[821] | 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 | }
|
---|