source: MondoRescue/branches/2.2.5/mindi-busybox/miscutils/less.c@ 1765

Last change on this file since 1765 was 1765, checked in by Bruno Cornec, 16 years ago

Update to busybox 1.7.2
File size: 30.9 KB
Line 
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 */
44enum {
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 */
76enum {
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
87enum { pattern_valid = 0 };
88#endif
89
90struct 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 */
163static void set_tty_cooked(void)
164{
165 fflush(stdout);
166 tcsetattr(kbd_fd, TCSANOW, &term_orig);
167}
168
169/* Exit the program gracefully */
170static void less_exit(int code)
171{
172 /* TODO: We really should save the terminal state when we start,
173 * and restore it when we exit. Less does this with the
174 * "ti" and "te" termcap commands; can this be done with
175 * only termios.h? */
176 putchar('\n');
177 fflush_stdout_and_exit(code);
178}
179
180/* Move the cursor to a position (x,y), where (0,0) is the
181 top-left corner of the console */
182static void move_cursor(int line, int row)
183{
184 printf("\033[%u;%uH", line, row);
185}
186
187static void clear_line(void)
188{
189 printf("\033[%u;0H" CLEAR_2_EOL, max_displayed_line + 2);
190}
191
192static void print_hilite(const char *str)
193{
194 printf(HIGHLIGHT"%s"NORMAL, str);
195}
196
197static 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
204static 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 */
232static 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. */
377static 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 */
384static 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 */
407static void status_print(void)
408{
409 const char *p;
410
411 /* Change the status if flags have been set */
412#if ENABLE_FEATURE_LESS_FLAGS
413 if (option_mask32 & (FLAG_M|FLAG_m)) {
414 m_status_print();
415 return;
416 }
417 /* No flags set */
418#endif
419
420 clear_line();
421 if (cur_fline && cur_fline < max_fline - max_displayed_line) {
422 putchar(':');
423 return;
424 }
425 p = "(END)";
426 if (!cur_fline)
427 p = filename;
428 if (num_files > 1) {
429 printf(HIGHLIGHT"%s (file %i of %i)"NORMAL,
430 p, current_file, num_files);
431 return;
432 }
433 print_hilite(p);
434}
435
436static 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
453static 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 :( */
458static 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
464static 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
525void print_found(const char *line);
526#endif
527
528static 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 */
562static 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
575static 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 */
588static 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
596static 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
604static 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
618static 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 */
637static 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
655static 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. */
697static 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
732static 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 putchar(c);
759 result[i++] = c;
760 result = xrealloc(result, i+1);
761 result[i] = '\0';
762 }
763}
764
765static 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 */
783static 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
795static 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
816static 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
852static 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
861static 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
885static 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
903static 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 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
954static 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 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
1022static void flag_change(void)
1023{
1024 int keypress;
1025
1026 clear_line();
1027 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
1046static void show_flag_status(void)
1047{
1048 int keypress;
1049 int flag_val;
1050
1051 clear_line();
1052 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
1081static 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
1107static 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
1127static 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
1150static 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
1165static 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
1185static 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
1207static 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':
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
1308static void sig_catcher(int sig ATTRIBUTE_UNUSED)
1309{
1310 set_tty_cooked();
1311 exit(1);
1312}
1313
1314int less_main(int argc, char **argv);
1315int 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}
Note: See TracBrowser for help on using the repository browser.