X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=miscutils%2Fless.c;h=0b0a9aed4be26e7290d9813cf946e5b25e2d44ca;hb=179e88bec91cfe58096900dc5509a080ff37b083;hp=0529b20479e4408db6c7f82a62fb326277b96406;hpb=5e25ddb7d369b6785ec3aaa96cbc0521c22aeb0d;p=oweals%2Fbusybox.git diff --git a/miscutils/less.c b/miscutils/less.c index 0529b2047..0b0a9aed4 100644 --- a/miscutils/less.c +++ b/miscutils/less.c @@ -4,7 +4,7 @@ * * Copyright (C) 2005 by Rob Sullivan * - * Licensed under the GPL v2 or later, see the file LICENSE in this tarball. + * Licensed under GPLv2 or later, see file LICENSE in this source tree. */ /* @@ -21,64 +21,144 @@ * redirected input has been read from stdin */ -#include /* sched_yield() */ +//config:config LESS +//config: bool "less" +//config: default y +//config: help +//config: 'less' is a pager, meaning that it displays text files. It possesses +//config: a wide array of features, and is an improvement over 'more'. +//config: +//config:config FEATURE_LESS_MAXLINES +//config: int "Max number of input lines less will try to eat" +//config: default 9999999 +//config: depends on LESS +//config: +//config:config FEATURE_LESS_BRACKETS +//config: bool "Enable bracket searching" +//config: default y +//config: depends on LESS +//config: help +//config: This option adds the capability to search for matching left and right +//config: brackets, facilitating programming. +//config: +//config:config FEATURE_LESS_FLAGS +//config: bool "Enable -m/-M" +//config: default y +//config: depends on LESS +//config: help +//config: The -M/-m flag enables a more sophisticated status line. +//config: +//config:config FEATURE_LESS_TRUNCATE +//config: bool "Enable -S" +//config: default y +//config: depends on LESS +//config: help +//config: The -S flag causes long lines to be truncated rather than +//config: wrapped. +//config: +//config:config FEATURE_LESS_MARKS +//config: bool "Enable marks" +//config: default y +//config: depends on LESS +//config: help +//config: Marks enable positions in a file to be stored for easy reference. +//config: +//config:config FEATURE_LESS_REGEXP +//config: bool "Enable regular expressions" +//config: default y +//config: depends on LESS +//config: help +//config: Enable regular expressions, allowing complex file searches. +//config: +//config:config FEATURE_LESS_WINCH +//config: bool "Enable automatic resizing on window size changes" +//config: default y +//config: depends on LESS +//config: help +//config: Makes less track window size changes. +//config: +//config:config FEATURE_LESS_ASK_TERMINAL +//config: bool "Use 'tell me cursor position' ESC sequence to measure window" +//config: default y +//config: depends on FEATURE_LESS_WINCH +//config: help +//config: Makes less track window size changes. +//config: If terminal size can't be retrieved and $LINES/$COLUMNS are not set, +//config: this option makes less perform a last-ditch effort to find it: +//config: position cursor to 999,999 and ask terminal to report real +//config: cursor position using "ESC [ 6 n" escape sequence, then read stdin. +//config: This is not clean but helps a lot on serial lines and such. +//config: +//config:config FEATURE_LESS_DASHCMD +//config: bool "Enable flag changes ('-' command)" +//config: default y +//config: depends on LESS +//config: help +//config: This enables the ability to change command-line flags within +//config: less itself ('-' keyboard command). +//config: +//config:config FEATURE_LESS_LINENUMS +//config: bool "Enable -N (dynamic switching of line numbers)" +//config: default y +//config: depends on FEATURE_LESS_DASHCMD + +//applet:IF_LESS(APPLET(less, BB_DIR_USR_BIN, BB_SUID_DROP)) + +//kbuild:lib-$(CONFIG_LESS) += less.o + +//usage:#define less_trivial_usage +//usage: "[-E" IF_FEATURE_LESS_REGEXP("I")IF_FEATURE_LESS_FLAGS("Mm") +//usage: "N" IF_FEATURE_LESS_TRUNCATE("S") "h~] [FILE]..." +//usage:#define less_full_usage "\n\n" +//usage: "View FILE (or stdin) one screenful at a time\n" +//usage: "\n -E Quit once the end of a file is reached" +//usage: IF_FEATURE_LESS_REGEXP( +//usage: "\n -I Ignore case in all searches" +//usage: ) +//usage: IF_FEATURE_LESS_FLAGS( +//usage: "\n -M,-m Display status line with line numbers" +//usage: "\n and percentage through the file" +//usage: ) +//usage: "\n -N Prefix line number to each line" +//usage: IF_FEATURE_LESS_TRUNCATE( +//usage: "\n -S Truncate long lines" +//usage: ) +//usage: "\n -~ Suppress ~s displayed past EOF" + +#include /* sched_yield() */ #include "libbb.h" +#include "common_bufsiz.h" #if ENABLE_FEATURE_LESS_REGEXP #include "xregex.h" #endif -/* FIXME: currently doesn't work right */ -#undef ENABLE_FEATURE_LESS_FLAGCS -#define ENABLE_FEATURE_LESS_FLAGCS 0 +#define ESC "\033" /* The escape codes for highlighted and normal text */ -#define HIGHLIGHT "\033[7m" -#define NORMAL "\033[0m" -/* The escape code to clear the screen */ -#define CLEAR "\033[H\033[J" -/* 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, +#define HIGHLIGHT ESC"[7m" +#define NORMAL ESC"[0m" +/* The escape code to home and clear to the end of screen */ +#define CLEAR ESC"[H\033[J" +/* The escape code to clear to the end of line */ +#define CLEAR_2_EOL ESC"[K" +enum { /* Absolute max of lines eaten */ MAXLINES = CONFIG_FEATURE_LESS_MAXLINES, - /* This many "after the end" lines we will show (at max) */ TILDES = 1, }; /* Command line options */ enum { - FLAG_E = 1, + FLAG_E = 1 << 0, FLAG_M = 1 << 1, FLAG_m = 1 << 2, FLAG_N = 1 << 3, FLAG_TILDE = 1 << 4, + FLAG_I = 1 << 5, + FLAG_S = (1 << 6) * ENABLE_FEATURE_LESS_TRUNCATE, /* hijack command line options variable for internal state vars */ LESS_STATE_MATCH_BACKWARDS = 1 << 15, }; @@ -90,13 +170,17 @@ enum { pattern_valid = 0 }; struct globals { int cur_fline; /* signed */ int kbd_fd; /* fd to get input from */ + int kbd_fd_orig_flags; int less_gets_pos; /* last position in last line, taking into account tabs */ - size_t linepos; - unsigned max_displayed_line; + size_t last_line_pos; unsigned max_fline; unsigned max_lineno; /* this one tracks linewrap */ + unsigned max_displayed_line; unsigned width; +#if ENABLE_FEATURE_LESS_WINCH + unsigned winch_counter; +#endif ssize_t eof_error; /* eof if 0, error if < 0 */ ssize_t readpos; ssize_t readeof; /* must be signed */ @@ -107,6 +191,12 @@ struct globals { unsigned current_file; char *filename; char **files; +#if ENABLE_FEATURE_LESS_FLAGS + int num_lines; /* a flag if < 0, line count if >= 0 */ +# define REOPEN_AND_COUNT (-1) +# define REOPEN_STDIN (-2) +# define NOT_REGULAR_FILE (-3) +#endif #if ENABLE_FEATURE_LESS_MARKS unsigned num_marks; unsigned mark_lines[15][2]; @@ -118,19 +208,26 @@ struct globals { int num_matches; regex_t pattern; smallint pattern_valid; +#endif +#if ENABLE_FEATURE_LESS_ASK_TERMINAL + smallint winsize_err; #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 max_displayed_line (G.max_displayed_line) +#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 ) @@ -141,6 +238,7 @@ struct globals { #define current_file (G.current_file ) #define filename (G.filename ) #define files (G.files ) +#define num_lines (G.num_lines ) #define num_marks (G.num_marks ) #define mark_lines (G.mark_lines ) #if ENABLE_FEATURE_LESS_REGEXP @@ -154,6 +252,7 @@ struct globals { #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; \ @@ -162,36 +261,34 @@ struct globals { 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. + * Line numbers are stored as uint32_t prepended to each line. + * Pointer is adjusted so that flines[i] points directly past + * line number. Accesor: */ +#define MEMPTR(p) ((char*)(p) - 4) +#define LINENO(p) (*(uint32_t*)((p) - 4)) + + /* Reset terminal input to normal */ static void set_tty_cooked(void) { - fflush(stdout); + fflush_all(); tcsetattr(kbd_fd, TCSANOW, &term_orig); } -/* Exit the program gracefully */ -static void less_exit(int code) -{ - bb_putchar('\n'); - set_tty_cooked(); - if (code < 0) - kill_myself_with_sig(- code); /* does not return */ - exit(code); -} - /* Move the cursor to a position (x,y), where (0,0) is the top-left corner of the console */ static void move_cursor(int line, int row) { - printf("\033[%u;%uH", line, row); + printf(ESC"[%u;%uH", line, row); } static void clear_line(void) { - printf("\033[%u;0H" CLEAR_2_EOL, max_displayed_line + 2); + printf(ESC"[%u;0H" CLEAR_2_EOL, max_displayed_line + 2); } static void print_hilite(const char *str) @@ -205,12 +302,120 @@ static void print_statusline(const char *str) printf(HIGHLIGHT"%.*s"NORMAL, width - 1, str); } +/* Exit the program gracefully */ +static void less_exit(int code) +{ + set_tty_cooked(); + if (!(G.kbd_fd_orig_flags & O_NONBLOCK)) + ndelay_off(kbd_fd); + clear_line(); + if (code < 0) + kill_myself_with_sig(- code); /* does not return */ + exit(code); +} + +#if (ENABLE_FEATURE_LESS_DASHCMD && ENABLE_FEATURE_LESS_LINENUMS) \ + || ENABLE_FEATURE_LESS_WINCH +static void re_wrap(void) +{ + int w = width; + int new_line_pos; + int src_idx; + int dst_idx; + int new_cur_fline = 0; + uint32_t lineno; + char linebuf[w + 1]; + const char **old_flines = flines; + const char *s; + char **new_flines = NULL; + char *d; + + if (option_mask32 & FLAG_N) + w -= 8; + + src_idx = 0; + dst_idx = 0; + s = old_flines[0]; + lineno = LINENO(s); + d = linebuf; + new_line_pos = 0; + while (1) { + *d = *s; + if (*d != '\0') { + new_line_pos++; + if (*d == '\t') { /* tab */ + new_line_pos += 7; + new_line_pos &= (~7); + } + s++; + d++; + if (new_line_pos >= w) { + int sz; + /* new line is full, create next one */ + *d = '\0'; + next_new: + sz = (d - linebuf) + 1; /* + 1: NUL */ + d = ((char*)xmalloc(sz + 4)) + 4; + LINENO(d) = lineno; + memcpy(d, linebuf, sz); + new_flines = xrealloc_vector(new_flines, 8, dst_idx); + new_flines[dst_idx] = d; + dst_idx++; + if (new_line_pos < w) { + /* if we came here thru "goto next_new" */ + if (src_idx > max_fline) + break; + lineno = LINENO(s); + } + d = linebuf; + 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) + new_cur_fline = dst_idx; + src_idx++; + /* no more lines? finish last new line (and exit the loop) */ + if (src_idx > max_fline) + goto next_new; + s = old_flines[src_idx]; + if (lineno != LINENO(s)) { + /* this is not a continuation line! + * create next _new_ line too */ + goto next_new; + } + } + + free(old_flines); + flines = (const char **)new_flines; + + max_fline = dst_idx - 1; + 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 + #if ENABLE_FEATURE_LESS_REGEXP static void fill_match_lines(unsigned pos); #else #define fill_match_lines(pos) ((void)0) #endif +static int at_end(void) +{ + return (option_mask32 & FLAG_S) + ? !(cur_fline <= max_fline && + max_lineno > LINENO(flines[cur_fline]) + max_displayed_line) + : !(max_fline > cur_fline + max_displayed_line); +} + /* Devilishly complex routine. * * Has to deal with EOF and EPIPE on input, @@ -230,39 +435,43 @@ static void fill_match_lines(unsigned pos); * 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 + * + * "git log -p | less -m" on the kernel git tree is a good test for EAGAINs, + * "/search on very long input" and "reaching max line count" corner cases. */ static void read_lines(void) { -#define readbuf bb_common_bufsiz1 char *current_line, *p; int w = width; char last_terminated = terminated; + time_t last_time = 0; + int retry_EAGAIN = 2; #if ENABLE_FEATURE_LESS_REGEXP unsigned old_max_fline = max_fline; - time_t last_time = 0; - unsigned seconds_p1 = 3; /* seconds_to_loop + 1 */ #endif +#define readbuf bb_common_bufsiz1 + setup_common_bufsiz(); + + /* (careful: max_fline can be -1) */ + if (max_fline + 1 > MAXLINES) + return; + if (option_mask32 & FLAG_N) w -= 8; - USE_FEATURE_LESS_REGEXP(again0:) - - p = current_line = xmalloc(w); - max_fline += last_terminated; + p = current_line = ((char*)xmalloc(w + 5)) + 4; if (!last_terminated) { const char *cp = flines[max_fline]; - if (option_mask32 & FLAG_N) - cp += 8; - strcpy(current_line, cp); - p += strlen(current_line); - free((char*)flines[max_fline]); - /* linepos is still valid from previous read_lines() */ + p = stpcpy(p, cp); + free(MEMPTR(cp)); + /* last_line_pos is still valid from previous read_lines() */ } else { - linepos = 0; + max_fline++; + last_line_pos = 0; } while (1) { /* read lines until we reach cur_fline or wanted_match */ @@ -272,40 +481,56 @@ static void read_lines(void) char c; /* if no unprocessed chars left, eat more */ if (readpos >= readeof) { - ndelay_on(0); - eof_error = safe_read(STDIN_FILENO, readbuf, sizeof(readbuf)); - ndelay_off(0); + int flags = ndelay_on(0); + + while (1) { + time_t t; + + errno = 0; + eof_error = safe_read(STDIN_FILENO, readbuf, COMMON_BUFSIZE); + if (errno != EAGAIN) + break; + t = time(NULL); + if (t != last_time) { + last_time = t; + if (--retry_EAGAIN < 0) + break; + } + sched_yield(); + } + fcntl(0, F_SETFL, flags); /* ndelay_off(0) */ readpos = 0; readeof = eof_error; if (eof_error <= 0) goto reached_eof; + retry_EAGAIN = 1; } c = readbuf[readpos]; /* backspace? [needed for manpages] */ /* 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'! */ @@ -313,6 +538,11 @@ static void read_lines(void) *p++ = c; *p = '\0'; } /* end of "read chars until we have a line" loop */ +#if 0 +//BUG: also triggers on this: +// { printf "\nfoo\n"; sleep 1; printf "\nbar\n"; } | less +// (resulting in lost empty line between "foo" and "bar" lines) +// the "terminated" logic needs fixing (or explaining) /* Corner case: linewrap with only "" wrapping to next line */ /* Looks ugly on screen, so we do not store this empty line */ if (!last_terminated && !current_line[0]) { @@ -320,25 +550,21 @@ static void read_lines(void) max_lineno++; continue; } +#endif reached_eof: last_terminated = terminated; - flines = xrealloc(flines, (max_fline+1) * sizeof(char *)); - if (option_mask32 & FLAG_N) { - /* Width of 7 preserves tab spacing in the text */ - flines[max_fline] = xasprintf( - (max_lineno <= 9999999) ? "%7u %s" : "%07u %s", - max_lineno % 10000000, current_line); - free(current_line); - if (terminated) - max_lineno++; - } else { - flines[max_fline] = xrealloc(current_line, strlen(current_line)+1); - } + flines = xrealloc_vector(flines, 8, max_fline); + + flines[max_fline] = (char*)xrealloc(MEMPTR(current_line), strlen(current_line) + 1 + 4) + 4; + LINENO(flines[max_fline]) = max_lineno; + if (terminated) + max_lineno++; + if (max_fline >= MAXLINES) { eof_error = 0; /* Pretend we saw EOF */ break; } - if (max_fline > cur_fline + max_displayed_line) { + if (!at_end()) { #if !ENABLE_FEATURE_LESS_REGEXP break; #else @@ -351,38 +577,26 @@ static void read_lines(void) #endif } if (eof_error <= 0) { - if (eof_error < 0) { - if (errno == EAGAIN) { - /* not yet eof or error, reset flag (or else - * we will hog CPU - select() will return - * immediately */ - eof_error = 1; - } else { - print_statusline("read error"); - } - } -#if !ENABLE_FEATURE_LESS_REGEXP break; -#else - if (wanted_match < num_matches) { - break; - } else { /* goto_match called us */ - time_t t = time(NULL); - if (t != last_time) { - last_time = t; - if (--seconds_p1 == 0) - break; - } - sched_yield(); - goto again0; /* go loop again (max 2 seconds) */ - } -#endif } max_fline++; - current_line = xmalloc(w); + current_line = ((char*)xmalloc(w + 5)) + 4; p = current_line; - linepos = 0; + last_line_pos = 0; } /* end of "read lines until we reach cur_fline" loop */ + + if (eof_error < 0) { + if (errno == EAGAIN) { + eof_error = 1; + } else { + print_statusline(bb_msg_read_error); + } + } +#if ENABLE_FEATURE_LESS_FLAGS + else if (eof_error == 0) + num_lines = max_lineno; +#endif + fill_match_lines(old_max_fline); #if ENABLE_FEATURE_LESS_REGEXP /* prevent us from being stuck in search for a match */ @@ -392,37 +606,89 @@ static void read_lines(void) } #if ENABLE_FEATURE_LESS_FLAGS -/* Interestingly, writing calc_percent as a function saves around 32 bytes - * on my build. */ -static int calc_percent(void) +static int safe_lineno(int fline) +{ + if (fline >= max_fline) + fline = max_fline - 1; + + /* also catches empty file (max_fline == 0) */ + if (fline < 0) + return 0; + + return LINENO(flines[fline]) + 1; +} + +/* count number of lines in file */ +static void update_num_lines(void) { - unsigned p = (100 * (cur_fline+max_displayed_line+1) + max_fline/2) / (max_fline+1); - return p <= 100 ? p : 100; + int count, fd; + struct stat stbuf; + ssize_t len, i; + char buf[4096]; + + /* only do this for regular files */ + if (num_lines == REOPEN_AND_COUNT || num_lines == REOPEN_STDIN) { + count = 0; + fd = open("/proc/self/fd/0", O_RDONLY); + if (fd < 0 && num_lines == REOPEN_AND_COUNT) { + /* "filename" is valid only if REOPEN_AND_COUNT */ + fd = open(filename, O_RDONLY); + } + if (fd < 0) { + /* somebody stole my file! */ + num_lines = NOT_REGULAR_FILE; + return; + } + if (fstat(fd, &stbuf) != 0 || !S_ISREG(stbuf.st_mode)) { + num_lines = NOT_REGULAR_FILE; + goto do_close; + } + while ((len = safe_read(fd, buf, sizeof(buf))) > 0) { + for (i = 0; i < len; ++i) { + if (buf[i] == '\n' && ++count == MAXLINES) + goto done; + } + } + done: + num_lines = count; + do_close: + close(fd); + } } /* Print a status line if -M was specified */ static void m_status_print(void) { - int percentage; + int first, last; + unsigned percent; - if (less_gets_pos >= 0) /* don't touch statusline while input is done! */ + if (less_gets_pos >= 0) /* don't touch statusline while input is done! */ return; clear_line(); printf(HIGHLIGHT"%s", filename); if (num_files > 1) printf(" (file %i of %i)", current_file, num_files); - printf(" lines %i-%i/%i ", - cur_fline + 1, cur_fline + max_displayed_line + 1, - max_fline + 1); - if (cur_fline >= (int)(max_fline - max_displayed_line)) { - printf("(END)"NORMAL); + + first = safe_lineno(cur_fline); + last = (option_mask32 & FLAG_S) + ? MIN(first + max_displayed_line, max_lineno) + : safe_lineno(cur_fline + max_displayed_line); + printf(" lines %i-%i", first, last); + + update_num_lines(); + if (num_lines >= 0) + printf("/%i", num_lines); + + if (at_end()) { + printf(" (END)"); if (num_files > 1 && current_file != num_files) - printf(HIGHLIGHT" - next: %s"NORMAL, files[current_file]); - return; + printf(" - next: %s", files[current_file]); + } else if (num_lines > 0) { + percent = (100 * last + num_lines/2) / num_lines; + printf(" %i%%", percent <= 100 ? percent : 100); } - percentage = calc_percent(); - printf("%i%%"NORMAL, percentage); + printf(NORMAL); } #endif @@ -431,7 +697,7 @@ static void status_print(void) { const char *p; - if (less_gets_pos >= 0) /* don't touch statusline while input is done! */ + if (less_gets_pos >= 0) /* don't touch statusline while input is done! */ return; /* Change the status if flags have been set */ @@ -444,7 +710,7 @@ static void status_print(void) #endif clear_line(); - if (cur_fline && cur_fline < (int)(max_fline - max_displayed_line)) { + if (cur_fline && !at_end()) { bb_putchar(':'); return; } @@ -459,33 +725,35 @@ static void status_print(void) print_hilite(p); } -static void cap_cur_fline(int nlines) -{ - int diff; - if (cur_fline < 0) - cur_fline = 0; - if (cur_fline + max_displayed_line > max_fline + TILDES) { - cur_fline -= nlines; - if (cur_fline < 0) - cur_fline = 0; - diff = max_fline - (cur_fline + max_displayed_line) + TILDES; - /* As the number of lines requested was too large, we just move - to the end of the file */ - if (diff > 0) - cur_fline += diff; - } -} - static const char controls[] ALIGN1 = /* NUL: never encountered; TAB: not converted */ /**/"\x01\x02\x03\x04\x05\x06\x07\x08" "\x0a\x0b\x0c\x0d\x0e\x0f" "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f" "\x7f\x9b"; /* DEL and infamous Meta-ESC :( */ static const char ctrlconv[] ALIGN1 = - /* '\n': it's a former NUL - subst with '@', not 'J' */ + /* why 40 instead of 4a below? - it is a replacement for '\n'. + * '\n' is a former NUL - we subst it with @, not J */ "\x40\x41\x42\x43\x44\x45\x46\x47\x48\x49\x40\x4b\x4c\x4d\x4e\x4f" "\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c\x5d\x5e\x5f"; +static void print_lineno(const char *line) +{ + const char *fmt = " "; + unsigned n = n; /* for compiler */ + + if (line != empty_line_marker) { + /* Width of 7 preserves tab spacing in the text */ + fmt = "%7u "; + n = LINENO(line) + 1; + if (n > 9999999 && MAXLINES > 9999999) { + n %= 10000000; + fmt = "%07u "; + } + } + printf(fmt, n); +} + + #if ENABLE_FEATURE_LESS_REGEXP static void print_found(const char *line) { @@ -494,7 +762,7 @@ static void print_found(const char *line) char *growline; regmatch_t match_structs; - char buf[width]; + char buf[width+1]; const char *str = line; char *p = buf; size_t n; @@ -517,9 +785,9 @@ static void print_found(const char *line) /* buf[] holds quarantined version of str */ /* Each part of the line that matches has the HIGHLIGHT - and NORMAL escape sequences placed around it. - NB: we regex against line, but insert text - from quarantined copy (buf[]) */ + * and NORMAL escape sequences placed around it. + * NB: we regex against line, but insert text + * from quarantined copy (buf[]) */ str = buf; growline = NULL; eflags = 0; @@ -527,24 +795,24 @@ static void print_found(const char *line) while (match_status == 0) { char *new = xasprintf("%s%.*s"HIGHLIGHT"%.*s"NORMAL, - growline ? : "", - match_structs.rm_so, str, - match_structs.rm_eo - match_structs.rm_so, + growline ? growline : "", + (int)match_structs.rm_so, str, + (int)(match_structs.rm_eo - match_structs.rm_so), str + match_structs.rm_so); - free(growline); growline = new; + free(growline); + growline = new; str += match_structs.rm_eo; line += match_structs.rm_eo; eflags = REG_NOTBOL; start: /* Most of the time doesn't find the regex, optimize for that */ match_status = regexec(&pattern, line, 1, &match_structs, eflags); + /* if even "" matches, treat it as "not a match" */ + if (match_structs.rm_so >= match_structs.rm_eo) + match_status = 1; } - if (!growline) { - printf(CLEAR_2_EOL"%s\n", str); - return; - } - printf(CLEAR_2_EOL"%s%s\n", growline, str); + printf("%s%s\n", growline ? growline : "", str); free(growline); } #else @@ -553,11 +821,10 @@ void print_found(const char *line); static void print_ascii(const char *str) { - char buf[width]; + char buf[width+1]; char *p; size_t n; - printf(CLEAR_2_EOL); while (*str) { n = strcspn(str, controls); if (n) { @@ -590,71 +857,169 @@ static void buffer_print(void) unsigned i; move_cursor(0, 0); - for (i = 0; i <= max_displayed_line; i++) + for (i = 0; i <= max_displayed_line; i++) { + printf(CLEAR_2_EOL); + if (option_mask32 & FLAG_N) + print_lineno(buffer[i]); if (pattern_valid) print_found(buffer[i]); else print_ascii(buffer[i]); + } + if ((option_mask32 & FLAG_E) + && eof_error <= 0 + && (max_fline - cur_fline) <= max_displayed_line + ) { + less_exit(EXIT_SUCCESS); + } status_print(); } static void buffer_fill_and_print(void) { unsigned i; +#if ENABLE_FEATURE_LESS_TRUNCATE + int fpos = cur_fline; + + if (option_mask32 & FLAG_S) { + /* Go back to the beginning of this line */ + while (fpos && LINENO(flines[fpos]) == LINENO(flines[fpos-1])) + fpos--; + } + + i = 0; + while (i <= max_displayed_line && fpos <= max_fline) { + int lineno = LINENO(flines[fpos]); + buffer[i] = flines[fpos]; + i++; + do { + fpos++; + } while ((fpos <= max_fline) + && (option_mask32 & FLAG_S) + && lineno == LINENO(flines[fpos]) + ); + } +#else for (i = 0; i <= max_displayed_line && cur_fline + i <= max_fline; i++) { buffer[i] = flines[cur_fline + i]; } +#endif for (; i <= max_displayed_line; i++) { buffer[i] = empty_line_marker; } buffer_print(); } +/* move cur_fline to a given line number, reading lines if necessary */ +static void goto_lineno(int target) +{ + if (target <= 0 ) { + cur_fline = 0; + } + else if (target > LINENO(flines[cur_fline])) { + retry: + while (LINENO(flines[cur_fline]) != target && cur_fline < max_fline) + ++cur_fline; + /* target not reached but more input is available */ + if (LINENO(flines[cur_fline]) != target && eof_error > 0) { + read_lines(); + goto retry; + } + } + else { + /* search backwards through already-read lines */ + while (LINENO(flines[cur_fline]) != target && cur_fline > 0) + --cur_fline; + } +} + +static void cap_cur_fline(void) +{ + if ((option_mask32 & FLAG_S)) { + if (cur_fline > max_fline) + cur_fline = max_fline; + if (LINENO(flines[cur_fline]) + max_displayed_line > max_lineno + TILDES) { + goto_lineno(max_lineno - max_displayed_line + TILDES); + read_lines(); + } + } + else { + if (cur_fline + max_displayed_line > max_fline + TILDES) + cur_fline = max_fline - max_displayed_line + TILDES; + if (cur_fline < 0) + cur_fline = 0; + } +} + /* Move the buffer up and down in the file in order to scroll */ static void buffer_down(int nlines) { - cur_fline += nlines; + if ((option_mask32 & FLAG_S)) + goto_lineno(LINENO(flines[cur_fline]) + nlines); + else + cur_fline += nlines; read_lines(); - cap_cur_fline(nlines); + cap_cur_fline(); buffer_fill_and_print(); } static void buffer_up(int nlines) { - cur_fline -= nlines; - if (cur_fline < 0) cur_fline = 0; + if ((option_mask32 & FLAG_S)) { + goto_lineno(LINENO(flines[cur_fline]) - nlines); + } + else { + cur_fline -= nlines; + if (cur_fline < 0) + cur_fline = 0; + } read_lines(); buffer_fill_and_print(); } -static void buffer_line(int linenum) +/* display a given line where the argument can be either an index into + * the flines array or a line number */ +static void buffer_to_line(int linenum, int is_lineno) { - if (linenum < 0) - linenum = 0; - cur_fline = linenum; + if (linenum <= 0) + cur_fline = 0; + else if (is_lineno) + goto_lineno(linenum); + else + cur_fline = linenum; read_lines(); - if (linenum + max_displayed_line > max_fline) - linenum = max_fline - max_displayed_line + TILDES; - if (linenum < 0) - linenum = 0; - cur_fline = linenum; + cap_cur_fline(); buffer_fill_and_print(); } +static void buffer_line(int linenum) +{ + buffer_to_line(linenum, FALSE); +} + +static void buffer_lineno(int lineno) +{ + buffer_to_line(lineno, TRUE); +} + 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); +#if ENABLE_FEATURE_LESS_FLAGS + num_lines = REOPEN_AND_COUNT; +#endif } else { /* "less" with no arguments in argv[] */ /* For status line only */ filename = xstrdup(bb_msg_standard_input); +#if ENABLE_FEATURE_LESS_FLAGS + num_lines = REOPEN_STDIN; +#endif } readpos = 0; readeof = 0; - linepos = 0; + last_line_pos = 0; terminated = 1; read_lines(); } @@ -666,7 +1031,7 @@ static void reinitialize(void) if (flines) { for (i = 0; i <= max_fline; i++) - free((void*)(flines[i])); + free(MEMPTR(flines[i])); free(flines); flines = NULL; } @@ -675,12 +1040,17 @@ static void reinitialize(void) cur_fline = 0; max_lineno = 0; open_file_and_read_lines(); +#if ENABLE_FEATURE_LESS_ASK_TERMINAL + if (G.winsize_err) + printf("\033[999;999H" "\033[6n"); +#endif buffer_fill_and_print(); } -static ssize_t getch_nowait(char* input, int sz) +static int64_t getch_nowait(void) { - ssize_t rd; + int rd; + int64_t key64; struct pollfd pfd[2]; pfd[0].fd = STDIN_FILENO; @@ -696,80 +1066,82 @@ static ssize_t getch_nowait(char* input, int sz) * (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 */ - ) { - /* We are interested in stdin */ - rd = 0; + /* Are we interested in stdin? */ + if (at_end()) { + 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); - safe_poll(pfd + rd, 2 - rd, -1); + fflush_all(); + + if (kbd_input[0] == 0) { /* if nothing is buffered */ +#if ENABLE_FEATURE_LESS_WINCH + 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; + } +#else + 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 */ + key64 = read_key(kbd_fd, kbd_input, /*timeout off:*/ -2); + if ((int)key64 == -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; + return key64; } -/* 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. */ -static int less_getch(int pos) +/* 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 int64_t less_getch(int pos) { - unsigned char input[16]; - unsigned i; + int64_t key64; + int key; again: less_gets_pos = pos; - memset(input, 0, sizeof(input)); - getch_nowait((char *)input, sizeof(input)); + key = key64 = 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. + * (checking only lower 32 bits is a size optimization: + * upper 32 bits are used only by KEYCODE_CURSOR_POS) + */ + if (key >= 0 && key < ' ' && key != 0x0d && key != 8) goto again; - return i; + + return key64; } 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; @@ -781,7 +1153,7 @@ static char* less_gets(int sz) printf("\x8 \x8"); i--; } - if (c < ' ') + if (c < ' ') /* filters out KEYCODE_xxx too (<0) */ continue; if (i >= width - sz - 1) continue; /* len limit */ @@ -930,7 +1302,7 @@ static void fill_match_lines(unsigned pos) /* and we didn't match it last time */ && !(num_matches && match_lines[num_matches-1] == pos) ) { - match_lines = xrealloc(match_lines, (num_matches+1) * sizeof(int)); + match_lines = xrealloc_vector(match_lines, 4, num_matches); match_lines[num_matches++] = pos; } pos++; @@ -962,7 +1334,8 @@ static void regex_process(void) } /* Compile the regex and check for errors */ - err = regcomp_or_errmsg(&pattern, uncomp_regex, 0); + err = regcomp_or_errmsg(&pattern, uncomp_regex, + (option_mask32 & FLAG_I) ? REG_ICASE : 0); free(uncomp_regex); if (err) { print_statusline(err); @@ -992,8 +1365,8 @@ static void number_process(int first_digit) { unsigned i; int num; + int keypress; char num_input[sizeof(int)*4]; /* more than enough */ - char keypress; num_input[0] = first_digit; @@ -1004,15 +1377,14 @@ static void number_process(int 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(keypress)) 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 */ @@ -1023,22 +1395,23 @@ static void number_process(int first_digit) /* 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 '>': - cur_fline = num + max_displayed_line; - read_lines(); - buffer_line(num - 1); + buffer_lineno(num - 1); break; case 'p': case '%': - num = num * (max_fline / 100); /* + max_fline / 2; */ - cur_fline = num + max_displayed_line; - read_lines(); - buffer_line(num); +#if ENABLE_FEATURE_LESS_FLAGS + update_num_lines(); + num = num * (num_lines > 0 ? num_lines : max_lineno) / 100; +#else + num = num * max_lineno / 100; +#endif + buffer_lineno(num); break; #if ENABLE_FEATURE_LESS_REGEXP case 'n': @@ -1056,7 +1429,7 @@ static void number_process(int first_digit) } } -#if ENABLE_FEATURE_LESS_FLAGCS +#if ENABLE_FEATURE_LESS_DASHCMD static void flag_change(void) { int keypress; @@ -1078,9 +1451,23 @@ static void flag_change(void) case '~': option_mask32 ^= FLAG_TILDE; break; +#if ENABLE_FEATURE_LESS_TRUNCATE + case 'S': + option_mask32 ^= FLAG_S; + buffer_fill_and_print(); + break; +#endif +#if ENABLE_FEATURE_LESS_LINENUMS + case 'N': + option_mask32 ^= FLAG_N; + re_wrap(); + buffer_fill_and_print(); + break; +#endif } } +#ifdef BLOAT static void show_flag_status(void) { int keypress; @@ -1116,6 +1503,8 @@ static void show_flag_status(void) } #endif +#endif /* ENABLE_FEATURE_LESS_DASHCMD */ + static void save_input_to_file(void) { const char *msg = ""; @@ -1126,7 +1515,7 @@ static void save_input_to_file(void) print_statusline("Log file: "); current_line = less_gets(sizeof("Log file: ")-1); if (current_line[0]) { - fp = fopen(current_line, "w"); + fp = fopen_for_write(current_line); if (!fp) { msg = "Error opening log file"; goto ret; @@ -1204,16 +1593,23 @@ static char opp_bracket(char bracket) static void match_right_bracket(char bracket) { - unsigned i; + unsigned i = cur_fline; - if (strchr(flines[cur_fline], bracket) == NULL) { + if (i >= max_fline + || strchr(flines[i], bracket) == NULL + ) { print_statusline("No bracket in top line"); return; } + bracket = opp_bracket(bracket); - for (i = cur_fline + 1; i < max_fline; i++) { + for (; i < max_fline; i++) { if (strchr(flines[i], bracket) != NULL) { - buffer_line(i); + /* + * Line with matched right bracket becomes + * last visible line + */ + buffer_line(i - max_displayed_line); return; } } @@ -1222,16 +1618,22 @@ static void match_right_bracket(char bracket) static void match_left_bracket(char bracket) { - int i; + int i = cur_fline + max_displayed_line; - if (strchr(flines[cur_fline + max_displayed_line], bracket) == NULL) { + if (i >= max_fline + || strchr(flines[i], bracket) == NULL + ) { print_statusline("No bracket in bottom line"); return; } bracket = opp_bracket(bracket); - for (i = cur_fline + max_displayed_line; i >= 0; i--) { + for (; i >= 0; i--) { if (strchr(flines[i], bracket) != NULL) { + /* + * Line with matched left bracket becomes + * first visible line + */ buffer_line(i); return; } @@ -1243,16 +1645,16 @@ static void match_left_bracket(char bracket) 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': @@ -1261,10 +1663,10 @@ static void keypress_process(int keypress) 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); @@ -1283,6 +1685,9 @@ static void keypress_process(int keypress) break; #endif case 'r': case 'R': + /* TODO: (1) also bind ^R, ^L to this? + * (2) re-measure window size? + */ buffer_print(); break; /*case 'R': @@ -1315,15 +1720,17 @@ static void keypress_process(int keypress) regex_process(); break; #endif -#if ENABLE_FEATURE_LESS_FLAGCS +#if ENABLE_FEATURE_LESS_DASHCMD case '-': 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); @@ -1346,17 +1753,28 @@ static void sig_catcher(int sig) less_exit(- sig); } +#if ENABLE_FEATURE_LESS_WINCH +static void sigwinch_handler(int sig UNUSED_PARAM) +{ + winch_counter++; +} +#endif + int less_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; int less_main(int argc, char **argv) { - int keypress; + char *tty_name; + int tty_fd; INIT_G(); - /* 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~"); + /* TODO: -x: do not interpret backspace, -xx: tab also + * -xxx: newline also + * -w N: assume width N (-xxx -w 32: hex viewer of sorts) + * -s: condense many empty lines to one + * (used by some setups for manpage display) + */ + getopt32(argv, "EMmN~I" IF_FEATURE_LESS_TRUNCATE("S") /*ignored:*/"s"); argc -= optind; argv += optind; num_files = argc; @@ -1366,10 +1784,6 @@ int less_main(int argc, char **argv) * is not a tty and turns into cat. This makes sense. */ if (!isatty(STDOUT_FILENO)) return bb_cat(argv); - kbd_fd = open(CURRENT_TTY, O_RDONLY); - if (kbd_fd < 0) - return bb_cat(argv); - ndelay_on(kbd_fd); if (!num_files) { if (isatty(STDIN_FILENO)) { @@ -1377,19 +1791,39 @@ int less_main(int argc, char **argv) bb_error_msg("missing filename"); bb_show_usage(); } - } else + } else { filename = xstrdup(files[0]); + } - get_terminal_width_height(kbd_fd, &width, &max_displayed_line); - /* 20: two tabstops + 4 */ - if (width < 20 || max_displayed_line < 3) - return bb_cat(argv); - max_displayed_line -= 2; - - buffer = xmalloc((max_displayed_line+1) * sizeof(char *)); if (option_mask32 & FLAG_TILDE) empty_line_marker = ""; + /* Some versions of less can survive w/o controlling tty, + * try to do the same. This also allows to specify an alternative + * tty via "less 1<>TTY". + * + * We prefer not to use STDOUT_FILENO directly, + * since we want to set this fd to non-blocking mode, + * and not interfere with other processes which share stdout with us. + */ + tty_name = xmalloc_ttyname(STDOUT_FILENO); + if (tty_name) { + tty_fd = open(tty_name, O_RDONLY); + free(tty_name); + if (tty_fd < 0) + goto try_ctty; + } else { + /* Try controlling tty */ + try_ctty: + tty_fd = open(CURRENT_TTY, O_RDONLY); + if (tty_fd < 0) { + /* If all else fails, less 481 uses stdout. Mimic that */ + tty_fd = STDOUT_FILENO; + } + } + G.kbd_fd_orig_flags = ndelay_on(tty_fd); + kbd_fd = tty_fd; /* save in a global */ + tcgetattr(kbd_fd, &term_orig); term_less = term_orig; term_less.c_lflag &= ~(ICANON | ECHO); @@ -1398,12 +1832,267 @@ int less_main(int argc, char **argv) term_less.c_cc[VMIN] = 1; term_less.c_cc[VTIME] = 0; + IF_FEATURE_LESS_ASK_TERMINAL(G.winsize_err =) get_terminal_width_height(kbd_fd, &width, &max_displayed_line); + /* 20: two tabstops + 4 */ + if (width < 20 || max_displayed_line < 3) + return bb_cat(argv); + max_displayed_line -= 2; + /* We want to restore term_orig on exit */ bb_signals(BB_FATAL_SIGS, sig_catcher); +#if ENABLE_FEATURE_LESS_WINCH + signal(SIGWINCH, sigwinch_handler); +#endif + buffer = xmalloc((max_displayed_line+1) * sizeof(char *)); reinitialize(); while (1) { + int64_t keypress; + +#if ENABLE_FEATURE_LESS_WINCH + while (WINCH_COUNTER) { + again: + winch_counter--; + IF_FEATURE_LESS_ASK_TERMINAL(G.winsize_err =) get_terminal_width_height(kbd_fd, &width, &max_displayed_line); + IF_FEATURE_LESS_ASK_TERMINAL(got_size:) + /* 20: two tabstops + 4 */ + if (width < 20) + width = 20; + if (max_displayed_line < 3) + max_displayed_line = 3; + 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? */ + } + keypress = less_getch(-1); /* -1: do not position cursor */ +# if ENABLE_FEATURE_LESS_ASK_TERMINAL + if ((int32_t)keypress == KEYCODE_CURSOR_POS) { + uint32_t rc = (keypress >> 32); + width = (rc & 0x7fff); + max_displayed_line = ((rc >> 16) & 0x7fff); + goto got_size; + } +# endif +#else keypress = less_getch(-1); /* -1: do not position cursor */ +#endif keypress_process(keypress); } } + +/* +Help text of less version 418 is below. +If you are implementing something, keeping +key and/or command line switch compatibility is a good idea: + + + SUMMARY OF LESS COMMANDS + + Commands marked with * may be preceded by a number, N. + Notes in parentheses indicate the behavior if N is given. + h H Display this help. + q :q Q :Q ZZ Exit. + --------------------------------------------------------------------------- + MOVING + e ^E j ^N CR * Forward one line (or N lines). + y ^Y k ^K ^P * Backward one line (or N lines). + f ^F ^V SPACE * Forward one window (or N lines). + b ^B ESC-v * Backward one window (or N lines). + z * Forward one window (and set window to N). + w * Backward one window (and set window to N). + ESC-SPACE * Forward one window, but don't stop at end-of-file. + d ^D * Forward one half-window (and set half-window to N). + u ^U * Backward one half-window (and set half-window to N). + ESC-) RightArrow * Left one half screen width (or N positions). + ESC-( LeftArrow * Right one half screen width (or N positions). + F Forward forever; like "tail -f". + r ^R ^L Repaint screen. + R Repaint screen, discarding buffered input. + --------------------------------------------------- + Default "window" is the screen height. + Default "half-window" is half of the screen height. + --------------------------------------------------------------------------- + SEARCHING + /pattern * Search forward for (N-th) matching line. + ?pattern * Search backward for (N-th) matching line. + n * Repeat previous search (for N-th occurrence). + N * Repeat previous search in reverse direction. + ESC-n * Repeat previous search, spanning files. + ESC-N * Repeat previous search, reverse dir. & spanning files. + ESC-u Undo (toggle) search highlighting. + --------------------------------------------------- + Search patterns may be modified by one or more of: + ^N or ! Search for NON-matching lines. + ^E or * Search multiple files (pass thru END OF FILE). + ^F or @ Start search at FIRST file (for /) or last file (for ?). + ^K Highlight matches, but don't move (KEEP position). + ^R Don't use REGULAR EXPRESSIONS. + --------------------------------------------------------------------------- + JUMPING + g < ESC-< * Go to first line in file (or line N). + G > ESC-> * Go to last line in file (or line N). + p % * Go to beginning of file (or N percent into file). + t * Go to the (N-th) next tag. + T * Go to the (N-th) previous tag. + { ( [ * Find close bracket } ) ]. + } ) ] * Find open bracket { ( [. + ESC-^F * Find close bracket . + ESC-^B * Find open bracket + --------------------------------------------------- + Each "find close bracket" command goes forward to the close bracket + matching the (N-th) open bracket in the top line. + Each "find open bracket" command goes backward to the open bracket + matching the (N-th) close bracket in the bottom line. + m Mark the current position with . + ' Go to a previously marked position. + '' Go to the previous position. + ^X^X Same as '. + --------------------------------------------------- + A mark is any upper-case or lower-case letter. + Certain marks are predefined: + ^ means beginning of the file + $ means end of the file + --------------------------------------------------------------------------- + CHANGING FILES + :e [file] Examine a new file. + ^X^V Same as :e. + :n * Examine the (N-th) next file from the command line. + :p * Examine the (N-th) previous file from the command line. + :x * Examine the first (or N-th) file from the command line. + :d Delete the current file from the command line list. + = ^G :f Print current file name. + --------------------------------------------------------------------------- + MISCELLANEOUS COMMANDS + - Toggle a command line option [see OPTIONS below]. + -- Toggle a command line option, by name. + _ Display the setting of a command line option. + __ Display the setting of an option, by name. + +cmd Execute the less cmd each time a new file is examined. + !command Execute the shell command with $SHELL. + |Xcommand Pipe file between current pos & mark X to shell command. + v Edit the current file with $VISUAL or $EDITOR. + V Print version number of "less". + --------------------------------------------------------------------------- + OPTIONS + Most options may be changed either on the command line, + or from within less by using the - or -- command. + Options may be given in one of two forms: either a single + character preceded by a -, or a name preceded by --. + -? ........ --help + Display help (from command line). + -a ........ --search-skip-screen + Forward search skips current screen. + -b [N] .... --buffers=[N] + Number of buffers. + -B ........ --auto-buffers + Don't automatically allocate buffers for pipes. + -c ........ --clear-screen + Repaint by clearing rather than scrolling. + -d ........ --dumb + Dumb terminal. + -D [xn.n] . --color=xn.n + Set screen colors. (MS-DOS only) + -e -E .... --quit-at-eof --QUIT-AT-EOF + Quit at end of file. + -f ........ --force + Force open non-regular files. + -F ........ --quit-if-one-screen + Quit if entire file fits on first screen. + -g ........ --hilite-search + Highlight only last match for searches. + -G ........ --HILITE-SEARCH + Don't highlight any matches for searches. + -h [N] .... --max-back-scroll=[N] + Backward scroll limit. + -i ........ --ignore-case + Ignore case in searches that do not contain uppercase. + -I ........ --IGNORE-CASE + Ignore case in all searches. + -j [N] .... --jump-target=[N] + Screen position of target lines. + -J ........ --status-column + Display a status column at left edge of screen. + -k [file] . --lesskey-file=[file] + Use a lesskey file. + -L ........ --no-lessopen + Ignore the LESSOPEN environment variable. + -m -M .... --long-prompt --LONG-PROMPT + Set prompt style. + -n -N .... --line-numbers --LINE-NUMBERS + Don't use line numbers. + -o [file] . --log-file=[file] + Copy to log file (standard input only). + -O [file] . --LOG-FILE=[file] + Copy to log file (unconditionally overwrite). + -p [pattern] --pattern=[pattern] + Start at pattern (from command line). + -P [prompt] --prompt=[prompt] + Define new prompt. + -q -Q .... --quiet --QUIET --silent --SILENT + Quiet the terminal bell. + -r -R .... --raw-control-chars --RAW-CONTROL-CHARS + Output "raw" control characters. + -s ........ --squeeze-blank-lines + Squeeze multiple blank lines. + -S ........ --chop-long-lines + Chop long lines. + -t [tag] .. --tag=[tag] + Find a tag. + -T [tagsfile] --tag-file=[tagsfile] + Use an alternate tags file. + -u -U .... --underline-special --UNDERLINE-SPECIAL + Change handling of backspaces. + -V ........ --version + Display the version number of "less". + -w ........ --hilite-unread + Highlight first new line after forward-screen. + -W ........ --HILITE-UNREAD + Highlight first new line after any forward movement. + -x [N[,...]] --tabs=[N[,...]] + Set tab stops. + -X ........ --no-init + Don't use termcap init/deinit strings. + --no-keypad + Don't use termcap keypad init/deinit strings. + -y [N] .... --max-forw-scroll=[N] + Forward scroll limit. + -z [N] .... --window=[N] + Set size of window. + -" [c[c]] . --quotes=[c[c]] + Set shell quote characters. + -~ ........ --tilde + Don't display tildes after end of file. + -# [N] .... --shift=[N] + Horizontal scroll amount (0 = one half screen width) + + --------------------------------------------------------------------------- + LINE EDITING + These keys can be used to edit text being entered + on the "command line" at the bottom of the screen. + RightArrow ESC-l Move cursor right one character. + LeftArrow ESC-h Move cursor left one character. + CNTL-RightArrow ESC-RightArrow ESC-w Move cursor right one word. + CNTL-LeftArrow ESC-LeftArrow ESC-b Move cursor left one word. + HOME ESC-0 Move cursor to start of line. + END ESC-$ Move cursor to end of line. + BACKSPACE Delete char to left of cursor. + DELETE ESC-x Delete char under cursor. + CNTL-BACKSPACE ESC-BACKSPACE Delete word to left of cursor. + CNTL-DELETE ESC-DELETE ESC-X Delete word under cursor. + CNTL-U ESC (MS-DOS only) Delete entire line. + UpArrow ESC-k Retrieve previous command line. + DownArrow ESC-j Retrieve next command line. + TAB Complete filename & cycle. + SHIFT-TAB ESC-TAB Complete filename & reverse cycle. + CNTL-L Complete filename, list all. +*/