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