/* The escape code to clear to end of line */
#define CLEAR_2_EOL "\033[K"
-/* These are the escape sequences corresponding to special keys */
enum {
- REAL_KEY_UP = 'A',
- REAL_KEY_DOWN = 'B',
- REAL_KEY_RIGHT = 'C',
- REAL_KEY_LEFT = 'D',
- REAL_PAGE_UP = '5',
- REAL_PAGE_DOWN = '6',
- REAL_KEY_HOME = '7', // vt100? linux vt? or what?
- REAL_KEY_END = '8',
- REAL_KEY_HOME_ALT = '1', // ESC [1~ (vt100? linux vt? or what?)
- REAL_KEY_END_ALT = '4', // ESC [4~
- REAL_KEY_HOME_XTERM = 'H',
- REAL_KEY_END_XTERM = 'F',
-
-/* These are the special codes assigned by this program to the special keys */
- KEY_UP = 20,
- KEY_DOWN = 21,
- KEY_RIGHT = 22,
- KEY_LEFT = 23,
- PAGE_UP = 24,
- PAGE_DOWN = 25,
- KEY_HOME = 26,
- KEY_END = 27,
-
/* Absolute max of lines eaten */
MAXLINES = CONFIG_FEATURE_LESS_MAXLINES,
-
/* This many "after the end" lines we will show (at max) */
TILDES = 1,
};
int kbd_fd; /* fd to get input from */
int less_gets_pos;
/* last position in last line, taking into account tabs */
- size_t linepos;
+ size_t last_line_pos;
unsigned max_fline;
unsigned max_lineno; /* this one tracks linewrap */
unsigned max_displayed_line;
#endif
smallint terminated;
struct termios term_orig, term_less;
+ char kbd_input[KEYCODE_BUFFER_SIZE];
};
#define G (*ptr_to_globals)
#define cur_fline (G.cur_fline )
#define kbd_fd (G.kbd_fd )
#define less_gets_pos (G.less_gets_pos )
-#define linepos (G.linepos )
+#define last_line_pos (G.last_line_pos )
#define max_fline (G.max_fline )
#define max_lineno (G.max_lineno )
#define max_displayed_line (G.max_displayed_line)
#define width (G.width )
#define winch_counter (G.winch_counter )
+/* This one is 100% not cached by compiler on read access */
+#define WINCH_COUNTER (*(volatile unsigned *)&winch_counter)
#define eof_error (G.eof_error )
#define readpos (G.readpos )
#define readeof (G.readeof )
#define terminated (G.terminated )
#define term_orig (G.term_orig )
#define term_less (G.term_less )
+#define kbd_input (G.kbd_input )
#define INIT_G() do { \
SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
less_gets_pos = -1; \
current_file = 1; \
eof_error = 1; \
terminated = 1; \
- USE_FEATURE_LESS_REGEXP(wanted_match = -1;) \
+ IF_FEATURE_LESS_REGEXP(wanted_match = -1;) \
} while (0)
/* flines[] are lines read from stdin, each in malloc'ed buffer.
exit(code);
}
-#if ENABLE_FEATURE_LESS_LINENUMS || ENABLE_FEATURE_LESS_WINCH
+#if (ENABLE_FEATURE_LESS_DASHCMD && ENABLE_FEATURE_LESS_LINENUMS) \
+ || ENABLE_FEATURE_LESS_WINCH
static void re_wrap(void)
{
int w = width;
- int rem;
+ int new_line_pos;
int src_idx;
int dst_idx;
int new_cur_fline = 0;
s = old_flines[0];
lineno = LINENO(s);
d = linebuf;
- rem = w;
+ new_line_pos = 0;
while (1) {
*d = *s;
if (*d != '\0') {
+ new_line_pos++;
+ if (*d == '\t') /* tab */
+ new_line_pos += 7;
s++;
d++;
- rem--;
- if (rem == 0) {
+ if (new_line_pos >= w) {
int sz;
/* new line is full, create next one */
*d = '\0';
new_flines = xrealloc_vector(new_flines, 8, dst_idx);
new_flines[dst_idx] = d;
dst_idx++;
- if (rem) {
- /* did we come here thru "goto next_new"? */
+ if (new_line_pos < w) {
+ /* if we came here thru "goto next_new" */
if (src_idx > max_fline)
break;
lineno = LINENO(s);
}
d = linebuf;
- rem = w;
+ new_line_pos = 0;
}
continue;
}
/* *d == NUL: old line ended, go to next old one */
free(MEMPTR(old_flines[src_idx]));
/* btw, convert cur_fline... */
- if (cur_fline == src_idx) {
+ if (cur_fline == src_idx)
new_cur_fline = dst_idx;
- }
src_idx++;
/* no more lines? finish last new line (and exit the loop) */
- if (src_idx > max_fline) {
+ if (src_idx > max_fline)
goto next_new;
- }
s = old_flines[src_idx];
if (lineno != LINENO(s)) {
/* this is not a continuation line!
flines = (const char **)new_flines;
max_fline = dst_idx - 1;
- linepos = 0; // XXX
+ last_line_pos = new_line_pos;
cur_fline = new_cur_fline;
/* max_lineno is screen-size independent */
+#if ENABLE_FEATURE_LESS_REGEXP
pattern_valid = 0;
+#endif
}
#endif
* on line wrap, only on "real" new lines.
* readbuf[0..readeof-1] - small preliminary buffer.
* readbuf[readpos] - next character to add to current line.
- * linepos - screen line position of next char to be read
+ * last_line_pos - screen line position of next char to be read
* (takes into account tabs and backspaces)
* eof_error - < 0 error, == 0 EOF, > 0 not EOF/error
*/
if (option_mask32 & FLAG_N)
w -= 8;
- USE_FEATURE_LESS_REGEXP(again0:)
+ IF_FEATURE_LESS_REGEXP(again0:)
p = current_line = ((char*)xmalloc(w + 4)) + 4;
max_fline += last_terminated;
strcpy(p, cp);
p += strlen(current_line);
free(MEMPTR(flines[max_fline]));
- /* linepos is still valid from previous read_lines() */
+ /* last_line_pos is still valid from previous read_lines() */
} else {
- linepos = 0;
+ last_line_pos = 0;
}
while (1) { /* read lines until we reach cur_fline or wanted_match */
/* backspace? [needed for manpages] */
/* <tab><bs> is (a) insane and */
/* (b) harder to do correctly, so we refuse to do it */
- if (c == '\x8' && linepos && p[-1] != '\t') {
+ if (c == '\x8' && last_line_pos && p[-1] != '\t') {
readpos++; /* eat it */
- linepos--;
+ last_line_pos--;
/* was buggy (p could end up <= current_line)... */
*--p = '\0';
continue;
}
{
- size_t new_linepos = linepos + 1;
+ size_t new_last_line_pos = last_line_pos + 1;
if (c == '\t') {
- new_linepos += 7;
- new_linepos &= (~7);
+ new_last_line_pos += 7;
+ new_last_line_pos &= (~7);
}
- if ((int)new_linepos >= w)
+ if ((int)new_last_line_pos >= w)
break;
- linepos = new_linepos;
+ last_line_pos = new_last_line_pos;
}
/* ok, we will eat this char */
readpos++;
if (c == '\n') {
terminated = 1;
- linepos = 0;
+ last_line_pos = 0;
break;
}
/* NUL is substituted by '\n'! */
max_fline++;
current_line = ((char*)xmalloc(w + 4)) + 4;
p = current_line;
- linepos = 0;
+ last_line_pos = 0;
} /* end of "read lines until we reach cur_fline" loop */
fill_match_lines(old_max_fline);
#if ENABLE_FEATURE_LESS_REGEXP
while (match_status == 0) {
char *new = xasprintf("%s%.*s"HIGHLIGHT"%.*s"NORMAL,
- growline ? : "",
+ growline ? growline : "",
match_structs.rm_so, str,
match_structs.rm_eo - match_structs.rm_so,
str + match_structs.rm_so);
static void open_file_and_read_lines(void)
{
if (filename) {
- int fd = xopen(filename, O_RDONLY);
- dup2(fd, 0);
- if (fd) close(fd);
+ xmove_fd(xopen(filename, O_RDONLY), STDIN_FILENO);
} else {
/* "less" with no arguments in argv[] */
/* For status line only */
}
readpos = 0;
readeof = 0;
- linepos = 0;
+ last_line_pos = 0;
terminated = 1;
read_lines();
}
buffer_fill_and_print();
}
-static ssize_t getch_nowait(char* input, int sz)
+static int getch_nowait(void)
{
- ssize_t rd;
+ int rd;
struct pollfd pfd[2];
pfd[0].fd = STDIN_FILENO;
* (switch fd into O_NONBLOCK'ed mode to avoid it)
*/
rd = 1;
- if (max_fline <= cur_fline + max_displayed_line
- && eof_error > 0 /* did NOT reach eof yet */
+ /* Are we interested in stdin? */
+//TODO: reuse code for determining this
+ if (!(option_mask32 & FLAG_S)
+ ? !(max_fline > cur_fline + max_displayed_line)
+ : !(max_fline >= cur_fline
+ && max_lineno > LINENO(flines[cur_fline]) + max_displayed_line)
) {
- /* We are interested in stdin */
- rd = 0;
+ if (eof_error > 0) /* did NOT reach eof yet */
+ rd = 0; /* yes, we are interested in stdin */
}
- /* position cursor if line input is done */
+ /* Position cursor if line input is done */
if (less_gets_pos >= 0)
move_cursor(max_displayed_line + 2, less_gets_pos + 1);
fflush(stdout);
+
+ if (kbd_input[0] == 0) { /* if nothing is buffered */
#if ENABLE_FEATURE_LESS_WINCH
- while (1) {
- int r;
- r = poll(pfd + rd, 2 - rd, -1);
- if (/*r < 0 && errno == EINTR &&*/ winch_counter) {
- input[0] = '\\'; /* anything which has no defined function */
- return 1;
+ while (1) {
+ int r;
+ /* NB: SIGWINCH interrupts poll() */
+ r = poll(pfd + rd, 2 - rd, -1);
+ if (/*r < 0 && errno == EINTR &&*/ winch_counter)
+ return '\\'; /* anything which has no defined function */
+ if (r) break;
}
- if (r) break;
- }
#else
- safe_poll(pfd + rd, 2 - rd, -1);
+ safe_poll(pfd + rd, 2 - rd, -1);
#endif
+ }
- input[0] = '\0';
- rd = safe_read(kbd_fd, input, sz); /* NB: kbd_fd is in O_NONBLOCK mode */
- if (rd < 0 && errno == EAGAIN) {
- /* No keyboard input -> we have input on stdin! */
- read_lines();
- buffer_fill_and_print();
- goto again;
+ /* We have kbd_fd in O_NONBLOCK mode, read inside read_key()
+ * would not block even if there is no input available */
+ rd = read_key(kbd_fd, kbd_input);
+ if (rd == -1) {
+ if (errno == EAGAIN) {
+ /* No keyboard input available. Since poll() did return,
+ * we should have input on stdin */
+ read_lines();
+ buffer_fill_and_print();
+ goto again;
+ }
+ /* EOF/error (ssh session got killed etc) */
+ less_exit(0);
}
set_tty_cooked();
return rd;
}
-/* Grab a character from input without requiring the return key. If the
- * character is ASCII \033, get more characters and assign certain sequences
- * special return codes. Note that this function works best with raw input. */
+/* Grab a character from input without requiring the return key.
+ * May return KEYCODE_xxx values.
+ * Note that this function works best with raw input. */
static int less_getch(int pos)
{
- unsigned char input[16];
- unsigned i;
+ int i;
again:
less_gets_pos = pos;
- memset(input, 0, sizeof(input));
- getch_nowait((char *)input, sizeof(input));
+ i = getch_nowait();
less_gets_pos = -1;
- /* Detect escape sequences (i.e. arrow keys) and handle
- * them accordingly */
- if (input[0] == '\033' && input[1] == '[') {
- i = input[2] - REAL_KEY_UP;
- if (i < 4)
- return 20 + i;
- i = input[2] - REAL_PAGE_UP;
- if (i < 4)
- return 24 + i;
- if (input[2] == REAL_KEY_HOME_XTERM)
- return KEY_HOME;
- if (input[2] == REAL_KEY_HOME_ALT)
- return KEY_HOME;
- if (input[2] == REAL_KEY_END_XTERM)
- return KEY_END;
- if (input[2] == REAL_KEY_END_ALT)
- return KEY_END;
- return 0;
- }
- /* Reject almost all control chars */
- i = input[0];
- if (i < ' ' && i != 0x0d && i != 8)
+ /* Discard Ctrl-something chars */
+ if (i >= 0 && i < ' ' && i != 0x0d && i != 8)
goto again;
return i;
}
static char* less_gets(int sz)
{
- char c;
+ int c;
unsigned i = 0;
char *result = xzalloc(1);
while (1) {
c = '\0';
less_gets_pos = sz + i;
- getch_nowait(&c, 1);
+ c = getch_nowait();
if (c == 0x0d) {
result[i] = '\0';
less_gets_pos = -1;
printf("\x8 \x8");
i--;
}
- if (c < ' ')
+ if (c < ' ') /* filters out KEYCODE_xxx too (<0) */
continue;
if (i >= width - sz - 1)
continue; /* len limit */
{
unsigned i;
int num;
+ int keypress;
char num_input[sizeof(int)*4]; /* more than enough */
- char keypress;
num_input[0] = first_digit;
/* Receive input until a letter is given */
i = 1;
while (i < sizeof(num_input)-1) {
- num_input[i] = less_getch(i + 1);
- if (!num_input[i] || !isdigit(num_input[i]))
+ keypress = less_getch(i + 1);
+ if ((unsigned)keypress > 255 || !isdigit(num_input[i]))
break;
- bb_putchar(num_input[i]);
+ num_input[i] = keypress;
+ bb_putchar(keypress);
i++;
}
- /* Take the final letter out of the digits string */
- keypress = num_input[i];
num_input[i] = '\0';
num = bb_strtou(num_input, NULL, 10);
/* on format error, num == -1 */
/* We now know the number and the letter entered, so we process them */
switch (keypress) {
- case KEY_DOWN: case 'z': case 'd': case 'e': case ' ': case '\015':
+ case KEYCODE_DOWN: case 'z': case 'd': case 'e': case ' ': case '\015':
buffer_down(num);
break;
- case KEY_UP: case 'b': case 'w': case 'y': case 'u':
+ case KEYCODE_UP: case 'b': case 'w': case 'y': case 'u':
buffer_up(num);
break;
case 'g': case '<': case 'G': case '>':
}
}
+#ifdef BLOAT
static void show_flag_status(void)
{
int keypress;
}
#endif
+#endif /* ENABLE_FEATURE_LESS_DASHCMD */
+
static void save_input_to_file(void)
{
const char *msg = "";
static void keypress_process(int keypress)
{
switch (keypress) {
- case KEY_DOWN: case 'e': case 'j': case 0x0d:
+ case KEYCODE_DOWN: case 'e': case 'j': case 0x0d:
buffer_down(1);
break;
- case KEY_UP: case 'y': case 'k':
+ case KEYCODE_UP: case 'y': case 'k':
buffer_up(1);
break;
- case PAGE_DOWN: case ' ': case 'z': case 'f':
+ case KEYCODE_PAGEDOWN: case ' ': case 'z': case 'f':
buffer_down(max_displayed_line + 1);
break;
- case PAGE_UP: case 'w': case 'b':
+ case KEYCODE_PAGEUP: case 'w': case 'b':
buffer_up(max_displayed_line + 1);
break;
case 'd':
case 'u':
buffer_up((max_displayed_line + 1) / 2);
break;
- case KEY_HOME: case 'g': case 'p': case '<': case '%':
+ case KEYCODE_HOME: case 'g': case 'p': case '<': case '%':
buffer_line(0);
break;
- case KEY_END: case 'G': case '>':
+ case KEYCODE_END: case 'G': case '>':
cur_fline = MAXLINES;
read_lines();
buffer_line(cur_fline);
flag_change();
buffer_print();
break;
+#ifdef BLOAT
case '_':
show_flag_status();
break;
#endif
+#endif
#if ENABLE_FEATURE_LESS_BRACKETS
case '{': case '(': case '[':
match_right_bracket(keypress);
/* TODO: -x: do not interpret backspace, -xx: tab also */
/* -xxx: newline also */
/* -w N: assume width N (-xxx -w 32: hex viewer of sorts) */
- getopt32(argv, "EMmN~I" USE_FEATURE_LESS_DASHCMD("S"));
+ getopt32(argv, "EMmN~I" IF_FEATURE_LESS_DASHCMD("S"));
argc -= optind;
argv += optind;
num_files = argc;
reinitialize();
while (1) {
#if ENABLE_FEATURE_LESS_WINCH
- if (winch_counter) {
+ while (WINCH_COUNTER) {
+ again:
winch_counter--;
get_terminal_width_height(kbd_fd, &width, &max_displayed_line);
/* 20: two tabstops + 4 */
max_displayed_line -= 2;
free(buffer);
buffer = xmalloc((max_displayed_line+1) * sizeof(char *));
+ /* Avoid re-wrap and/or redraw if we already know
+ * we need to do it again. These ops are expensive */
+ if (WINCH_COUNTER)
+ goto again;
re_wrap();
+ if (WINCH_COUNTER)
+ goto again;
buffer_fill_and_print();
+ /* This took some time. Loop back and check,
+ * were there another SIGWINCH? */
}
#endif
keypress = less_getch(-1); /* -1: do not position cursor */
projects / oweals / busybox.git / blobdiff