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