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         bb_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                 bb_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[] ALIGN1 =
 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[] ALIGN1 =
 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         memset(input, 0, sizeof(input));
 703         getch_nowait(input, sizeof(input));
 704
 705         /* Detect escape sequences (i.e. arrow keys) and handle
 706          * them accordingly */
 707         if (input[0] == '\033' && input[1] == '[') {
 708                 set_tty_cooked();
 709                 i = input[2] - REAL_KEY_UP;
 710                 if (i < 4)
 711                         return 20 + i;
 712                 i = input[2] - REAL_PAGE_UP;
 713                 if (i < 4)
 714                         return 24 + i;
 715                 if (input[2] == REAL_KEY_HOME_XTERM)
 716                         return KEY_HOME;
 717                 if (input[2] == REAL_KEY_HOME_ALT)
 718                         return KEY_HOME;
 719                 if (input[2] == REAL_KEY_END_XTERM)
 720                         return KEY_END;
 721                 if (input[2] == REAL_KEY_END_ALT)
 722                         return KEY_END;
 723                 return 0;
 724         }
 725         /* Reject almost all control chars */
 726         i = input[0];
 727         if (i < ' ' && i != 0x0d && i != 8) goto again;
 728         set_tty_cooked();
 729         return i;
 730 }
 731
 732 static char* less_gets(int sz)
 733 {
 734         char c;
 735         int i = 0;
 736         char *result = xzalloc(1);
 737         while (1) {
 738                 fflush(stdout);
 739
 740                 /* I be damned if I know why is it needed *repeatedly*,
 741                  * but it is needed. Is it because of stdio? */
 742                 tcsetattr(kbd_fd, TCSANOW, &term_less);
 743
 744                 c = '\0';
 745                 read(kbd_fd, &c, 1);
 746                 if (c == 0x0d)
 747                         return result;
 748                 if (c == 0x7f)
 749                         c = 8;
 750                 if (c == 8 && i) {
 751                         printf("\x8 \x8");
 752                         i--;
 753                 }
 754                 if (c < ' ')
 755                         continue;
 756                 if (i >= width - sz - 1)
 757                         continue; /* len limit */
 758                 bb_putchar(c);
 759                 result[i++] = c;
 760                 result = xrealloc(result, i+1);
 761                 result[i] = '\0';
 762         }
 763 }
 764
 765 static void examine_file(void)
 766 {
 767         print_statusline("Examine: ");
 768         free(filename);
 769         filename = less_gets(sizeof("Examine: ")-1);
 770         /* files start by = argv. why we assume that argv is infinitely long??
 771         files[num_files] = filename;
 772         current_file = num_files + 1;
 773         num_files++; */
 774         files[0] = filename;
 775         num_files = current_file = 1;
 776         reinitialize();
 777 }
 778
 779 /* This function changes the file currently being paged. direction can be one of the following:
 780  * -1: go back one file
 781  *  0: go to the first file
 782  *  1: go forward one file */
 783 static void change_file(int direction)
 784 {
 785         if (current_file != ((direction > 0) ? num_files : 1)) {
 786                 current_file = direction ? current_file + direction : 1;
 787                 free(filename);
 788                 filename = xstrdup(files[current_file - 1]);
 789                 reinitialize();
 790         } else {
 791                 print_statusline(direction > 0 ? "No next file" : "No previous file");
 792         }
 793 }
 794
 795 static void remove_current_file(void)
 796 {
 797         int i;
 798
 799         if (num_files < 2)
 800                 return;
 801
 802         if (current_file != 1) {
 803                 change_file(-1);
 804                 for (i = 3; i <= num_files; i++)
 805                         files[i - 2] = files[i - 1];
 806                 num_files--;
 807         } else {
 808                 change_file(1);
 809                 for (i = 2; i <= num_files; i++)
 810                         files[i - 2] = files[i - 1];
 811                 num_files--;
 812                 current_file--;
 813         }
 814 }
 815
 816 static void colon_process(void)
 817 {
 818         int keypress;
 819
 820         /* Clear the current line and print a prompt */
 821         print_statusline(" :");
 822
 823         keypress = less_getch();
 824         switch (keypress) {
 825         case 'd':
 826                 remove_current_file();
 827                 break;
 828         case 'e':
 829                 examine_file();
 830                 break;
 831 #if ENABLE_FEATURE_LESS_FLAGS
 832         case 'f':
 833                 m_status_print();
 834                 break;
 835 #endif
 836         case 'n':
 837                 change_file(1);
 838                 break;
 839         case 'p':
 840                 change_file(-1);
 841                 break;
 842         case 'q':
 843                 less_exit(0);
 844                 break;
 845         case 'x':
 846                 change_file(0);
 847                 break;
 848         }
 849 }
 850
 851 #if ENABLE_FEATURE_LESS_REGEXP
 852 static void normalize_match_pos(int match)
 853 {
 854         if (match >= num_matches)
 855                 match = num_matches - 1;
 856         if (match < 0)
 857                 match = 0;
 858         match_pos = match;
 859 }
 860
 861 static void goto_match(int match)
 862 {
 863         int sv;
 864
 865         if (!pattern_valid)
 866                 return;
 867         if (match < 0)
 868                 match = 0;
 869         sv = cur_fline;
 870         /* Try to find next match if eof isn't reached yet */
 871         if (match >= num_matches && eof_error > 0) {
 872                 cur_fline = MAXLINES; /* look as far as needed */
 873                 read_lines();
 874         }
 875         if (num_matches) {
 876                 cap_cur_fline(cur_fline);
 877                 normalize_match_pos(match);
 878                 buffer_line(match_lines[match_pos]);
 879         } else {
 880                 cur_fline = sv;
 881                 print_statusline("No matches found");
 882         }
 883 }
 884
 885 static void fill_match_lines(unsigned pos)
 886 {
 887         if (!pattern_valid)
 888                 return;
 889         /* Run the regex on each line of the current file */
 890         while (pos <= max_fline) {
 891                 /* If this line matches */
 892                 if (regexec(&pattern, flines[pos], 0, NULL, 0) == 0
 893                 /* and we didn't match it last time */
 894                  && !(num_matches && match_lines[num_matches-1] == pos)
 895                 ) {
 896                         match_lines = xrealloc(match_lines, (num_matches+1) * sizeof(int));
 897                         match_lines[num_matches++] = pos;
 898                 }
 899                 pos++;
 900         }
 901 }
 902
 903 static void regex_process(void)
 904 {
 905         char *uncomp_regex, *err;
 906
 907         /* Reset variables */
 908         free(match_lines);
 909         match_lines = NULL;
 910         match_pos = 0;
 911         num_matches = 0;
 912         if (pattern_valid) {
 913                 regfree(&pattern);
 914                 pattern_valid = 0;
 915         }
 916
 917         /* Get the uncompiled regular expression from the user */
 918         clear_line();
 919         bb_putchar((option_mask32 & LESS_STATE_MATCH_BACKWARDS) ? '?' : '/');
 920         uncomp_regex = less_gets(1);
 921         if (!uncomp_regex[0]) {
 922                 free(uncomp_regex);
 923                 buffer_print();
 924                 return;
 925         }
 926
 927         /* Compile the regex and check for errors */
 928         err = regcomp_or_errmsg(&pattern, uncomp_regex, 0);
 929         free(uncomp_regex);
 930         if (err) {
 931                 print_statusline(err);
 932                 free(err);
 933                 return;
 934         }
 935
 936         pattern_valid = 1;
 937         match_pos = 0;
 938         fill_match_lines(0);
 939         while (match_pos < num_matches) {
 940                 if (match_lines[match_pos] > cur_fline)
 941                         break;
 942                 match_pos++;
 943         }
 944         if (option_mask32 & LESS_STATE_MATCH_BACKWARDS)
 945                 match_pos--;
 946
 947         /* It's possible that no matches are found yet.
 948          * goto_match() will read input looking for match,
 949          * if needed */
 950         goto_match(match_pos);
 951 }
 952 #endif
 953
 954 static void number_process(int first_digit)
 955 {
 956         int i = 1;
 957         int num;
 958         char num_input[sizeof(int)*4]; /* more than enough */
 959         char keypress;
 960
 961         num_input[0] = first_digit;
 962
 963         /* Clear the current line, print a prompt, and then print the digit */
 964         clear_line();
 965         printf(":%c", first_digit);
 966
 967         /* Receive input until a letter is given */
 968         while (i < sizeof(num_input)-1) {
 969                 num_input[i] = less_getch();
 970                 if (!num_input[i] || !isdigit(num_input[i]))
 971                         break;
 972                 bb_putchar(num_input[i]);
 973                 i++;
 974         }
 975
 976         /* Take the final letter out of the digits string */
 977         keypress = num_input[i];
 978         num_input[i] = '\0';
 979         num = bb_strtou(num_input, NULL, 10);
 980         /* on format error, num == -1 */
 981         if (num < 1 || num > MAXLINES) {
 982                 buffer_print();
 983                 return;
 984         }
 985
 986         /* We now know the number and the letter entered, so we process them */
 987         switch (keypress) {
 988         case KEY_DOWN: case 'z': case 'd': case 'e': case ' ': case '\015':
 989                 buffer_down(num);
 990                 break;
 991         case KEY_UP: case 'b': case 'w': case 'y': case 'u':
 992                 buffer_up(num);
 993                 break;
 994         case 'g': case '<': case 'G': case '>':
 995                 cur_fline = num + max_displayed_line;
 996                 read_lines();
 997                 buffer_line(num - 1);
 998                 break;
 999         case 'p': case '%':
1000                 num = num * (max_fline / 100); /* + max_fline / 2; */
1001                 cur_fline = num + max_displayed_line;
1002                 read_lines();
1003                 buffer_line(num);
1004                 break;
1005 #if ENABLE_FEATURE_LESS_REGEXP
1006         case 'n':
1007                 goto_match(match_pos + num);
1008                 break;
1009         case '/':
1010                 option_mask32 &= ~LESS_STATE_MATCH_BACKWARDS;
1011                 regex_process();
1012                 break;
1013         case '?':
1014                 option_mask32 |= LESS_STATE_MATCH_BACKWARDS;
1015                 regex_process();
1016                 break;
1017 #endif
1018         }
1019 }
1020
1021 #if ENABLE_FEATURE_LESS_FLAGCS
1022 static void flag_change(void)
1023 {
1024         int keypress;
1025
1026         clear_line();
1027         bb_putchar('-');
1028         keypress = less_getch();
1029
1030         switch (keypress) {
1031         case 'M':
1032                 option_mask32 ^= FLAG_M;
1033                 break;
1034         case 'm':
1035                 option_mask32 ^= FLAG_m;
1036                 break;
1037         case 'E':
1038                 option_mask32 ^= FLAG_E;
1039                 break;
1040         case '~':
1041                 option_mask32 ^= FLAG_TILDE;
1042                 break;
1043         }
1044 }
1045
1046 static void show_flag_status(void)
1047 {
1048         int keypress;
1049         int flag_val;
1050
1051         clear_line();
1052         bb_putchar('_');
1053         keypress = less_getch();
1054
1055         switch (keypress) {
1056         case 'M':
1057                 flag_val = option_mask32 & FLAG_M;
1058                 break;
1059         case 'm':
1060                 flag_val = option_mask32 & FLAG_m;
1061                 break;
1062         case '~':
1063                 flag_val = option_mask32 & FLAG_TILDE;
1064                 break;
1065         case 'N':
1066                 flag_val = option_mask32 & FLAG_N;
1067                 break;
1068         case 'E':
1069                 flag_val = option_mask32 & FLAG_E;
1070                 break;
1071         default:
1072                 flag_val = 0;
1073                 break;
1074         }
1075
1076         clear_line();
1077         printf(HIGHLIGHT"The status of the flag is: %u"NORMAL, flag_val != 0);
1078 }
1079 #endif
1080
1081 static void save_input_to_file(void)
1082 {
1083         const char *msg = "";
1084         char *current_line;
1085         int i;
1086         FILE *fp;
1087
1088         print_statusline("Log file: ");
1089         current_line = less_gets(sizeof("Log file: ")-1);
1090         if (strlen(current_line) > 0) {
1091                 fp = fopen(current_line, "w");
1092                 if (!fp) {
1093                         msg = "Error opening log file";
1094                         goto ret;
1095                 }
1096                 for (i = 0; i <= max_fline; i++)
1097                         fprintf(fp, "%s\n", flines[i]);
1098                 fclose(fp);
1099                 msg = "Done";
1100         }
1101  ret:
1102         print_statusline(msg);
1103         free(current_line);
1104 }
1105
1106 #if ENABLE_FEATURE_LESS_MARKS
1107 static void add_mark(void)
1108 {
1109         int letter;
1110
1111         print_statusline("Mark: ");
1112         letter = less_getch();
1113
1114         if (isalpha(letter)) {
1115                 /* If we exceed 15 marks, start overwriting previous ones */
1116                 if (num_marks == 14)
1117                         num_marks = 0;
1118
1119                 mark_lines[num_marks][0] = letter;
1120                 mark_lines[num_marks][1] = cur_fline;
1121                 num_marks++;
1122         } else {
1123                 print_statusline("Invalid mark letter");
1124         }
1125 }
1126
1127 static void goto_mark(void)
1128 {
1129         int letter;
1130         int i;
1131
1132         print_statusline("Go to mark: ");
1133         letter = less_getch();
1134         clear_line();
1135
1136         if (isalpha(letter)) {
1137                 for (i = 0; i <= num_marks; i++)
1138                         if (letter == mark_lines[i][0]) {
1139                                 buffer_line(mark_lines[i][1]);
1140                                 break;
1141                         }
1142                 if (num_marks == 14 && letter != mark_lines[14][0])
1143                         print_statusline("Mark not set");
1144         } else
1145                 print_statusline("Invalid mark letter");
1146 }
1147 #endif
1148
1149 #if ENABLE_FEATURE_LESS_BRACKETS
1150 static char opp_bracket(char bracket)
1151 {
1152         switch (bracket) {
1153         case '{': case '[':
1154                 return bracket + 2;
1155         case '(':
1156                 return ')';
1157         case '}': case ']':
1158                 return bracket - 2;
1159         case ')':
1160                 return '(';
1161         }
1162         return 0;
1163 }
1164
1165 static void match_right_bracket(char bracket)
1166 {
1167         int bracket_line = -1;
1168         int i;
1169
1170         if (strchr(flines[cur_fline], bracket) == NULL) {
1171                 print_statusline("No bracket in top line");
1172                 return;
1173         }
1174         for (i = cur_fline + 1; i < max_fline; i++) {
1175                 if (strchr(flines[i], opp_bracket(bracket)) != NULL) {
1176                         bracket_line = i;
1177                         break;
1178                 }
1179         }
1180         if (bracket_line == -1)
1181                 print_statusline("No matching bracket found");
1182         buffer_line(bracket_line - max_displayed_line);
1183 }
1184
1185 static void match_left_bracket(char bracket)
1186 {
1187         int bracket_line = -1;
1188         int i;
1189
1190         if (strchr(flines[cur_fline + max_displayed_line], bracket) == NULL) {
1191                 print_statusline("No bracket in bottom line");
1192                 return;
1193         }
1194
1195         for (i = cur_fline + max_displayed_line; i >= 0; i--) {
1196                 if (strchr(flines[i], opp_bracket(bracket)) != NULL) {
1197                         bracket_line = i;
1198                         break;
1199                 }
1200         }
1201         if (bracket_line == -1)
1202                 print_statusline("No matching bracket found");
1203         buffer_line(bracket_line);
1204 }
1205 #endif  /* FEATURE_LESS_BRACKETS */
1206
1207 static void keypress_process(int keypress)
1208 {
1209         switch (keypress) {
1210         case KEY_DOWN: case 'e': case 'j': case 0x0d:
1211                 buffer_down(1);
1212                 break;
1213         case KEY_UP: case 'y': case 'k':
1214                 buffer_up(1);
1215                 break;
1216         case PAGE_DOWN: case ' ': case 'z': case 'f':
1217                 buffer_down(max_displayed_line + 1);
1218                 break;
1219         case PAGE_UP: case 'w': case 'b':
1220                 buffer_up(max_displayed_line + 1);
1221                 break;
1222         case 'd':
1223                 buffer_down((max_displayed_line + 1) / 2);
1224                 break;
1225         case 'u':
1226                 buffer_up((max_displayed_line + 1) / 2);
1227                 break;
1228         case KEY_HOME: case 'g': case 'p': case '<': case '%':
1229                 buffer_line(0);
1230                 break;
1231         case KEY_END: case 'G': case '>':
1232                 cur_fline = MAXLINES;
1233                 read_lines();
1234                 buffer_line(cur_fline);
1235                 break;
1236         case 'q': case 'Q':
1237                 less_exit(0);
1238                 break;
1239 #if ENABLE_FEATURE_LESS_MARKS
1240         case 'm':
1241                 add_mark();
1242                 buffer_print();
1243                 break;
1244         case '\'':
1245                 goto_mark();
1246                 buffer_print();
1247                 break;
1248 #endif
1249         case 'r': case 'R':
1250                 buffer_print();
1251                 break;
1252         /*case 'R':
1253                 full_repaint();
1254                 break;*/
1255         case 's':
1256                 save_input_to_file();
1257                 break;
1258         case 'E':
1259                 examine_file();
1260                 break;
1261 #if ENABLE_FEATURE_LESS_FLAGS
1262         case '=':
1263                 m_status_print();
1264                 break;
1265 #endif
1266 #if ENABLE_FEATURE_LESS_REGEXP
1267         case '/':
1268                 option_mask32 &= ~LESS_STATE_MATCH_BACKWARDS;
1269                 regex_process();
1270                 break;
1271         case 'n':
1272                 goto_match(match_pos + 1);
1273                 break;
1274         case 'N':
1275                 goto_match(match_pos - 1);
1276                 break;
1277         case '?':
1278                 option_mask32 |= LESS_STATE_MATCH_BACKWARDS;
1279                 regex_process();
1280                 break;
1281 #endif
1282 #if ENABLE_FEATURE_LESS_FLAGCS
1283         case '-':
1284                 flag_change();
1285                 buffer_print();
1286                 break;
1287         case '_':
1288                 show_flag_status();
1289                 break;
1290 #endif
1291 #if ENABLE_FEATURE_LESS_BRACKETS
1292         case '{': case '(': case '[':
1293                 match_right_bracket(keypress);
1294                 break;
1295         case '}': case ')': case ']':
1296                 match_left_bracket(keypress);
1297                 break;
1298 #endif
1299         case ':':
1300                 colon_process();
1301                 break;
1302         }
1303
1304         if (isdigit(keypress))
1305                 number_process(keypress);
1306 }
1307
1308 static void sig_catcher(int sig ATTRIBUTE_UNUSED)
1309 {
1310         set_tty_cooked();
1311         exit(1);
1312 }
1313
1314 int less_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
1315 int less_main(int argc, char **argv)
1316 {
1317         int keypress;
1318
1319         INIT_G();
1320
1321         /* TODO: -x: do not interpret backspace, -xx: tab also */
1322         /* -xxx: newline also */
1323         /* -w N: assume width N (-xxx -w 32: hex viewer of sorts) */
1324         getopt32(argv, "EMmN~");
1325         argc -= optind;
1326         argv += optind;
1327         num_files = argc;
1328         files = argv;
1329
1330         /* Another popular pager, most, detects when stdout
1331          * is not a tty and turns into cat. This makes sense. */
1332         if (!isatty(STDOUT_FILENO))
1333                 return bb_cat(argv);
1334         kbd_fd = open(CURRENT_TTY, O_RDONLY);
1335         if (kbd_fd < 0)
1336                 return bb_cat(argv);
1337
1338         if (!num_files) {
1339                 if (isatty(STDIN_FILENO)) {
1340                         /* Just "less"? No args and no redirection? */
1341                         bb_error_msg("missing filename");
1342                         bb_show_usage();
1343                 }
1344         } else
1345                 filename = xstrdup(files[0]);
1346
1347         get_terminal_width_height(kbd_fd, &width, &max_displayed_line);
1348         /* 20: two tabstops + 4 */
1349         if (width < 20 || max_displayed_line < 3)
1350                 bb_error_msg_and_die("too narrow here");
1351         max_displayed_line -= 2;
1352
1353         buffer = xmalloc((max_displayed_line+1) * sizeof(char *));
1354         if (option_mask32 & FLAG_TILDE)
1355                 empty_line_marker = "";
1356
1357         tcgetattr(kbd_fd, &term_orig);
1358         signal(SIGTERM, sig_catcher);
1359         signal(SIGINT, sig_catcher);
1360         term_less = term_orig;
1361         term_less.c_lflag &= ~(ICANON | ECHO);
1362         term_less.c_iflag &= ~(IXON | ICRNL);
1363         /*term_less.c_oflag &= ~ONLCR;*/
1364         term_less.c_cc[VMIN] = 1;
1365         term_less.c_cc[VTIME] = 0;
1366
1367         /* Want to do it just once, but it doesn't work, */
1368         /* so we are redoing it (see code above). Mystery... */
1369         /*tcsetattr(kbd_fd, TCSANOW, &term_less);*/
1370
1371         reinitialize();
1372         while (1) {
1373                 keypress = less_getch();
1374                 keypress_process(keypress);
1375         }
1376 }