miscutils/less.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * Mini less implementation for busybox
   4  *
   5  * Copyright (C) 2005 by Rob Sullivan <cogito.ergo.cogito@gmail.com>
   6  *
   7  * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
   8  */
   9
  10 /*
  11  * TODO:
  12  * - Add more regular expression support - search modifiers, certain matches, etc.
  13  * - Add more complex bracket searching - currently, nested brackets are
  14  *   not considered.
  15  * - Add support for "F" as an input. This causes less to act in
  16  *   a similar way to tail -f.
  17  * - Allow horizontal scrolling.
  18  *
  19  * Notes:
  20  * - the inp file pointer is used so that keyboard input works after
  21  *   redirected input has been read from stdin
  22  */
  23
  24 #include <sched.h>      /* sched_yield() */
  25
  26 #include "libbb.h"
  27 #if ENABLE_FEATURE_LESS_REGEXP
  28 #include "xregex.h"
  29 #endif
  30
  31 /* FIXME: currently doesn't work right */
  32 #undef ENABLE_FEATURE_LESS_FLAGCS
  33 #define ENABLE_FEATURE_LESS_FLAGCS 0
  34
  35 /* The escape codes for highlighted and normal text */
  36 #define HIGHLIGHT "\033[7m"
  37 #define NORMAL "\033[0m"
  38 /* The escape code to clear the screen */
  39 #define CLEAR "\033[H\033[J"
  40 /* The escape code to clear to end of line */
  41 #define CLEAR_2_EOL "\033[K"
  42
  43 /* These are the escape sequences corresponding to special keys */
  44 enum {
  45         REAL_KEY_UP = 'A',
  46         REAL_KEY_DOWN = 'B',
  47         REAL_KEY_RIGHT = 'C',
  48         REAL_KEY_LEFT = 'D',
  49         REAL_PAGE_UP = '5',
  50         REAL_PAGE_DOWN = '6',
  51         REAL_KEY_HOME = '7', // vt100? linux vt? or what?
  52         REAL_KEY_END = '8',
  53         REAL_KEY_HOME_ALT = '1', // ESC [1~ (vt100? linux vt? or what?)
  54         REAL_KEY_END_ALT = '4', // ESC [4~
  55         REAL_KEY_HOME_XTERM = 'H',
  56         REAL_KEY_END_XTERM = 'F',
  57
  58 /* These are the special codes assigned by this program to the special keys */
  59         KEY_UP = 20,
  60         KEY_DOWN = 21,
  61         KEY_RIGHT = 22,
  62         KEY_LEFT = 23,
  63         PAGE_UP = 24,
  64         PAGE_DOWN = 25,
  65         KEY_HOME = 26,
  66         KEY_END = 27,
  67
  68 /* Absolute max of lines eaten */
  69         MAXLINES = CONFIG_FEATURE_LESS_MAXLINES,
  70
  71 /* This many "after the end" lines we will show (at max) */
  72         TILDES = 1,
  73 };
  74
  75 /* Command line options */
  76 enum {
  77         FLAG_E = 1,
  78         FLAG_M = 1 << 1,
  79         FLAG_m = 1 << 2,
  80         FLAG_N = 1 << 3,
  81         FLAG_TILDE = 1 << 4,
  82         FLAG_I = 1 << 5,
  83 /* hijack command line options variable for internal state vars */
  84         LESS_STATE_MATCH_BACKWARDS = 1 << 15,
  85 };
  86
  87 #if !ENABLE_FEATURE_LESS_REGEXP
  88 enum { pattern_valid = 0 };
  89 #endif
  90
  91 struct globals {
  92         int cur_fline; /* signed */
  93         int kbd_fd;  /* fd to get input from */
  94         int less_gets_pos;
  95 /* last position in last line, taking into account tabs */
  96         size_t linepos;
  97         unsigned max_displayed_line;
  98         unsigned max_fline;
  99         unsigned max_lineno; /* this one tracks linewrap */
 100         unsigned width;
 101         ssize_t eof_error; /* eof if 0, error if < 0 */
 102         ssize_t readpos;
 103         ssize_t readeof; /* must be signed */
 104         const char **buffer;
 105         const char **flines;
 106         const char *empty_line_marker;
 107         unsigned num_files;
 108         unsigned current_file;
 109         char *filename;
 110         char **files;
 111 #if ENABLE_FEATURE_LESS_MARKS
 112         unsigned num_marks;
 113         unsigned mark_lines[15][2];
 114 #endif
 115 #if ENABLE_FEATURE_LESS_REGEXP
 116         unsigned *match_lines;
 117         int match_pos; /* signed! */
 118         int wanted_match; /* signed! */
 119         int num_matches;
 120         regex_t pattern;
 121         smallint pattern_valid;
 122 #endif
 123         smallint terminated;
 124         struct termios term_orig, term_less;
 125 };
 126 #define G (*ptr_to_globals)
 127 #define cur_fline           (G.cur_fline         )
 128 #define kbd_fd              (G.kbd_fd            )
 129 #define less_gets_pos       (G.less_gets_pos     )
 130 #define linepos             (G.linepos           )
 131 #define max_displayed_line  (G.max_displayed_line)
 132 #define max_fline           (G.max_fline         )
 133 #define max_lineno          (G.max_lineno        )
 134 #define width               (G.width             )
 135 #define eof_error           (G.eof_error         )
 136 #define readpos             (G.readpos           )
 137 #define readeof             (G.readeof           )
 138 #define buffer              (G.buffer            )
 139 #define flines              (G.flines            )
 140 #define empty_line_marker   (G.empty_line_marker )
 141 #define num_files           (G.num_files         )
 142 #define current_file        (G.current_file      )
 143 #define filename            (G.filename          )
 144 #define files               (G.files             )
 145 #define num_marks           (G.num_marks         )
 146 #define mark_lines          (G.mark_lines        )
 147 #if ENABLE_FEATURE_LESS_REGEXP
 148 #define match_lines         (G.match_lines       )
 149 #define match_pos           (G.match_pos         )
 150 #define num_matches         (G.num_matches       )
 151 #define wanted_match        (G.wanted_match      )
 152 #define pattern             (G.pattern           )
 153 #define pattern_valid       (G.pattern_valid     )
 154 #endif
 155 #define terminated          (G.terminated        )
 156 #define term_orig           (G.term_orig         )
 157 #define term_less           (G.term_less         )
 158 #define INIT_G() do { \
 159         SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
 160         less_gets_pos = -1; \
 161         empty_line_marker = "~"; \
 162         num_files = 1; \
 163         current_file = 1; \
 164         eof_error = 1; \
 165         terminated = 1; \
 166         USE_FEATURE_LESS_REGEXP(wanted_match = -1;) \
 167 } while (0)
 168
 169 /* Reset terminal input to normal */
 170 static void set_tty_cooked(void)
 171 {
 172         fflush(stdout);
 173         tcsetattr(kbd_fd, TCSANOW, &term_orig);
 174 }
 175
 176 /* Move the cursor to a position (x,y), where (0,0) is the
 177    top-left corner of the console */
 178 static void move_cursor(int line, int row)
 179 {
 180         printf("\033[%u;%uH", line, row);
 181 }
 182
 183 static void clear_line(void)
 184 {
 185         printf("\033[%u;0H" CLEAR_2_EOL, max_displayed_line + 2);
 186 }
 187
 188 static void print_hilite(const char *str)
 189 {
 190         printf(HIGHLIGHT"%s"NORMAL, str);
 191 }
 192
 193 static void print_statusline(const char *str)
 194 {
 195         clear_line();
 196         printf(HIGHLIGHT"%.*s"NORMAL, width - 1, str);
 197 }
 198
 199 /* Exit the program gracefully */
 200 static void less_exit(int code)
 201 {
 202         set_tty_cooked();
 203         clear_line();
 204         if (code < 0)
 205                 kill_myself_with_sig(- code); /* does not return */
 206         exit(code);
 207 }
 208
 209 #if ENABLE_FEATURE_LESS_REGEXP
 210 static void fill_match_lines(unsigned pos);
 211 #else
 212 #define fill_match_lines(pos) ((void)0)
 213 #endif
 214
 215 /* Devilishly complex routine.
 216  *
 217  * Has to deal with EOF and EPIPE on input,
 218  * with line wrapping, with last line not ending in '\n'
 219  * (possibly not ending YET!), with backspace and tabs.
 220  * It reads input again if last time we got an EOF (thus supporting
 221  * growing files) or EPIPE (watching output of slow process like make).
 222  *
 223  * Variables used:
 224  * flines[] - array of lines already read. Linewrap may cause
 225  *      one source file line to occupy several flines[n].
 226  * flines[max_fline] - last line, possibly incomplete.
 227  * terminated - 1 if flines[max_fline] is 'terminated'
 228  *      (if there was '\n' [which isn't stored itself, we just remember
 229  *      that it was seen])
 230  * max_lineno - last line's number, this one doesn't increment
 231  *      on line wrap, only on "real" new lines.
 232  * readbuf[0..readeof-1] - small preliminary buffer.
 233  * readbuf[readpos] - next character to add to current line.
 234  * linepos - screen line position of next char to be read
 235  *      (takes into account tabs and backspaces)
 236  * eof_error - < 0 error, == 0 EOF, > 0 not EOF/error
 237  */
 238 static void read_lines(void)
 239 {
 240 #define readbuf bb_common_bufsiz1
 241         char *current_line, *p;
 242         int w = width;
 243         char last_terminated = terminated;
 244 #if ENABLE_FEATURE_LESS_REGEXP
 245         unsigned old_max_fline = max_fline;
 246         time_t last_time = 0;
 247         unsigned seconds_p1 = 3; /* seconds_to_loop + 1 */
 248 #endif
 249
 250         if (option_mask32 & FLAG_N)
 251                 w -= 8;
 252
 253  USE_FEATURE_LESS_REGEXP(again0:)
 254
 255         p = current_line = xmalloc(w);
 256         max_fline += last_terminated;
 257         if (!last_terminated) {
 258                 const char *cp = flines[max_fline];
 259                 if (option_mask32 & FLAG_N)
 260                         cp += 8;
 261                 strcpy(current_line, cp);
 262                 p += strlen(current_line);
 263                 free((char*)flines[max_fline]);
 264                 /* linepos is still valid from previous read_lines() */
 265         } else {
 266                 linepos = 0;
 267         }
 268
 269         while (1) { /* read lines until we reach cur_fline or wanted_match */
 270                 *p = '\0';
 271                 terminated = 0;
 272                 while (1) { /* read chars until we have a line */
 273                         char c;
 274                         /* if no unprocessed chars left, eat more */
 275                         if (readpos >= readeof) {
 276                                 ndelay_on(0);
 277                                 eof_error = safe_read(STDIN_FILENO, readbuf, sizeof(readbuf));
 278                                 ndelay_off(0);
 279                                 readpos = 0;
 280                                 readeof = eof_error;
 281                                 if (eof_error <= 0)
 282                                         goto reached_eof;
 283                         }
 284                         c = readbuf[readpos];
 285                         /* backspace? [needed for manpages] */
 286                         /* <tab><bs> is (a) insane and */
 287                         /* (b) harder to do correctly, so we refuse to do it */
 288                         if (c == '\x8' && linepos && p[-1] != '\t') {
 289                                 readpos++; /* eat it */
 290                                 linepos--;
 291                         /* was buggy (p could end up <= current_line)... */
 292                                 *--p = '\0';
 293                                 continue;
 294                         }
 295                         {
 296                                 size_t new_linepos = linepos + 1;
 297                                 if (c == '\t') {
 298                                         new_linepos += 7;
 299                                         new_linepos &= (~7);
 300                                 }
 301                                 if ((int)new_linepos >= w)
 302                                         break;
 303                                 linepos = new_linepos;
 304                         }
 305                         /* ok, we will eat this char */
 306                         readpos++;
 307                         if (c == '\n') {
 308                                 terminated = 1;
 309                                 linepos = 0;
 310                                 break;
 311                         }
 312                         /* NUL is substituted by '\n'! */
 313                         if (c == '\0') c = '\n';
 314                         *p++ = c;
 315                         *p = '\0';
 316                 } /* end of "read chars until we have a line" loop */
 317                 /* Corner case: linewrap with only "" wrapping to next line */
 318                 /* Looks ugly on screen, so we do not store this empty line */
 319                 if (!last_terminated && !current_line[0]) {
 320                         last_terminated = 1;
 321                         max_lineno++;
 322                         continue;
 323                 }
 324  reached_eof:
 325                 last_terminated = terminated;
 326                 flines = xrealloc_vector(flines, 8, max_fline);
 327                 if (option_mask32 & FLAG_N) {
 328                         /* Width of 7 preserves tab spacing in the text */
 329                         flines[max_fline] = xasprintf(
 330                                 (max_lineno <= 9999999) ? "%7u %s" : "%07u %s",
 331                                 max_lineno % 10000000, current_line);
 332                         free(current_line);
 333                         if (terminated)
 334                                 max_lineno++;
 335                 } else {
 336                         flines[max_fline] = xrealloc(current_line, strlen(current_line) + 1);
 337                 }
 338                 if (max_fline >= MAXLINES) {
 339                         eof_error = 0; /* Pretend we saw EOF */
 340                         break;
 341                 }
 342                 if (max_fline > cur_fline + max_displayed_line) {
 343 #if !ENABLE_FEATURE_LESS_REGEXP
 344                         break;
 345 #else
 346                         if (wanted_match >= num_matches) { /* goto_match called us */
 347                                 fill_match_lines(old_max_fline);
 348                                 old_max_fline = max_fline;
 349                         }
 350                         if (wanted_match < num_matches)
 351                                 break;
 352 #endif
 353                 }
 354                 if (eof_error <= 0) {
 355                         if (eof_error < 0) {
 356                                 if (errno == EAGAIN) {
 357                                         /* not yet eof or error, reset flag (or else
 358                                          * we will hog CPU - select() will return
 359                                          * immediately */
 360                                         eof_error = 1;
 361                                 } else {
 362                                         print_statusline("read error");
 363                                 }
 364                         }
 365 #if !ENABLE_FEATURE_LESS_REGEXP
 366                         break;
 367 #else
 368                         if (wanted_match < num_matches) {
 369                                 break;
 370                         } else { /* goto_match called us */
 371                                 time_t t = time(NULL);
 372                                 if (t != last_time) {
 373                                         last_time = t;
 374                                         if (--seconds_p1 == 0)
 375                                                 break;
 376                                 }
 377                                 sched_yield();
 378                                 goto again0; /* go loop again (max 2 seconds) */
 379                         }
 380 #endif
 381                 }
 382                 max_fline++;
 383                 current_line = xmalloc(w);
 384                 p = current_line;
 385                 linepos = 0;
 386         } /* end of "read lines until we reach cur_fline" loop */
 387         fill_match_lines(old_max_fline);
 388 #if ENABLE_FEATURE_LESS_REGEXP
 389         /* prevent us from being stuck in search for a match */
 390         wanted_match = -1;
 391 #endif
 392 #undef readbuf
 393 }
 394
 395 #if ENABLE_FEATURE_LESS_FLAGS
 396 /* Interestingly, writing calc_percent as a function saves around 32 bytes
 397  * on my build. */
 398 static int calc_percent(void)
 399 {
 400         unsigned p = (100 * (cur_fline+max_displayed_line+1) + max_fline/2) / (max_fline+1);
 401         return p <= 100 ? p : 100;
 402 }
 403
 404 /* Print a status line if -M was specified */
 405 static void m_status_print(void)
 406 {
 407         int percentage;
 408
 409         if (less_gets_pos >= 0) /* don't touch statusline while input is done! */
 410                 return;
 411
 412         clear_line();
 413         printf(HIGHLIGHT"%s", filename);
 414         if (num_files > 1)
 415                 printf(" (file %i of %i)", current_file, num_files);
 416         printf(" lines %i-%i/%i ",
 417                         cur_fline + 1, cur_fline + max_displayed_line + 1,
 418                         max_fline + 1);
 419         if (cur_fline >= (int)(max_fline - max_displayed_line)) {
 420                 printf("(END)"NORMAL);
 421                 if (num_files > 1 && current_file != num_files)
 422                         printf(HIGHLIGHT" - next: %s"NORMAL, files[current_file]);
 423                 return;
 424         }
 425         percentage = calc_percent();
 426         printf("%i%%"NORMAL, percentage);
 427 }
 428 #endif
 429
 430 /* Print the status line */
 431 static void status_print(void)
 432 {
 433         const char *p;
 434
 435         if (less_gets_pos >= 0) /* don't touch statusline while input is done! */
 436                 return;
 437
 438         /* Change the status if flags have been set */
 439 #if ENABLE_FEATURE_LESS_FLAGS
 440         if (option_mask32 & (FLAG_M|FLAG_m)) {
 441                 m_status_print();
 442                 return;
 443         }
 444         /* No flags set */
 445 #endif
 446
 447         clear_line();
 448         if (cur_fline && cur_fline < (int)(max_fline - max_displayed_line)) {
 449                 bb_putchar(':');
 450                 return;
 451         }
 452         p = "(END)";
 453         if (!cur_fline)
 454                 p = filename;
 455         if (num_files > 1) {
 456                 printf(HIGHLIGHT"%s (file %i of %i)"NORMAL,
 457                                 p, current_file, num_files);
 458                 return;
 459         }
 460         print_hilite(p);
 461 }
 462
 463 static void cap_cur_fline(int nlines)
 464 {
 465         int diff;
 466         if (cur_fline < 0)
 467                 cur_fline = 0;
 468         if (cur_fline + max_displayed_line > max_fline + TILDES) {
 469                 cur_fline -= nlines;
 470                 if (cur_fline < 0)
 471                         cur_fline = 0;
 472                 diff = max_fline - (cur_fline + max_displayed_line) + TILDES;
 473                 /* As the number of lines requested was too large, we just move
 474                 to the end of the file */
 475                 if (diff > 0)
 476                         cur_fline += diff;
 477         }
 478 }
 479
 480 static const char controls[] ALIGN1 =
 481         /* NUL: never encountered; TAB: not converted */
 482         /**/"\x01\x02\x03\x04\x05\x06\x07\x08"  "\x0a\x0b\x0c\x0d\x0e\x0f"
 483         "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f"
 484         "\x7f\x9b"; /* DEL and infamous Meta-ESC :( */
 485 static const char ctrlconv[] ALIGN1 =
 486         /* '\n': it's a former NUL - subst with '@', not 'J' */
 487         "\x40\x41\x42\x43\x44\x45\x46\x47\x48\x49\x40\x4b\x4c\x4d\x4e\x4f"
 488         "\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c\x5d\x5e\x5f";
 489
 490 #if ENABLE_FEATURE_LESS_REGEXP
 491 static void print_found(const char *line)
 492 {
 493         int match_status;
 494         int eflags;
 495         char *growline;
 496         regmatch_t match_structs;
 497
 498         char buf[width];
 499         const char *str = line;
 500         char *p = buf;
 501         size_t n;
 502
 503         while (*str) {
 504                 n = strcspn(str, controls);
 505                 if (n) {
 506                         if (!str[n]) break;
 507                         memcpy(p, str, n);
 508                         p += n;
 509                         str += n;
 510                 }
 511                 n = strspn(str, controls);
 512                 memset(p, '.', n);
 513                 p += n;
 514                 str += n;
 515         }
 516         strcpy(p, str);
 517
 518         /* buf[] holds quarantined version of str */
 519
 520         /* Each part of the line that matches has the HIGHLIGHT
 521            and NORMAL escape sequences placed around it.
 522            NB: we regex against line, but insert text
 523            from quarantined copy (buf[]) */
 524         str = buf;
 525         growline = NULL;
 526         eflags = 0;
 527         goto start;
 528
 529         while (match_status == 0) {
 530                 char *new = xasprintf("%s%.*s"HIGHLIGHT"%.*s"NORMAL,
 531                                 growline ? : "",
 532                                 match_structs.rm_so, str,
 533                                 match_structs.rm_eo - match_structs.rm_so,
 534                                                 str + match_structs.rm_so);
 535                 free(growline); growline = new;
 536                 str += match_structs.rm_eo;
 537                 line += match_structs.rm_eo;
 538                 eflags = REG_NOTBOL;
 539  start:
 540                 /* Most of the time doesn't find the regex, optimize for that */
 541                 match_status = regexec(&pattern, line, 1, &match_structs, eflags);
 542                 /* if even "" matches, treat it as "not a match" */
 543                 if (match_structs.rm_so >= match_structs.rm_eo)
 544                         match_status = 1;
 545         }
 546
 547         if (!growline) {
 548                 printf(CLEAR_2_EOL"%s\n", str);
 549                 return;
 550         }
 551         printf(CLEAR_2_EOL"%s%s\n", growline, str);
 552         free(growline);
 553 }
 554 #else
 555 void print_found(const char *line);
 556 #endif
 557
 558 static void print_ascii(const char *str)
 559 {
 560         char buf[width];
 561         char *p;
 562         size_t n;
 563
 564         printf(CLEAR_2_EOL);
 565         while (*str) {
 566                 n = strcspn(str, controls);
 567                 if (n) {
 568                         if (!str[n]) break;
 569                         printf("%.*s", (int) n, str);
 570                         str += n;
 571                 }
 572                 n = strspn(str, controls);
 573                 p = buf;
 574                 do {
 575                         if (*str == 0x7f)
 576                                 *p++ = '?';
 577                         else if (*str == (char)0x9b)
 578                         /* VT100's CSI, aka Meta-ESC. Who's inventor? */
 579                         /* I want to know who committed this sin */
 580                                 *p++ = '{';
 581                         else
 582                                 *p++ = ctrlconv[(unsigned char)*str];
 583                         str++;
 584                 } while (--n);
 585                 *p = '\0';
 586                 print_hilite(buf);
 587         }
 588         puts(str);
 589 }
 590
 591 /* Print the buffer */
 592 static void buffer_print(void)
 593 {
 594         unsigned i;
 595
 596         move_cursor(0, 0);
 597         for (i = 0; i <= max_displayed_line; i++)
 598                 if (pattern_valid)
 599                         print_found(buffer[i]);
 600                 else
 601                         print_ascii(buffer[i]);
 602         status_print();
 603 }
 604
 605 static void buffer_fill_and_print(void)
 606 {
 607         unsigned i;
 608         for (i = 0; i <= max_displayed_line && cur_fline + i <= max_fline; i++) {
 609                 buffer[i] = flines[cur_fline + i];
 610         }
 611         for (; i <= max_displayed_line; i++) {
 612                 buffer[i] = empty_line_marker;
 613         }
 614         buffer_print();
 615 }
 616
 617 /* Move the buffer up and down in the file in order to scroll */
 618 static void buffer_down(int nlines)
 619 {
 620         cur_fline += nlines;
 621         read_lines();
 622         cap_cur_fline(nlines);
 623         buffer_fill_and_print();
 624 }
 625
 626 static void buffer_up(int nlines)
 627 {
 628         cur_fline -= nlines;
 629         if (cur_fline < 0) cur_fline = 0;
 630         read_lines();
 631         buffer_fill_and_print();
 632 }
 633
 634 static void buffer_line(int linenum)
 635 {
 636         if (linenum < 0)
 637                 linenum = 0;
 638         cur_fline = linenum;
 639         read_lines();
 640         if (linenum + max_displayed_line > max_fline)
 641                 linenum = max_fline - max_displayed_line + TILDES;
 642         if (linenum < 0)
 643                 linenum = 0;
 644         cur_fline = linenum;
 645         buffer_fill_and_print();
 646 }
 647
 648 static void open_file_and_read_lines(void)
 649 {
 650         if (filename) {
 651                 int fd = xopen(filename, O_RDONLY);
 652                 dup2(fd, 0);
 653                 if (fd) close(fd);
 654         } else {
 655                 /* "less" with no arguments in argv[] */
 656                 /* For status line only */
 657                 filename = xstrdup(bb_msg_standard_input);
 658         }
 659         readpos = 0;
 660         readeof = 0;
 661         linepos = 0;
 662         terminated = 1;
 663         read_lines();
 664 }
 665
 666 /* Reinitialize everything for a new file - free the memory and start over */
 667 static void reinitialize(void)
 668 {
 669         unsigned i;
 670
 671         if (flines) {
 672                 for (i = 0; i <= max_fline; i++)
 673                         free((void*)(flines[i]));
 674                 free(flines);
 675                 flines = NULL;
 676         }
 677
 678         max_fline = -1;
 679         cur_fline = 0;
 680         max_lineno = 0;
 681         open_file_and_read_lines();
 682         buffer_fill_and_print();
 683 }
 684
 685 static ssize_t getch_nowait(char* input, int sz)
 686 {
 687         ssize_t rd;
 688         struct pollfd pfd[2];
 689
 690         pfd[0].fd = STDIN_FILENO;
 691         pfd[0].events = POLLIN;
 692         pfd[1].fd = kbd_fd;
 693         pfd[1].events = POLLIN;
 694  again:
 695         tcsetattr(kbd_fd, TCSANOW, &term_less);
 696         /* NB: select/poll returns whenever read will not block. Therefore:
 697          * if eof is reached, select/poll will return immediately
 698          * because read will immediately return 0 bytes.
 699          * Even if select/poll says that input is available, read CAN block
 700          * (switch fd into O_NONBLOCK'ed mode to avoid it)
 701          */
 702         rd = 1;
 703         if (max_fline <= cur_fline + max_displayed_line
 704          && eof_error > 0 /* did NOT reach eof yet */
 705         ) {
 706                 /* We are interested in stdin */
 707                 rd = 0;
 708         }
 709         /* position cursor if line input is done */
 710         if (less_gets_pos >= 0)
 711                 move_cursor(max_displayed_line + 2, less_gets_pos + 1);
 712         fflush(stdout);
 713         safe_poll(pfd + rd, 2 - rd, -1);
 714
 715         input[0] = '\0';
 716         rd = safe_read(kbd_fd, input, sz); /* NB: kbd_fd is in O_NONBLOCK mode */
 717         if (rd < 0 && errno == EAGAIN) {
 718                 /* No keyboard input -> we have input on stdin! */
 719                 read_lines();
 720                 buffer_fill_and_print();
 721                 goto again;
 722         }
 723         set_tty_cooked();
 724         return rd;
 725 }
 726
 727 /* Grab a character from input without requiring the return key. If the
 728  * character is ASCII \033, get more characters and assign certain sequences
 729  * special return codes. Note that this function works best with raw input. */
 730 static int less_getch(int pos)
 731 {
 732         unsigned char input[16];
 733         unsigned i;
 734
 735  again:
 736         less_gets_pos = pos;
 737         memset(input, 0, sizeof(input));
 738         getch_nowait((char *)input, sizeof(input));
 739         less_gets_pos = -1;
 740
 741         /* Detect escape sequences (i.e. arrow keys) and handle
 742          * them accordingly */
 743         if (input[0] == '\033' && input[1] == '[') {
 744                 i = input[2] - REAL_KEY_UP;
 745                 if (i < 4)
 746                         return 20 + i;
 747                 i = input[2] - REAL_PAGE_UP;
 748                 if (i < 4)
 749                         return 24 + i;
 750                 if (input[2] == REAL_KEY_HOME_XTERM)
 751                         return KEY_HOME;
 752                 if (input[2] == REAL_KEY_HOME_ALT)
 753                         return KEY_HOME;
 754                 if (input[2] == REAL_KEY_END_XTERM)
 755                         return KEY_END;
 756                 if (input[2] == REAL_KEY_END_ALT)
 757                         return KEY_END;
 758                 return 0;
 759         }
 760         /* Reject almost all control chars */
 761         i = input[0];
 762         if (i < ' ' && i != 0x0d && i != 8)
 763                 goto again;
 764         return i;
 765 }
 766
 767 static char* less_gets(int sz)
 768 {
 769         char c;
 770         unsigned i = 0;
 771         char *result = xzalloc(1);
 772
 773         while (1) {
 774                 c = '\0';
 775                 less_gets_pos = sz + i;
 776                 getch_nowait(&c, 1);
 777                 if (c == 0x0d) {
 778                         result[i] = '\0';
 779                         less_gets_pos = -1;
 780                         return result;
 781                 }
 782                 if (c == 0x7f)
 783                         c = 8;
 784                 if (c == 8 && i) {
 785                         printf("\x8 \x8");
 786                         i--;
 787                 }
 788                 if (c < ' ')
 789                         continue;
 790                 if (i >= width - sz - 1)
 791                         continue; /* len limit */
 792                 bb_putchar(c);
 793                 result[i++] = c;
 794                 result = xrealloc(result, i+1);
 795         }
 796 }
 797
 798 static void examine_file(void)
 799 {
 800         char *new_fname;
 801
 802         print_statusline("Examine: ");
 803         new_fname = less_gets(sizeof("Examine: ") - 1);
 804         if (!new_fname[0]) {
 805                 status_print();
 806  err:
 807                 free(new_fname);
 808                 return;
 809         }
 810         if (access(new_fname, R_OK) != 0) {
 811                 print_statusline("Cannot read this file");
 812                 goto err;
 813         }
 814         free(filename);
 815         filename = new_fname;
 816         /* files start by = argv. why we assume that argv is infinitely long??
 817         files[num_files] = filename;
 818         current_file = num_files + 1;
 819         num_files++; */
 820         files[0] = filename;
 821         num_files = current_file = 1;
 822         reinitialize();
 823 }
 824
 825 /* This function changes the file currently being paged. direction can be one of the following:
 826  * -1: go back one file
 827  *  0: go to the first file
 828  *  1: go forward one file */
 829 static void change_file(int direction)
 830 {
 831         if (current_file != ((direction > 0) ? num_files : 1)) {
 832                 current_file = direction ? current_file + direction : 1;
 833                 free(filename);
 834                 filename = xstrdup(files[current_file - 1]);
 835                 reinitialize();
 836         } else {
 837                 print_statusline(direction > 0 ? "No next file" : "No previous file");
 838         }
 839 }
 840
 841 static void remove_current_file(void)
 842 {
 843         unsigned i;
 844
 845         if (num_files < 2)
 846                 return;
 847
 848         if (current_file != 1) {
 849                 change_file(-1);
 850                 for (i = 3; i <= num_files; i++)
 851                         files[i - 2] = files[i - 1];
 852                 num_files--;
 853         } else {
 854                 change_file(1);
 855                 for (i = 2; i <= num_files; i++)
 856                         files[i - 2] = files[i - 1];
 857                 num_files--;
 858                 current_file--;
 859         }
 860 }
 861
 862 static void colon_process(void)
 863 {
 864         int keypress;
 865
 866         /* Clear the current line and print a prompt */
 867         print_statusline(" :");
 868
 869         keypress = less_getch(2);
 870         switch (keypress) {
 871         case 'd':
 872                 remove_current_file();
 873                 break;
 874         case 'e':
 875                 examine_file();
 876                 break;
 877 #if ENABLE_FEATURE_LESS_FLAGS
 878         case 'f':
 879                 m_status_print();
 880                 break;
 881 #endif
 882         case 'n':
 883                 change_file(1);
 884                 break;
 885         case 'p':
 886                 change_file(-1);
 887                 break;
 888         case 'q':
 889                 less_exit(EXIT_SUCCESS);
 890                 break;
 891         case 'x':
 892                 change_file(0);
 893                 break;
 894         }
 895 }
 896
 897 #if ENABLE_FEATURE_LESS_REGEXP
 898 static void normalize_match_pos(int match)
 899 {
 900         if (match >= num_matches)
 901                 match = num_matches - 1;
 902         if (match < 0)
 903                 match = 0;
 904         match_pos = match;
 905 }
 906
 907 static void goto_match(int match)
 908 {
 909         if (!pattern_valid)
 910                 return;
 911         if (match < 0)
 912                 match = 0;
 913         /* Try to find next match if eof isn't reached yet */
 914         if (match >= num_matches && eof_error > 0) {
 915                 wanted_match = match; /* "I want to read until I see N'th match" */
 916                 read_lines();
 917         }
 918         if (num_matches) {
 919                 normalize_match_pos(match);
 920                 buffer_line(match_lines[match_pos]);
 921         } else {
 922                 print_statusline("No matches found");
 923         }
 924 }
 925
 926 static void fill_match_lines(unsigned pos)
 927 {
 928         if (!pattern_valid)
 929                 return;
 930         /* Run the regex on each line of the current file */
 931         while (pos <= max_fline) {
 932                 /* If this line matches */
 933                 if (regexec(&pattern, flines[pos], 0, NULL, 0) == 0
 934                 /* and we didn't match it last time */
 935                  && !(num_matches && match_lines[num_matches-1] == pos)
 936                 ) {
 937                         match_lines = xrealloc_vector(match_lines, 4, num_matches);
 938                         match_lines[num_matches++] = pos;
 939                 }
 940                 pos++;
 941         }
 942 }
 943
 944 static void regex_process(void)
 945 {
 946         char *uncomp_regex, *err;
 947
 948         /* Reset variables */
 949         free(match_lines);
 950         match_lines = NULL;
 951         match_pos = 0;
 952         num_matches = 0;
 953         if (pattern_valid) {
 954                 regfree(&pattern);
 955                 pattern_valid = 0;
 956         }
 957
 958         /* Get the uncompiled regular expression from the user */
 959         clear_line();
 960         bb_putchar((option_mask32 & LESS_STATE_MATCH_BACKWARDS) ? '?' : '/');
 961         uncomp_regex = less_gets(1);
 962         if (!uncomp_regex[0]) {
 963                 free(uncomp_regex);
 964                 buffer_print();
 965                 return;
 966         }
 967
 968         /* Compile the regex and check for errors */
 969         err = regcomp_or_errmsg(&pattern, uncomp_regex,
 970                                                         option_mask32 & FLAG_I ? REG_ICASE : 0);
 971         free(uncomp_regex);
 972         if (err) {
 973                 print_statusline(err);
 974                 free(err);
 975                 return;
 976         }
 977
 978         pattern_valid = 1;
 979         match_pos = 0;
 980         fill_match_lines(0);
 981         while (match_pos < num_matches) {
 982                 if ((int)match_lines[match_pos] > cur_fline)
 983                         break;
 984                 match_pos++;
 985         }
 986         if (option_mask32 & LESS_STATE_MATCH_BACKWARDS)
 987                 match_pos--;
 988
 989         /* It's possible that no matches are found yet.
 990          * goto_match() will read input looking for match,
 991          * if needed */
 992         goto_match(match_pos);
 993 }
 994 #endif
 995
 996 static void number_process(int first_digit)
 997 {
 998         unsigned i;
 999         int num;
1000         char num_input[sizeof(int)*4]; /* more than enough */
1001         char keypress;
1002
1003         num_input[0] = first_digit;
1004
1005         /* Clear the current line, print a prompt, and then print the digit */
1006         clear_line();
1007         printf(":%c", first_digit);
1008
1009         /* Receive input until a letter is given */
1010         i = 1;
1011         while (i < sizeof(num_input)-1) {
1012                 num_input[i] = less_getch(i + 1);
1013                 if (!num_input[i] || !isdigit(num_input[i]))
1014                         break;
1015                 bb_putchar(num_input[i]);
1016                 i++;
1017         }
1018
1019         /* Take the final letter out of the digits string */
1020         keypress = num_input[i];
1021         num_input[i] = '\0';
1022         num = bb_strtou(num_input, NULL, 10);
1023         /* on format error, num == -1 */
1024         if (num < 1 || num > MAXLINES) {
1025                 buffer_print();
1026                 return;
1027         }
1028
1029         /* We now know the number and the letter entered, so we process them */
1030         switch (keypress) {
1031         case KEY_DOWN: case 'z': case 'd': case 'e': case ' ': case '\015':
1032                 buffer_down(num);
1033                 break;
1034         case KEY_UP: case 'b': case 'w': case 'y': case 'u':
1035                 buffer_up(num);
1036                 break;
1037         case 'g': case '<': case 'G': case '>':
1038                 cur_fline = num + max_displayed_line;
1039                 read_lines();
1040                 buffer_line(num - 1);
1041                 break;
1042         case 'p': case '%':
1043                 num = num * (max_fline / 100); /* + max_fline / 2; */
1044                 cur_fline = num + max_displayed_line;
1045                 read_lines();
1046                 buffer_line(num);
1047                 break;
1048 #if ENABLE_FEATURE_LESS_REGEXP
1049         case 'n':
1050                 goto_match(match_pos + num);
1051                 break;
1052         case '/':
1053                 option_mask32 &= ~LESS_STATE_MATCH_BACKWARDS;
1054                 regex_process();
1055                 break;
1056         case '?':
1057                 option_mask32 |= LESS_STATE_MATCH_BACKWARDS;
1058                 regex_process();
1059                 break;
1060 #endif
1061         }
1062 }
1063
1064 #if ENABLE_FEATURE_LESS_FLAGCS
1065 static void flag_change(void)
1066 {
1067         int keypress;
1068
1069         clear_line();
1070         bb_putchar('-');
1071         keypress = less_getch(1);
1072
1073         switch (keypress) {
1074         case 'M':
1075                 option_mask32 ^= FLAG_M;
1076                 break;
1077         case 'm':
1078                 option_mask32 ^= FLAG_m;
1079                 break;
1080         case 'E':
1081                 option_mask32 ^= FLAG_E;
1082                 break;
1083         case '~':
1084                 option_mask32 ^= FLAG_TILDE;
1085                 break;
1086         }
1087 }
1088
1089 static void show_flag_status(void)
1090 {
1091         int keypress;
1092         int flag_val;
1093
1094         clear_line();
1095         bb_putchar('_');
1096         keypress = less_getch(1);
1097
1098         switch (keypress) {
1099         case 'M':
1100                 flag_val = option_mask32 & FLAG_M;
1101                 break;
1102         case 'm':
1103                 flag_val = option_mask32 & FLAG_m;
1104                 break;
1105         case '~':
1106                 flag_val = option_mask32 & FLAG_TILDE;
1107                 break;
1108         case 'N':
1109                 flag_val = option_mask32 & FLAG_N;
1110                 break;
1111         case 'E':
1112                 flag_val = option_mask32 & FLAG_E;
1113                 break;
1114         default:
1115                 flag_val = 0;
1116                 break;
1117         }
1118
1119         clear_line();
1120         printf(HIGHLIGHT"The status of the flag is: %u"NORMAL, flag_val != 0);
1121 }
1122 #endif
1123
1124 static void save_input_to_file(void)
1125 {
1126         const char *msg = "";
1127         char *current_line;
1128         unsigned i;
1129         FILE *fp;
1130
1131         print_statusline("Log file: ");
1132         current_line = less_gets(sizeof("Log file: ")-1);
1133         if (current_line[0]) {
1134                 fp = fopen_for_write(current_line);
1135                 if (!fp) {
1136                         msg = "Error opening log file";
1137                         goto ret;
1138                 }
1139                 for (i = 0; i <= max_fline; i++)
1140                         fprintf(fp, "%s\n", flines[i]);
1141                 fclose(fp);
1142                 msg = "Done";
1143         }
1144  ret:
1145         print_statusline(msg);
1146         free(current_line);
1147 }
1148
1149 #if ENABLE_FEATURE_LESS_MARKS
1150 static void add_mark(void)
1151 {
1152         int letter;
1153
1154         print_statusline("Mark: ");
1155         letter = less_getch(sizeof("Mark: ") - 1);
1156
1157         if (isalpha(letter)) {
1158                 /* If we exceed 15 marks, start overwriting previous ones */
1159                 if (num_marks == 14)
1160                         num_marks = 0;
1161
1162                 mark_lines[num_marks][0] = letter;
1163                 mark_lines[num_marks][1] = cur_fline;
1164                 num_marks++;
1165         } else {
1166                 print_statusline("Invalid mark letter");
1167         }
1168 }
1169
1170 static void goto_mark(void)
1171 {
1172         int letter;
1173         int i;
1174
1175         print_statusline("Go to mark: ");
1176         letter = less_getch(sizeof("Go to mark: ") - 1);
1177         clear_line();
1178
1179         if (isalpha(letter)) {
1180                 for (i = 0; i <= num_marks; i++)
1181                         if (letter == mark_lines[i][0]) {
1182                                 buffer_line(mark_lines[i][1]);
1183                                 break;
1184                         }
1185                 if (num_marks == 14 && letter != mark_lines[14][0])
1186                         print_statusline("Mark not set");
1187         } else
1188                 print_statusline("Invalid mark letter");
1189 }
1190 #endif
1191
1192 #if ENABLE_FEATURE_LESS_BRACKETS
1193 static char opp_bracket(char bracket)
1194 {
1195         switch (bracket) {
1196                 case '{': case '[': /* '}' == '{' + 2. Same for '[' */
1197                         bracket++;
1198                 case '(':           /* ')' == '(' + 1 */
1199                         bracket++;
1200                         break;
1201                 case '}': case ']':
1202                         bracket--;
1203                 case ')':
1204                         bracket--;
1205                         break;
1206         };
1207         return bracket;
1208 }
1209
1210 static void match_right_bracket(char bracket)
1211 {
1212         unsigned i;
1213
1214         if (strchr(flines[cur_fline], bracket) == NULL) {
1215                 print_statusline("No bracket in top line");
1216                 return;
1217         }
1218         bracket = opp_bracket(bracket);
1219         for (i = cur_fline + 1; i < max_fline; i++) {
1220                 if (strchr(flines[i], bracket) != NULL) {
1221                         buffer_line(i);
1222                         return;
1223                 }
1224         }
1225         print_statusline("No matching bracket found");
1226 }
1227
1228 static void match_left_bracket(char bracket)
1229 {
1230         int i;
1231
1232         if (strchr(flines[cur_fline + max_displayed_line], bracket) == NULL) {
1233                 print_statusline("No bracket in bottom line");
1234                 return;
1235         }
1236
1237         bracket = opp_bracket(bracket);
1238         for (i = cur_fline + max_displayed_line; i >= 0; i--) {
1239                 if (strchr(flines[i], bracket) != NULL) {
1240                         buffer_line(i);
1241                         return;
1242                 }
1243         }
1244         print_statusline("No matching bracket found");
1245 }
1246 #endif  /* FEATURE_LESS_BRACKETS */
1247
1248 static void keypress_process(int keypress)
1249 {
1250         switch (keypress) {
1251         case KEY_DOWN: case 'e': case 'j': case 0x0d:
1252                 buffer_down(1);
1253                 break;
1254         case KEY_UP: case 'y': case 'k':
1255                 buffer_up(1);
1256                 break;
1257         case PAGE_DOWN: case ' ': case 'z': case 'f':
1258                 buffer_down(max_displayed_line + 1);
1259                 break;
1260         case PAGE_UP: case 'w': case 'b':
1261                 buffer_up(max_displayed_line + 1);
1262                 break;
1263         case 'd':
1264                 buffer_down((max_displayed_line + 1) / 2);
1265                 break;
1266         case 'u':
1267                 buffer_up((max_displayed_line + 1) / 2);
1268                 break;
1269         case KEY_HOME: case 'g': case 'p': case '<': case '%':
1270                 buffer_line(0);
1271                 break;
1272         case KEY_END: case 'G': case '>':
1273                 cur_fline = MAXLINES;
1274                 read_lines();
1275                 buffer_line(cur_fline);
1276                 break;
1277         case 'q': case 'Q':
1278                 less_exit(EXIT_SUCCESS);
1279                 break;
1280 #if ENABLE_FEATURE_LESS_MARKS
1281         case 'm':
1282                 add_mark();
1283                 buffer_print();
1284                 break;
1285         case '\'':
1286                 goto_mark();
1287                 buffer_print();
1288                 break;
1289 #endif
1290         case 'r': case 'R':
1291                 buffer_print();
1292                 break;
1293         /*case 'R':
1294                 full_repaint();
1295                 break;*/
1296         case 's':
1297                 save_input_to_file();
1298                 break;
1299         case 'E':
1300                 examine_file();
1301                 break;
1302 #if ENABLE_FEATURE_LESS_FLAGS
1303         case '=':
1304                 m_status_print();
1305                 break;
1306 #endif
1307 #if ENABLE_FEATURE_LESS_REGEXP
1308         case '/':
1309                 option_mask32 &= ~LESS_STATE_MATCH_BACKWARDS;
1310                 regex_process();
1311                 break;
1312         case 'n':
1313                 goto_match(match_pos + 1);
1314                 break;
1315         case 'N':
1316                 goto_match(match_pos - 1);
1317                 break;
1318         case '?':
1319                 option_mask32 |= LESS_STATE_MATCH_BACKWARDS;
1320                 regex_process();
1321                 break;
1322 #endif
1323 #if ENABLE_FEATURE_LESS_FLAGCS
1324         case '-':
1325                 flag_change();
1326                 buffer_print();
1327                 break;
1328         case '_':
1329                 show_flag_status();
1330                 break;
1331 #endif
1332 #if ENABLE_FEATURE_LESS_BRACKETS
1333         case '{': case '(': case '[':
1334                 match_right_bracket(keypress);
1335                 break;
1336         case '}': case ')': case ']':
1337                 match_left_bracket(keypress);
1338                 break;
1339 #endif
1340         case ':':
1341                 colon_process();
1342                 break;
1343         }
1344
1345         if (isdigit(keypress))
1346                 number_process(keypress);
1347 }
1348
1349 static void sig_catcher(int sig)
1350 {
1351         less_exit(- sig);
1352 }
1353
1354 int less_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
1355 int less_main(int argc, char **argv)
1356 {
1357         int keypress;
1358
1359         INIT_G();
1360
1361         /* TODO: -x: do not interpret backspace, -xx: tab also */
1362         /* -xxx: newline also */
1363         /* -w N: assume width N (-xxx -w 32: hex viewer of sorts) */
1364         getopt32(argv, "EMmN~I");
1365         argc -= optind;
1366         argv += optind;
1367         num_files = argc;
1368         files = argv;
1369
1370         /* Another popular pager, most, detects when stdout
1371          * is not a tty and turns into cat. This makes sense. */
1372         if (!isatty(STDOUT_FILENO))
1373                 return bb_cat(argv);
1374         kbd_fd = open(CURRENT_TTY, O_RDONLY);
1375         if (kbd_fd < 0)
1376                 return bb_cat(argv);
1377         ndelay_on(kbd_fd);
1378
1379         if (!num_files) {
1380                 if (isatty(STDIN_FILENO)) {
1381                         /* Just "less"? No args and no redirection? */
1382                         bb_error_msg("missing filename");
1383                         bb_show_usage();
1384                 }
1385         } else
1386                 filename = xstrdup(files[0]);
1387
1388         get_terminal_width_height(kbd_fd, &width, &max_displayed_line);
1389         /* 20: two tabstops + 4 */
1390         if (width < 20 || max_displayed_line < 3)
1391                 return bb_cat(argv);
1392         max_displayed_line -= 2;
1393
1394         buffer = xmalloc((max_displayed_line+1) * sizeof(char *));
1395         if (option_mask32 & FLAG_TILDE)
1396                 empty_line_marker = "";
1397
1398         tcgetattr(kbd_fd, &term_orig);
1399         term_less = term_orig;
1400         term_less.c_lflag &= ~(ICANON | ECHO);
1401         term_less.c_iflag &= ~(IXON | ICRNL);
1402         /*term_less.c_oflag &= ~ONLCR;*/
1403         term_less.c_cc[VMIN] = 1;
1404         term_less.c_cc[VTIME] = 0;
1405
1406         /* We want to restore term_orig on exit */
1407         bb_signals(BB_FATAL_SIGS, sig_catcher);
1408
1409         reinitialize();
1410         while (1) {
1411                 keypress = less_getch(-1); /* -1: do not position cursor */
1412                 keypress_process(keypress);
1413         }
1414 }