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  *      This program needs a lot of development, so consider it in a beta stage
  12  *      at best.
  13  *
  14  *      TODO:
  15  *      - Add more regular expression support - search modifiers, certain matches, etc.
  16  *      - Add more complex bracket searching - currently, nested brackets are
  17  *      not considered.
  18  *      - Add support for "F" as an input. This causes less to act in
  19  *      a similar way to tail -f.
  20  *      - Check for binary files, and prompt the user if a binary file
  21  *      is detected.
  22  *      - Allow horizontal scrolling. Currently, lines simply continue onto
  23  *      the next line, per the terminal's discretion
  24  *
  25  *      Notes:
  26  *      - filename is an array and not a pointer because that avoids all sorts
  27  *      of complications involving the fact that something that is pointed to
  28  *      will be changed if the pointer is changed.
  29  *      - the inp file pointer is used so that keyboard input works after
  30  *      redirected input has been read from stdin
  31 */
  32
  33 #include "busybox.h"
  34 #include <stdio.h>
  35 #include <stdlib.h>
  36 #include <string.h>
  37 #include <termios.h>
  38 #include <unistd.h>
  39 #include <ctype.h>
  40
  41 #ifdef CONFIG_FEATURE_LESS_REGEXP
  42 #include "xregex.h"
  43 #endif
  44
  45
  46 /* These are the escape sequences corresponding to special keys */
  47 #define REAL_KEY_UP 'A'
  48 #define REAL_KEY_DOWN 'B'
  49 #define REAL_KEY_RIGHT 'C'
  50 #define REAL_KEY_LEFT 'D'
  51 #define REAL_PAGE_UP '5'
  52 #define REAL_PAGE_DOWN '6'
  53
  54 /* These are the special codes assigned by this program to the special keys */
  55 #define PAGE_UP 20
  56 #define PAGE_DOWN 21
  57 #define KEY_UP 22
  58 #define KEY_DOWN 23
  59 #define KEY_RIGHT 24
  60 #define KEY_LEFT 25
  61
  62 /* The escape codes for highlighted and normal text */
  63 #define HIGHLIGHT "\033[7m"
  64 #define NORMAL "\033[0m"
  65
  66 /* The escape code to clear the screen */
  67 #define CLEAR "\033[H\033[J"
  68
  69 /* Maximum number of lines in a file */
  70 #define MAXLINES 10000
  71
  72 static int height;
  73 static int width;
  74 static char **files;
  75 static char filename[256];
  76 static char **buffer;
  77 static char **flines;
  78 static int current_file = 1;
  79 static int line_pos;
  80 static int num_flines;
  81 static int num_files = 1;
  82 static int past_eof;
  83
  84 /* Command line options */
  85 static unsigned long flags;
  86 #define FLAG_E 1
  87 #define FLAG_M (1<<1)
  88 #define FLAG_m (1<<2)
  89 #define FLAG_N (1<<3)
  90 #define FLAG_TILDE (1<<4)
  91
  92 /* This is needed so that program behaviour changes when input comes from
  93    stdin */
  94 static int inp_stdin;
  95
  96 #ifdef CONFIG_FEATURE_LESS_MARKS
  97 static int mark_lines[15][2];
  98 static int num_marks;
  99 #endif
 100
 101 #ifdef CONFIG_FEATURE_LESS_REGEXP
 102 static int match_found;
 103 static int *match_lines;
 104 static int match_pos;
 105 static int num_matches;
 106 static int match_backwards;
 107 static regex_t old_pattern;
 108 #endif
 109
 110 /* Needed termios structures */
 111 static struct termios term_orig, term_vi;
 112
 113 /* File pointer to get input from */
 114 static FILE *inp;
 115
 116 /* Reset terminal input to normal */
 117 static void set_tty_cooked(void)
 118 {
 119         fflush(stdout);
 120         tcsetattr(fileno(inp), TCSANOW, &term_orig);
 121 }
 122
 123 /* Set terminal input to raw mode  (taken from vi.c) */
 124 static void set_tty_raw(void)
 125 {
 126         tcsetattr(fileno(inp), TCSANOW, &term_vi);
 127 }
 128
 129 /* Exit the program gracefully */
 130 static void tless_exit(int code)
 131 {
 132         /* TODO: We really should save the terminal state when we start,
 133                  and restore it when we exit. Less does this with the
 134                  "ti" and "te" termcap commands; can this be done with
 135                  only termios.h? */
 136
 137         putchar('\n');
 138         exit(code);
 139 }
 140
 141 /* Grab a character from input without requiring the return key. If the
 142    character is ASCII \033, get more characters and assign certain sequences
 143    special return codes. Note that this function works best with raw input. */
 144 static int tless_getch(void)
 145 {
 146         int input;
 147
 148         set_tty_raw();
 149
 150         input = getc(inp);
 151         /* Detect escape sequences (i.e. arrow keys) and handle
 152            them accordingly */
 153
 154         if (input == '\033' && getc(inp) == '[') {
 155                 input = getc(inp);
 156                 set_tty_cooked();
 157                 if (input == REAL_KEY_UP)
 158                         return KEY_UP;
 159                 else if (input == REAL_KEY_DOWN)
 160                         return KEY_DOWN;
 161                 else if (input == REAL_KEY_RIGHT)
 162                         return KEY_RIGHT;
 163                 else if (input == REAL_KEY_LEFT)
 164                         return KEY_LEFT;
 165                 else if (input == REAL_PAGE_UP)
 166                         return PAGE_UP;
 167                 else if (input == REAL_PAGE_DOWN)
 168                         return PAGE_DOWN;
 169         }
 170         /* The input is a normal ASCII value */
 171         else {
 172                 set_tty_cooked();
 173                 return input;
 174         }
 175         return 0;
 176 }
 177
 178 /* Move the cursor to a position (x,y), where (0,0) is the
 179    top-left corner of the console */
 180 static void move_cursor(int x, int y)
 181 {
 182         printf("\033[%i;%iH", x, y);
 183 }
 184
 185 static void clear_line(void)
 186 {
 187         move_cursor(height, 0);
 188         printf("\033[K");
 189 }
 190
 191 /* This adds line numbers to every line, as the -N flag necessitates */
 192 static void add_linenumbers(void)
 193 {
 194         char current_line[256];
 195         int i;
 196
 197         for (i = 0; i <= num_flines; i++) {
 198                 safe_strncpy(current_line, flines[i], 256);
 199                 flines[i] = bb_xasprintf("%5d %s", i + 1, current_line);
 200         }
 201 }
 202
 203 static void data_readlines(void)
 204 {
 205         int i;
 206         char current_line[256];
 207         FILE *fp;
 208
 209         fp = (inp_stdin) ? stdin : bb_xfopen(filename, "r");
 210         flines = NULL;
 211         for (i = 0; (feof(fp)==0) && (i <= MAXLINES); i++) {
 212                 strcpy(current_line, "");
 213                 fgets(current_line, 256, fp);
 214                 if (fp != stdin)
 215                         bb_xferror(fp, filename);
 216                 flines = xrealloc(flines, (i+1) * sizeof(char *));
 217                 flines[i] = bb_xstrdup(current_line);
 218         }
 219         num_flines = i - 2;
 220
 221         /* Reset variables for a new file */
 222
 223         line_pos = 0;
 224         past_eof = 0;
 225
 226         fclose(fp);
 227
 228         if (inp == NULL)
 229                 inp = (inp_stdin) ? bb_xfopen(CURRENT_TTY, "r") : stdin;
 230
 231         if (flags & FLAG_N)
 232                 add_linenumbers();
 233 }
 234
 235 #ifdef CONFIG_FEATURE_LESS_FLAGS
 236
 237 /* Interestingly, writing calc_percent as a function and not a prototype saves around 32 bytes
 238  * on my build. */
 239 static int calc_percent(void)
 240 {
 241         return ((100 * (line_pos + height - 2) / num_flines) + 1);
 242 }
 243
 244 /* Print a status line if -M was specified */
 245 static void m_status_print(void)
 246 {
 247         int percentage;
 248
 249         if (!past_eof) {
 250                 if (!line_pos) {
 251                         if (num_files > 1)
 252                                 printf("%s%s %s%i%s%i%s%i-%i/%i ", HIGHLIGHT, filename, "(file ", current_file, " of ", num_files, ") lines ", line_pos + 1, line_pos + height - 1, num_flines + 1);
 253                         else {
 254                                 printf("%s%s lines %i-%i/%i ", HIGHLIGHT, filename, line_pos + 1, line_pos + height - 1, num_flines + 1);
 255                         }
 256                 }
 257                 else {
 258                         printf("%s %s lines %i-%i/%i ", HIGHLIGHT, filename, line_pos + 1, line_pos + height - 1, num_flines + 1);
 259                 }
 260
 261                 if (line_pos == num_flines - height + 2) {
 262                         printf("(END) %s", NORMAL);
 263                         if ((num_files > 1) && (current_file != num_files))
 264                                 printf("%s- Next: %s%s", HIGHLIGHT, files[current_file], NORMAL);
 265                 }
 266                 else {
 267                         percentage = calc_percent();
 268                         printf("%i%% %s", percentage, NORMAL);
 269                 }
 270         }
 271         else {
 272                 printf("%s%s lines %i-%i/%i (END) ", HIGHLIGHT, filename, line_pos + 1, num_flines + 1, num_flines + 1);
 273                 if ((num_files > 1) && (current_file != num_files))
 274                         printf("- Next: %s", files[current_file]);
 275                 printf("%s", NORMAL);
 276         }
 277 }
 278
 279 /* Print a status line if -m was specified */
 280 static void medium_status_print(void)
 281 {
 282         int percentage;
 283         percentage = calc_percent();
 284
 285         if (!line_pos)
 286                 printf("%s%s %i%%%s", HIGHLIGHT, filename, percentage, NORMAL);
 287         else if (line_pos == num_flines - height + 2)
 288                 printf("%s(END)%s", HIGHLIGHT, NORMAL);
 289         else
 290                 printf("%s%i%%%s", HIGHLIGHT, percentage, NORMAL);
 291 }
 292 #endif
 293
 294 /* Print the status line */
 295 static void status_print(void)
 296 {
 297         /* Change the status if flags have been set */
 298 #ifdef CONFIG_FEATURE_LESS_FLAGS
 299         if (flags & FLAG_M)
 300                 m_status_print();
 301         else if (flags & FLAG_m)
 302                 medium_status_print();
 303         /* No flags set */
 304         else {
 305 #endif
 306                 if (!line_pos) {
 307                         printf("%s%s %s", HIGHLIGHT, filename, NORMAL);
 308                         if (num_files > 1)
 309                                 printf("%s%s%i%s%i%s%s", HIGHLIGHT, "(file ", current_file, " of ", num_files, ")", NORMAL);
 310                 }
 311                 else if (line_pos == num_flines - height + 2) {
 312                         printf("%s%s %s", HIGHLIGHT, "(END)", NORMAL);
 313                         if ((num_files > 1) && (current_file != num_files))
 314                                 printf("%s%s%s%s", HIGHLIGHT, "- Next: ", files[current_file], NORMAL);
 315                 }
 316                 else {
 317                         putchar(':');
 318                 }
 319 #ifdef CONFIG_FEATURE_LESS_FLAGS
 320         }
 321 #endif
 322 }
 323
 324 /* Print the buffer */
 325 static void buffer_print(void)
 326 {
 327         int i;
 328
 329         printf("%s", CLEAR);
 330         if (num_flines >= height - 2) {
 331                 for (i = 0; i < height - 1; i++)
 332                         printf("%s", buffer[i]);
 333         }
 334         else {
 335                 for (i = 1; i < (height - 1 - num_flines); i++)
 336                         putchar('\n');
 337                 for (i = 0; i < height - 1; i++)
 338                         printf("%s", buffer[i]);
 339         }
 340
 341         status_print();
 342 }
 343
 344 /* Initialise the buffer */
 345 static void buffer_init(void)
 346 {
 347         int i;
 348
 349         if (buffer == NULL) {
 350                 /* malloc the number of lines needed for the buffer */
 351                 buffer = xrealloc(buffer, height * sizeof(char *));
 352         } else {
 353                 for (i = 0; i < (height - 1); i++)
 354                         free(buffer[i]);
 355         }
 356
 357         /* Fill the buffer until the end of the file or the
 358            end of the buffer is reached */
 359         for (i = 0; (i < (height - 1)) && (i <= num_flines); i++) {
 360                 buffer[i] = bb_xstrdup(flines[i]);
 361         }
 362
 363         /* If the buffer still isn't full, fill it with blank lines */
 364         for (; i < (height - 1); i++) {
 365                 buffer[i] = bb_xstrdup("");
 366         }
 367 }
 368
 369 /* Move the buffer up and down in the file in order to scroll */
 370 static void buffer_down(int nlines)
 371 {
 372         int i;
 373
 374         if (!past_eof) {
 375                 if (line_pos + (height - 3) + nlines < num_flines) {
 376                         line_pos += nlines;
 377                         for (i = 0; i < (height - 1); i++) {
 378                                 free(buffer[i]);
 379                                 buffer[i] = bb_xstrdup(flines[line_pos + i]);
 380                         }
 381                 }
 382                 else {
 383                         /* As the number of lines requested was too large, we just move
 384                         to the end of the file */
 385                         while (line_pos + (height - 3) + 1 < num_flines) {
 386                                 line_pos += 1;
 387                                 for (i = 0; i < (height - 1); i++) {
 388                                         free(buffer[i]);
 389                                         buffer[i] = bb_xstrdup(flines[line_pos + i]);
 390                                 }
 391                         }
 392                 }
 393
 394                 /* We exit if the -E flag has been set */
 395                 if ((flags & FLAG_E) && (line_pos + (height - 2) == num_flines))
 396                         tless_exit(0);
 397         }
 398 }
 399
 400 static void buffer_up(int nlines)
 401 {
 402         int i;
 403         int tilde_line;
 404
 405         if (!past_eof) {
 406                 if (line_pos - nlines >= 0) {
 407                         line_pos -= nlines;
 408                         for (i = 0; i < (height - 1); i++) {
 409                                 free(buffer[i]);
 410                                 buffer[i] = bb_xstrdup(flines[line_pos + i]);
 411                         }
 412                 }
 413                 else {
 414                 /* As the requested number of lines to move was too large, we
 415                    move one line up at a time until we can't. */
 416                         while (line_pos != 0) {
 417                                 line_pos -= 1;
 418                                 for (i = 0; i < (height - 1); i++) {
 419                                         free(buffer[i]);
 420                                         buffer[i] = bb_xstrdup(flines[line_pos + i]);
 421                                 }
 422                         }
 423                 }
 424         }
 425         else {
 426                 /* Work out where the tildes start */
 427                 tilde_line = num_flines - line_pos + 3;
 428
 429                 line_pos -= nlines;
 430                 /* Going backwards nlines lines has taken us to a point where
 431                    nothing is past the EOF, so we revert to normal. */
 432                 if (line_pos < num_flines - height + 3) {
 433                         past_eof = 0;
 434                         buffer_up(nlines);
 435                 }
 436                 else {
 437                         /* We only move part of the buffer, as the rest
 438                         is past the EOF */
 439                         for (i = 0; i < (height - 1); i++) {
 440                                 free(buffer[i]);
 441                                 if (i < tilde_line - nlines + 1)
 442                                         buffer[i] = bb_xstrdup(flines[line_pos + i]);
 443                                 else {
 444                                         if (line_pos >= num_flines - height + 2)
 445                                                 buffer[i] = bb_xstrdup("~\n");
 446                                 }
 447                         }
 448                 }
 449         }
 450 }
 451
 452 static void buffer_line(int linenum)
 453 {
 454         int i;
 455         past_eof = 0;
 456
 457         if (linenum < 0 || linenum > num_flines) {
 458                 clear_line();
 459                 printf("%s%s%i%s", HIGHLIGHT, "Cannot seek to line number ", linenum + 1, NORMAL);
 460         }
 461         else if (linenum < (num_flines - height - 2)) {
 462                 for (i = 0; i < (height - 1); i++) {
 463                         free(buffer[i]);
 464                         buffer[i] = bb_xstrdup(flines[linenum + i]);
 465                 }
 466                 line_pos = linenum;
 467                 buffer_print();
 468         }
 469         else {
 470                 for (i = 0; i < (height - 1); i++) {
 471                         free(buffer[i]);
 472                         if (linenum + i < num_flines + 2)
 473                                 buffer[i] = bb_xstrdup(flines[linenum + i]);
 474                         else
 475                                 buffer[i] = bb_xstrdup((flags & FLAG_TILDE) ? "\n" : "~\n");
 476                 }
 477                 line_pos = linenum;
 478                 /* Set past_eof so buffer_down and buffer_up act differently */
 479                 past_eof = 1;
 480                 buffer_print();
 481         }
 482 }
 483
 484 /* Reinitialise everything for a new file - free the memory and start over */
 485 static void reinitialise(void)
 486 {
 487         int i;
 488
 489         for (i = 0; i <= num_flines; i++)
 490                 free(flines[i]);
 491         free(flines);
 492
 493         data_readlines();
 494         buffer_init();
 495         buffer_print();
 496 }
 497
 498 static void examine_file(void)
 499 {
 500         int newline_offset;
 501
 502         clear_line();
 503         printf("Examine: ");
 504         fgets(filename, 256, inp);
 505
 506         /* As fgets adds a newline to the end of an input string, we
 507            need to remove it */
 508         newline_offset = strlen(filename) - 1;
 509         filename[newline_offset] = '\0';
 510
 511         files[num_files] = bb_xstrdup(filename);
 512         current_file = num_files + 1;
 513         num_files++;
 514
 515         inp_stdin = 0;
 516         reinitialise();
 517 }
 518
 519 /* This function changes the file currently being paged. direction can be one of the following:
 520  * -1: go back one file
 521  *  0: go to the first file
 522  *  1: go forward one file
 523 */
 524 static void change_file(int direction)
 525 {
 526         if (current_file != ((direction > 0) ? num_files : 1)) {
 527                 current_file = direction ? current_file + direction : 1;
 528                 strcpy(filename, files[current_file - 1]);
 529                 reinitialise();
 530         }
 531         else {
 532                 clear_line();
 533                 printf("%s%s%s", HIGHLIGHT, (direction > 0) ? "No next file" : "No previous file", NORMAL);
 534         }
 535 }
 536
 537 static void remove_current_file(void)
 538 {
 539         int i;
 540
 541         if (current_file != 1) {
 542                 change_file(-1);
 543                 for (i = 3; i <= num_files; i++)
 544                         files[i - 2] = files[i - 1];
 545                 num_files--;
 546                 buffer_print();
 547         }
 548         else {
 549                 change_file(1);
 550                 for (i = 2; i <= num_files; i++)
 551                         files[i - 2] = files[i - 1];
 552                 num_files--;
 553                 current_file--;
 554                 buffer_print();
 555         }
 556 }
 557
 558 static void colon_process(void)
 559 {
 560         int keypress;
 561
 562         /* Clear the current line and print a prompt */
 563         clear_line();
 564         printf(" :");
 565
 566         keypress = tless_getch();
 567         switch (keypress) {
 568                 case 'd':
 569                         remove_current_file();
 570                         break;
 571                 case 'e':
 572                         examine_file();
 573                         break;
 574 #ifdef CONFIG_FEATURE_LESS_FLAGS
 575                 case 'f':
 576                         clear_line();
 577                         m_status_print();
 578                         break;
 579 #endif
 580                 case 'n':
 581                         change_file(1);
 582                         break;
 583                 case 'p':
 584                         change_file(-1);
 585                         break;
 586                 case 'q':
 587                         tless_exit(0);
 588                         break;
 589                 case 'x':
 590                         change_file(0);
 591                         break;
 592                 default:
 593                         break;
 594         }
 595 }
 596
 597 #ifdef CONFIG_FEATURE_LESS_REGEXP
 598 /* The below two regular expression handler functions NEED development. */
 599
 600 /* Get a regular expression from the user, and then go through the current
 601    file line by line, running a processing regex function on each one. */
 602
 603 static char *process_regex_on_line(char *line, regex_t *pattern, int action)
 604 {
 605         /* This function takes the regex and applies it to the line.
 606            Each part of the line that matches has the HIGHLIGHT
 607            and NORMAL escape sequences placed around it by
 608            insert_highlights if action = 1, or has the escape sequences
 609            removed if action = 0, and then the line is returned. */
 610         int match_status;
 611         char *line2 = (char *) xmalloc((sizeof(char) * (strlen(line) + 1)) + 64);
 612         char *growline = "";
 613         regmatch_t match_structs;
 614
 615         line2 = bb_xstrdup(line);
 616
 617         match_found = 0;
 618         match_status = regexec(pattern, line2, 1, &match_structs, 0);
 619
 620         while (match_status == 0) {
 621                 if (match_found == 0)
 622                         match_found = 1;
 623
 624                 if (action) {
 625                         growline = bb_xasprintf("%s%.*s%s%.*s%s", growline, match_structs.rm_so, line2, HIGHLIGHT, match_structs.rm_eo - match_structs.rm_so, line2 + match_structs.rm_so, NORMAL);
 626                 }
 627                 else {
 628                         growline = bb_xasprintf("%s%.*s%.*s", growline, match_structs.rm_so - 4, line2, match_structs.rm_eo - match_structs.rm_so, line2 + match_structs.rm_so);
 629                 }
 630
 631                 line2 += match_structs.rm_eo;
 632                 match_status = regexec(pattern, line2, 1, &match_structs, REG_NOTBOL);
 633         }
 634
 635         growline = bb_xasprintf("%s%s", growline, line2);
 636
 637         return (match_found ? growline : line);
 638
 639         free(growline);
 640         free(line2);
 641 }
 642
 643 static void goto_match(int match)
 644 {
 645         /* This goes to a specific match - all line positions of matches are
 646            stored within the match_lines[] array. */
 647         if ((match < num_matches) && (match >= 0)) {
 648                 buffer_line(match_lines[match]);
 649                 match_pos = match;
 650         }
 651 }
 652
 653 static void regex_process(void)
 654 {
 655         char uncomp_regex[100];
 656         char *current_line;
 657         int i;
 658         int j = 0;
 659         regex_t pattern;
 660         /* Get the uncompiled regular expression from the user */
 661         clear_line();
 662         putchar((match_backwards) ? '?' : '/');
 663         uncomp_regex[0] = 0;
 664         fgets(uncomp_regex, sizeof(uncomp_regex), inp);
 665
 666         if (strlen(uncomp_regex) == 1) {
 667                 if (num_matches)
 668                         goto_match(match_backwards ? match_pos - 1 : match_pos + 1);
 669                 else
 670                         buffer_print();
 671                 return;
 672         }
 673         uncomp_regex[strlen(uncomp_regex) - 1] = '\0';
 674
 675         /* Compile the regex and check for errors */
 676         xregcomp(&pattern, uncomp_regex, 0);
 677
 678         if (num_matches) {
 679                 /* Get rid of all the highlights we added previously */
 680                 for (i = 0; i <= num_flines; i++) {
 681                         current_line = process_regex_on_line(flines[i], &old_pattern, 0);
 682                         flines[i] = bb_xstrdup(current_line);
 683                 }
 684         }
 685         old_pattern = pattern;
 686
 687         /* Reset variables */
 688         match_lines = xrealloc(match_lines, sizeof(int));
 689         match_lines[0] = -1;
 690         match_pos = 0;
 691         num_matches = 0;
 692         match_found = 0;
 693         /* Run the regex on each line of the current file here */
 694         for (i = 0; i <= num_flines; i++) {
 695                 current_line = process_regex_on_line(flines[i], &pattern, 1);
 696                 flines[i] = bb_xstrdup(current_line);
 697                 if (match_found) {
 698                         match_lines = xrealloc(match_lines, (j + 1) * sizeof(int));
 699                         match_lines[j] = i;
 700                         j++;
 701                 }
 702         }
 703
 704         num_matches = j;
 705         if ((match_lines[0] != -1) && (num_flines > height - 2)) {
 706                 if (match_backwards) {
 707                         for (i = 0; i < num_matches; i++) {
 708                                 if (match_lines[i] > line_pos) {
 709                                         match_pos = i - 1;
 710                                         buffer_line(match_lines[match_pos]);
 711                                         break;
 712                                 }
 713                         }
 714                 }
 715                 else
 716                         buffer_line(match_lines[0]);
 717         }
 718         else
 719                 buffer_init();
 720 }
 721 #endif
 722
 723 static void number_process(int first_digit)
 724 {
 725         int i = 1;
 726         int num;
 727         char num_input[80];
 728         char keypress;
 729         char *endptr;
 730
 731         num_input[0] = first_digit;
 732
 733         /* Clear the current line, print a prompt, and then print the digit */
 734         clear_line();
 735         printf(":%c", first_digit);
 736
 737         /* Receive input until a letter is given (max 80 chars)*/
 738         while((i < 80) && (num_input[i] = tless_getch()) && isdigit(num_input[i])) {
 739                 putchar(num_input[i]);
 740                 i++;
 741         }
 742
 743         /* Take the final letter out of the digits string */
 744         keypress = num_input[i];
 745         num_input[i] = '\0';
 746         num = strtol(num_input, &endptr, 10);
 747         if (endptr==num_input || *endptr!='\0' || num < 1 || num > MAXLINES) {
 748                 buffer_print();
 749                 return;
 750         }
 751
 752         /* We now know the number and the letter entered, so we process them */
 753         switch (keypress) {
 754                 case KEY_DOWN: case 'z': case 'd': case 'e': case ' ': case '\015':
 755                         buffer_down(num);
 756                         break;
 757                 case KEY_UP: case 'b': case 'w': case 'y': case 'u':
 758                         buffer_up(num);
 759                         break;
 760                 case 'g': case '<': case 'G': case '>':
 761                         if (num_flines >= height - 2)
 762                                 buffer_line(num - 1);
 763                         break;
 764                 case 'p': case '%':
 765                         buffer_line(((num / 100) * num_flines) - 1);
 766                         break;
 767 #ifdef CONFIG_FEATURE_LESS_REGEXP
 768                 case 'n':
 769                         goto_match(match_pos + num);
 770                         break;
 771                 case '/':
 772                         match_backwards = 0;
 773                         regex_process();
 774                         break;
 775                 case '?':
 776                         match_backwards = 1;
 777                         regex_process();
 778                         break;
 779 #endif
 780                 default:
 781                         break;
 782         }
 783 }
 784
 785 #ifdef CONFIG_FEATURE_LESS_FLAGCS
 786 static void flag_change(void)
 787 {
 788         int keypress;
 789
 790         clear_line();
 791         putchar('-');
 792         keypress = tless_getch();
 793
 794         switch (keypress) {
 795                 case 'M':
 796                         flags ^= FLAG_M;
 797                         break;
 798                 case 'm':
 799                         flags ^= FLAG_m;
 800                         break;
 801                 case 'E':
 802                         flags ^= FLAG_E;
 803                         break;
 804                 case '~':
 805                         flags ^= FLAG_TILDE;
 806                         break;
 807                 default:
 808                         break;
 809         }
 810 }
 811
 812 static void show_flag_status(void)
 813 {
 814         int keypress;
 815         int flag_val;
 816
 817         clear_line();
 818         putchar('_');
 819         keypress = tless_getch();
 820
 821         switch (keypress) {
 822                 case 'M':
 823                         flag_val = flags & FLAG_M;
 824                         break;
 825                 case 'm':
 826                         flag_val = flags & FLAG_m;
 827                         break;
 828                 case '~':
 829                         flag_val = flags & FLAG_TILDE;
 830                         break;
 831                 case 'N':
 832                         flag_val = flags & FLAG_N;
 833                         break;
 834                 case 'E':
 835                         flag_val = flags & FLAG_E;
 836                         break;
 837                 default:
 838                         flag_val = 0;
 839                         break;
 840         }
 841
 842         clear_line();
 843         printf("%s%s%i%s", HIGHLIGHT, "The status of the flag is: ", flag_val != 0, NORMAL);
 844 }
 845 #endif
 846
 847 static void full_repaint(void)
 848 {
 849         int temp_line_pos = line_pos;
 850         data_readlines();
 851         buffer_init();
 852         buffer_line(temp_line_pos);
 853 }
 854
 855
 856 static void save_input_to_file(void)
 857 {
 858         char current_line[256];
 859         int i;
 860         FILE *fp;
 861
 862         clear_line();
 863         printf("Log file: ");
 864         fgets(current_line, 256, inp);
 865         current_line[strlen(current_line) - 1] = '\0';
 866         if (strlen(current_line) > 1) {
 867                 fp = bb_xfopen(current_line, "w");
 868                 for (i = 0; i < num_flines; i++)
 869                         fprintf(fp, "%s", flines[i]);
 870                 fclose(fp);
 871                 buffer_print();
 872         }
 873         else
 874                 printf("%sNo log file%s", HIGHLIGHT, NORMAL);
 875 }
 876
 877 #ifdef CONFIG_FEATURE_LESS_MARKS
 878 static void add_mark(void)
 879 {
 880         int letter;
 881         int mark_line;
 882
 883         clear_line();
 884         printf("Mark: ");
 885         letter = tless_getch();
 886
 887         if (isalpha(letter)) {
 888                 mark_line = line_pos;
 889
 890                 /* If we exceed 15 marks, start overwriting previous ones */
 891                 if (num_marks == 14)
 892                         num_marks = 0;
 893
 894                 mark_lines[num_marks][0] = letter;
 895                 mark_lines[num_marks][1] = line_pos;
 896                 num_marks++;
 897         }
 898         else {
 899                 clear_line();
 900                 printf("%s%s%s", HIGHLIGHT, "Invalid mark letter", NORMAL);
 901         }
 902 }
 903
 904 static void goto_mark(void)
 905 {
 906         int letter;
 907         int i;
 908
 909         clear_line();
 910         printf("Go to mark: ");
 911         letter = tless_getch();
 912         clear_line();
 913
 914         if (isalpha(letter)) {
 915                 for (i = 0; i <= num_marks; i++)
 916                         if (letter == mark_lines[i][0]) {
 917                                 buffer_line(mark_lines[i][1]);
 918                                 break;
 919                         }
 920                 if ((num_marks == 14) && (letter != mark_lines[14][0]))
 921                         printf("%s%s%s", HIGHLIGHT, "Mark not set", NORMAL);
 922         }
 923         else
 924                 printf("%s%s%s", HIGHLIGHT, "Invalid mark letter", NORMAL);
 925 }
 926 #endif
 927
 928
 929 #ifdef CONFIG_FEATURE_LESS_BRACKETS
 930
 931 static char opp_bracket(char bracket)
 932 {
 933         switch (bracket) {
 934                 case '{': case '[':
 935                         return bracket + 2;
 936                         break;
 937                 case '(':
 938                         return ')';
 939                         break;
 940                 case '}': case ']':
 941                         return bracket - 2;
 942                         break;
 943                 case ')':
 944                         return '(';
 945                         break;
 946                 default:
 947                         return 0;
 948                         break;
 949         }
 950 }
 951
 952 static void match_right_bracket(char bracket)
 953 {
 954         int bracket_line = -1;
 955         int i;
 956
 957         clear_line();
 958
 959         if (strchr(flines[line_pos], bracket) == NULL)
 960                 printf("%s%s%s", HIGHLIGHT, "No bracket in top line", NORMAL);
 961         else {
 962                 for (i = line_pos + 1; i < num_flines; i++) {
 963                         if (strchr(flines[i], opp_bracket(bracket)) != NULL) {
 964                                 bracket_line = i;
 965                                 break;
 966                         }
 967                 }
 968
 969                 if (bracket_line == -1)
 970                         printf("%s%s%s", HIGHLIGHT, "No matching bracket found", NORMAL);
 971
 972                 buffer_line(bracket_line - height + 2);
 973         }
 974 }
 975
 976 static void match_left_bracket(char bracket)
 977 {
 978         int bracket_line = -1;
 979         int i;
 980
 981         clear_line();
 982
 983         if (strchr(flines[line_pos + height - 2], bracket) == NULL) {
 984                 printf("%s%s%s", HIGHLIGHT, "No bracket in bottom line", NORMAL);
 985                 printf("%s", flines[line_pos + height]);
 986                 sleep(4);
 987         }
 988         else {
 989                 for (i = line_pos + height - 2; i >= 0; i--) {
 990                         if (strchr(flines[i], opp_bracket(bracket)) != NULL) {
 991                                 bracket_line = i;
 992                                 break;
 993                         }
 994                 }
 995
 996                 if (bracket_line == -1)
 997                         printf("%s%s%s", HIGHLIGHT, "No matching bracket found", NORMAL);
 998
 999                 buffer_line(bracket_line);
1000         }
1001 }
1002
1003 #endif  /* CONFIG_FEATURE_LESS_BRACKETS */
1004
1005 static void keypress_process(int keypress)
1006 {
1007         switch (keypress) {
1008                 case KEY_DOWN: case 'e': case 'j': case '\015':
1009                         buffer_down(1);
1010                         buffer_print();
1011                         break;
1012                 case KEY_UP: case 'y': case 'k':
1013                         buffer_up(1);
1014                         buffer_print();
1015                         break;
1016                 case PAGE_DOWN: case ' ': case 'z':
1017                         buffer_down(height - 1);
1018                         buffer_print();
1019                         break;
1020                 case PAGE_UP: case 'w': case 'b':
1021                         buffer_up(height - 1);
1022                         buffer_print();
1023                         break;
1024                 case 'd':
1025                         buffer_down((height - 1) / 2);
1026                         buffer_print();
1027                         break;
1028                 case 'u':
1029                         buffer_up((height - 1) / 2);
1030                         buffer_print();
1031                         break;
1032                 case 'g': case 'p': case '<': case '%':
1033                         buffer_line(0);
1034                         break;
1035                 case 'G': case '>':
1036                         buffer_line(num_flines - height + 2);
1037                         break;
1038                 case 'q': case 'Q':
1039                         tless_exit(0);
1040                         break;
1041 #ifdef CONFIG_FEATURE_LESS_MARKS
1042                 case 'm':
1043                         add_mark();
1044                         buffer_print();
1045                         break;
1046                 case '\'':
1047                         goto_mark();
1048                         buffer_print();
1049                         break;
1050 #endif
1051                 case 'r':
1052                         buffer_print();
1053                         break;
1054                 case 'R':
1055                         full_repaint();
1056                         break;
1057                 case 's':
1058                         if (inp_stdin)
1059                                 save_input_to_file();
1060                         break;
1061                 case 'E':
1062                         examine_file();
1063                         break;
1064 #ifdef CONFIG_FEATURE_LESS_FLAGS
1065                 case '=':
1066                         clear_line();
1067                         m_status_print();
1068                         break;
1069 #endif
1070 #ifdef CONFIG_FEATURE_LESS_REGEXP
1071                 case '/':
1072                         match_backwards = 0;
1073                         regex_process();
1074                         break;
1075                 case 'n':
1076                         goto_match(match_pos + 1);
1077                         break;
1078                 case 'N':
1079                         goto_match(match_pos - 1);
1080                         break;
1081                 case '?':
1082                         match_backwards = 1;
1083                         regex_process();
1084                         break;
1085 #endif
1086 #ifdef CONFIG_FEATURE_LESS_FLAGCS
1087                 case '-':
1088                         flag_change();
1089                         buffer_print();
1090                         break;
1091                 case '_':
1092                         show_flag_status();
1093                         break;
1094 #endif
1095 #ifdef CONFIG_FEATURE_LESS_BRACKETS
1096                 case '{': case '(': case '[':
1097                         match_right_bracket(keypress);
1098                         break;
1099                 case '}': case ')': case ']':
1100                         match_left_bracket(keypress);
1101                         break;
1102 #endif
1103                 case ':':
1104                         colon_process();
1105                         break;
1106                 default:
1107                         break;
1108         }
1109
1110         if (isdigit(keypress))
1111                 number_process(keypress);
1112 }
1113
1114 int less_main(int argc, char **argv) {
1115
1116         int keypress;
1117
1118         flags = bb_getopt_ulflags(argc, argv, "EMmN~");
1119
1120         argc -= optind;
1121         argv += optind;
1122         files = argv;
1123         num_files = argc;
1124
1125         if (!num_files) {
1126                 if (ttyname(STDIN_FILENO) == NULL)
1127                         inp_stdin = 1;
1128                 else {
1129                         bb_error_msg("Missing filename");
1130                         bb_show_usage();
1131                 }
1132         }
1133
1134         strcpy(filename, (inp_stdin) ? bb_msg_standard_input : files[0]);
1135         get_terminal_width_height(0, &width, &height);
1136         data_readlines();
1137         tcgetattr(fileno(inp), &term_orig);
1138         term_vi = term_orig;
1139         term_vi.c_lflag &= (~ICANON & ~ECHO);
1140         term_vi.c_iflag &= (~IXON & ~ICRNL);
1141         term_vi.c_oflag &= (~ONLCR);
1142         term_vi.c_cc[VMIN] = 1;
1143         term_vi.c_cc[VTIME] = 0;
1144         buffer_init();
1145         buffer_print();
1146
1147         while (1) {
1148                 keypress = tless_getch();
1149                 keypress_process(keypress);
1150         }
1151 }