*
* Copyright (C) 2005 by Rob Sullivan <cogito.ergo.cogito@gmail.com>
*
- * 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.
*/
/*
* redirected input has been read from stdin
*/
-#include <sched.h> /* 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:
+//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 dynamic switching of line numbers"
+//config: default y
+//config: depends on FEATURE_LESS_DASHCMD
+//config: help
+//config: Enables "-N" command.
+
+//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.h> /* sched_yield() */
#include "libbb.h"
+#include "common_bufsiz.h"
#if ENABLE_FEATURE_LESS_REGEXP
#include "xregex.h"
#endif
-/* In progress */
-#define ENABLE_FEATURE_LESS_REWRAP 0
-
-/* 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_NO_WRAP = 1 << 14,
LESS_STATE_MATCH_BACKWARDS = 1 << 15,
};
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 */
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];
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 )
#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
#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.
/* Reset terminal input to normal */
static void set_tty_cooked(void)
{
- fflush(stdout);
+ fflush_all();
tcsetattr(kbd_fd, TCSANOW, &term_orig);
}
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)
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_REWRAP
+#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;
+ 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
#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,
* 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 = ((char*)xmalloc(w + 4)) + 4;
- max_fline += last_terminated;
+ p = current_line = ((char*)xmalloc(w + 5)) + 4;
if (!last_terminated) {
const char *cp = flines[max_fline];
- strcpy(p, cp);
- p += strlen(current_line);
- free(MEMPTR(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 */
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] */
/* <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'! */
*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]) {
max_lineno++;
continue;
}
+#endif
reached_eof:
last_terminated = terminated;
flines = xrealloc_vector(flines, 8, max_fline);
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
#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 = ((char*)xmalloc(w + 4)) + 4;
+ 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 */
}
#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
{
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 */
#endif
clear_line();
- if (cur_fline && cur_fline < (int)(max_fline - max_displayed_line)) {
+ if (cur_fline && !at_end()) {
bb_putchar(':');
return;
}
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 lineno_str(char *nbuf9, const char *line)
+static void print_lineno(const char *line)
{
- nbuf9[0] = '\0';
- if (option_mask32 & FLAG_N) {
- const char *fmt;
- unsigned n;
-
- if (line == empty_line_marker) {
- memset(nbuf9, ' ', 8);
- nbuf9[8] = '\0';
- return;
- }
+ 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) {
+ if (n > 9999999 && MAXLINES > 9999999) {
n %= 10000000;
fmt = "%07u ";
}
- sprintf(nbuf9, fmt, n);
}
+ printf(fmt, n);
}
char *growline;
regmatch_t match_structs;
- char buf[width];
- char nbuf9[9];
+ char buf[width+1];
const char *str = line;
char *p = buf;
size_t n;
/* 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;
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;
match_status = 1;
}
- lineno_str(nbuf9, line);
- if (!growline) {
- printf(CLEAR_2_EOL"%s%s\n", nbuf9, str);
- return;
- }
- printf(CLEAR_2_EOL"%s%s%s\n", nbuf9, growline, str);
+ printf("%s%s\n", growline ? growline : "", str);
free(growline);
}
#else
static void print_ascii(const char *str)
{
- char buf[width];
- char nbuf9[9];
+ char buf[width+1];
char *p;
size_t n;
- lineno_str(nbuf9, str);
- printf(CLEAR_2_EOL"%s", nbuf9);
-
while (*str) {
n = strcspn(str, controls);
if (n) {
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();
}
-#if ENABLE_FEATURE_LESS_REWRAP
static void buffer_fill_and_print(void)
{
- unsigned i = 0;
- int fpos = cur_fline + i;
+ unsigned i;
+#if ENABLE_FEATURE_LESS_TRUNCATE
+ int fpos = cur_fline;
- if (option_mask32 & LESS_STATE_NO_WRAP) {
+ 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];
do {
fpos++;
} while ((fpos <= max_fline)
- && (option_mask32 & LESS_STATE_NO_WRAP)
+ && (option_mask32 & FLAG_S)
&& lineno == LINENO(flines[fpos])
);
}
- for (; i <= max_displayed_line; i++) {
- buffer[i] = empty_line_marker;
- }
- buffer_print();
-}
#else
-static void buffer_fill_and_print(void)
-{
- unsigned i;
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();
}
-#endif
+
+/* 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();
}
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;
* (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;
printf("\x8 \x8");
i--;
}
- if (c < ' ')
+ if (c < ' ') /* filters out KEYCODE_xxx too (<0) */
continue;
if (i >= width - sz - 1)
continue; /* len limit */
/* Compile the regex and check for errors */
err = regcomp_or_errmsg(&pattern, uncomp_regex,
- option_mask32 & FLAG_I ? REG_ICASE : 0);
+ (option_mask32 & FLAG_I) ? REG_ICASE : 0);
free(uncomp_regex);
if (err) {
print_statusline(err);
{
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(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 */
/* 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':
}
}
-#if ENABLE_FEATURE_LESS_FLAGCS
+#if ENABLE_FEATURE_LESS_DASHCMD
static void flag_change(void)
{
int keypress;
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;
}
#endif
+#endif /* ENABLE_FEATURE_LESS_DASHCMD */
+
static void save_input_to_file(void)
{
const char *msg = "";
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;
}
}
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;
}
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);
break;
#endif
case 'r': case 'R':
+ /* TODO: (1) also bind ^R, ^L to this?
+ * (2) re-measure window size?
+ */
buffer_print();
break;
/*case 'R':
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);
case ':':
colon_process();
break;
-#if ENABLE_FEATURE_LESS_REWRAP
- case '*': /* Should be -N command / option */
- option_mask32 ^= FLAG_N;
- get_terminal_width_height(kbd_fd, &width, &max_displayed_line);
- if (width < 20) /* 20: two tabstops + 4 */
- 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 *));
- re_wrap();
- buffer_fill_and_print();
- break;
- case '&': /* Should be -S command / option */
- option_mask32 ^= LESS_STATE_NO_WRAP;
- buffer_fill_and_print();
- break;
-#endif
}
if (isdigit(keypress))
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~I");
+ /* 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;
* 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)) {
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);
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);
}
}
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 preceeded by --.
+ character preceded by a -, or a name preceded by --.
-? ........ --help
Display help (from command line).
-a ........ --search-skip-screen
projects / oweals / busybox.git / blobdiff