1 /* $FreeBSD$ */
2 /*
3 * Copyright (C) 1984-2021 Mark Nudelman
4 *
5 * You may distribute under the terms of either the GNU General Public
6 * License or the Less License, as specified in the README file.
7 *
8 * For more information, see the README file.
9 */
10
11
12 /*
13 * User-level command processor.
14 */
15
16 #include "less.h"
17 #if MSDOS_COMPILER==WIN32C
18 #include <windows.h>
19 #endif
20 #include "position.h"
21 #include "option.h"
22 #include "cmd.h"
23
24 extern int erase_char, erase2_char, kill_char;
25 extern int sigs;
26 extern int quit_if_one_screen;
27 extern int squished;
28 extern int sc_width;
29 extern int sc_height;
30 extern char *kent;
31 extern int swindow;
32 extern int jump_sline;
33 extern int quitting;
34 extern int wscroll;
35 extern int top_scroll;
36 extern int ignore_eoi;
37 extern int secure;
38 extern int hshift;
39 extern int bs_mode;
40 extern int show_attn;
41 extern int less_is_more;
42 extern int status_col;
43 extern POSITION highest_hilite;
44 extern POSITION start_attnpos;
45 extern POSITION end_attnpos;
46 extern char *every_first_cmd;
47 extern char version[];
48 extern struct scrpos initial_scrpos;
49 extern IFILE curr_ifile;
50 extern void *ml_search;
51 extern void *ml_examine;
52 extern int wheel_lines;
53 #if SHELL_ESCAPE || PIPEC
54 extern void *ml_shell;
55 #endif
56 #if EDITOR
57 extern char *editor;
58 extern char *editproto;
59 #endif
60 extern int screen_trashed; /* The screen has been overwritten */
61 extern int shift_count;
62 extern int oldbot;
63 extern int forw_prompt;
64 extern int incr_search;
65 #if MSDOS_COMPILER==WIN32C
66 extern int utf_mode;
67 #endif
68
69 #if SHELL_ESCAPE
70 static char *shellcmd = NULL; /* For holding last shell command for "!!" */
71 #endif
72 static int mca; /* The multicharacter command (action) */
73 static int search_type; /* The previous type of search */
74 static LINENUM number; /* The number typed by the user */
75 static long fraction; /* The fractional part of the number */
76 static struct loption *curropt;
77 static int opt_lower;
78 static int optflag;
79 static int optgetname;
80 static POSITION bottompos;
81 static int save_hshift;
82 static int save_bs_mode;
83 #if PIPEC
84 static char pipec;
85 #endif
86
87 /* Stack of ungotten chars (via ungetcc) */
88 struct ungot {
89 struct ungot *ug_next;
90 LWCHAR ug_char;
91 };
92 static struct ungot* ungot = NULL;
93
94 static void multi_search LESSPARAMS((char *pattern, int n, int silent));
95
96 /*
97 * Move the cursor to start of prompt line before executing a command.
98 * This looks nicer if the command takes a long time before
99 * updating the screen.
100 */
101 static void
cmd_exec(VOID_PARAM)102 cmd_exec(VOID_PARAM)
103 {
104 clear_attn();
105 clear_bot();
106 flush();
107 }
108
109 /*
110 * Indicate we are reading a multi-character command.
111 */
112 static void
set_mca(action)113 set_mca(action)
114 int action;
115 {
116 mca = action;
117 clear_bot();
118 clear_cmd();
119 }
120
121 /*
122 * Indicate we are not reading a multi-character command.
123 */
124 static void
clear_mca(VOID_PARAM)125 clear_mca(VOID_PARAM)
126 {
127 if (mca == 0)
128 return;
129 mca = 0;
130 }
131
132 /*
133 * Set up the display to start a new multi-character command.
134 */
135 static void
start_mca(action,prompt,mlist,cmdflags)136 start_mca(action, prompt, mlist, cmdflags)
137 int action;
138 constant char *prompt;
139 void *mlist;
140 int cmdflags;
141 {
142 set_mca(action);
143 cmd_putstr(prompt);
144 set_mlist(mlist, cmdflags);
145 }
146
147 public int
in_mca(VOID_PARAM)148 in_mca(VOID_PARAM)
149 {
150 return (mca != 0 && mca != A_PREFIX);
151 }
152
153 /*
154 * Set up the display to start a new search command.
155 */
156 static void
mca_search(VOID_PARAM)157 mca_search(VOID_PARAM)
158 {
159 #if HILITE_SEARCH
160 if (search_type & SRCH_FILTER)
161 set_mca(A_FILTER);
162 else
163 #endif
164 if (search_type & SRCH_FORW)
165 set_mca(A_F_SEARCH);
166 else
167 set_mca(A_B_SEARCH);
168
169 if (search_type & SRCH_NO_MATCH)
170 cmd_putstr("Non-match ");
171 if (search_type & SRCH_FIRST_FILE)
172 cmd_putstr("First-file ");
173 if (search_type & SRCH_PAST_EOF)
174 cmd_putstr("EOF-ignore ");
175 if (search_type & SRCH_NO_MOVE)
176 cmd_putstr("Keep-pos ");
177 if (search_type & SRCH_NO_REGEX)
178 cmd_putstr("Regex-off ");
179 if (search_type & SRCH_WRAP)
180 cmd_putstr("Wrap ");
181
182 #if HILITE_SEARCH
183 if (search_type & SRCH_FILTER)
184 cmd_putstr("&/");
185 else
186 #endif
187 if (search_type & SRCH_FORW)
188 cmd_putstr("/");
189 else
190 cmd_putstr("?");
191 forw_prompt = 0;
192 set_mlist(ml_search, 0);
193 }
194
195 /*
196 * Set up the display to start a new toggle-option command.
197 */
198 static void
mca_opt_toggle(VOID_PARAM)199 mca_opt_toggle(VOID_PARAM)
200 {
201 int no_prompt;
202 int flag;
203 char *dash;
204
205 no_prompt = (optflag & OPT_NO_PROMPT);
206 flag = (optflag & ~OPT_NO_PROMPT);
207 dash = (flag == OPT_NO_TOGGLE) ? "_" : "-";
208
209 set_mca(A_OPT_TOGGLE);
210 cmd_putstr(dash);
211 if (optgetname)
212 cmd_putstr(dash);
213 if (no_prompt)
214 cmd_putstr("(P)");
215 switch (flag)
216 {
217 case OPT_UNSET:
218 cmd_putstr("+");
219 break;
220 case OPT_SET:
221 cmd_putstr("!");
222 break;
223 }
224 forw_prompt = 0;
225 set_mlist(NULL, 0);
226 }
227
228 /*
229 * Execute a multicharacter command.
230 */
231 static void
exec_mca(VOID_PARAM)232 exec_mca(VOID_PARAM)
233 {
234 char *cbuf;
235
236 cmd_exec();
237 cbuf = get_cmdbuf();
238
239 switch (mca)
240 {
241 case A_F_SEARCH:
242 case A_B_SEARCH:
243 multi_search(cbuf, (int) number, 0);
244 break;
245 #if HILITE_SEARCH
246 case A_FILTER:
247 search_type ^= SRCH_NO_MATCH;
248 set_filter_pattern(cbuf, search_type);
249 break;
250 #endif
251 case A_FIRSTCMD:
252 /*
253 * Skip leading spaces or + signs in the string.
254 */
255 while (*cbuf == '+' || *cbuf == ' ')
256 cbuf++;
257 if (every_first_cmd != NULL)
258 free(every_first_cmd);
259 if (*cbuf == '\0')
260 every_first_cmd = NULL;
261 else
262 every_first_cmd = save(cbuf);
263 break;
264 case A_OPT_TOGGLE:
265 toggle_option(curropt, opt_lower, cbuf, optflag);
266 curropt = NULL;
267 break;
268 case A_F_BRACKET:
269 match_brac(cbuf[0], cbuf[1], 1, (int) number);
270 break;
271 case A_B_BRACKET:
272 match_brac(cbuf[1], cbuf[0], 0, (int) number);
273 break;
274 #if EXAMINE
275 case A_EXAMINE:
276 if (secure)
277 break;
278 edit_list(cbuf);
279 #if TAGS
280 /* If tag structure is loaded then clean it up. */
281 cleantags();
282 #endif
283 break;
284 #endif
285 #if SHELL_ESCAPE
286 case A_SHELL:
287 /*
288 * !! just uses whatever is in shellcmd.
289 * Otherwise, copy cmdbuf to shellcmd,
290 * expanding any special characters ("%" or "#").
291 */
292 if (*cbuf != '!')
293 {
294 if (shellcmd != NULL)
295 free(shellcmd);
296 shellcmd = fexpand(cbuf);
297 }
298
299 if (secure)
300 break;
301 if (shellcmd == NULL)
302 lsystem("", "!done");
303 else
304 lsystem(shellcmd, "!done");
305 break;
306 #endif
307 #if PIPEC
308 case A_PIPE:
309 if (secure)
310 break;
311 (void) pipe_mark(pipec, cbuf);
312 error("|done", NULL_PARG);
313 break;
314 #endif
315 }
316 }
317
318 /*
319 * Is a character an erase or kill char?
320 */
321 static int
is_erase_char(c)322 is_erase_char(c)
323 int c;
324 {
325 return (c == erase_char || c == erase2_char || c == kill_char);
326 }
327
328 /*
329 * Is a character a carriage return or newline?
330 */
331 static int
is_newline_char(c)332 is_newline_char(c)
333 int c;
334 {
335 return (c == '\n' || c == '\r');
336 }
337
338 /*
339 * Handle the first char of an option (after the initial dash).
340 */
341 static int
mca_opt_first_char(c)342 mca_opt_first_char(c)
343 int c;
344 {
345 int flag = (optflag & ~OPT_NO_PROMPT);
346 if (flag == OPT_NO_TOGGLE)
347 {
348 switch (c)
349 {
350 case '_':
351 /* "__" = long option name. */
352 optgetname = TRUE;
353 mca_opt_toggle();
354 return (MCA_MORE);
355 }
356 } else
357 {
358 switch (c)
359 {
360 case '+':
361 /* "-+" = UNSET. */
362 optflag = (flag == OPT_UNSET) ?
363 OPT_TOGGLE : OPT_UNSET;
364 mca_opt_toggle();
365 return (MCA_MORE);
366 case '!':
367 /* "-!" = SET */
368 optflag = (flag == OPT_SET) ?
369 OPT_TOGGLE : OPT_SET;
370 mca_opt_toggle();
371 return (MCA_MORE);
372 case CONTROL('P'):
373 optflag ^= OPT_NO_PROMPT;
374 mca_opt_toggle();
375 return (MCA_MORE);
376 case '-':
377 /* "--" = long option name. */
378 optgetname = TRUE;
379 mca_opt_toggle();
380 return (MCA_MORE);
381 }
382 }
383 /* Char was not handled here. */
384 return (NO_MCA);
385 }
386
387 /*
388 * Add a char to a long option name.
389 * See if we've got a match for an option name yet.
390 * If so, display the complete name and stop
391 * accepting chars until user hits RETURN.
392 */
393 static int
mca_opt_nonfirst_char(c)394 mca_opt_nonfirst_char(c)
395 int c;
396 {
397 char *p;
398 char *oname;
399 int err;
400
401 if (curropt != NULL)
402 {
403 /*
404 * Already have a match for the name.
405 * Don't accept anything but erase/kill.
406 */
407 if (is_erase_char(c))
408 return (MCA_DONE);
409 return (MCA_MORE);
410 }
411 /*
412 * Add char to cmd buffer and try to match
413 * the option name.
414 */
415 if (cmd_char(c) == CC_QUIT)
416 return (MCA_DONE);
417 p = get_cmdbuf();
418 opt_lower = ASCII_IS_LOWER(p[0]);
419 err = 0;
420 curropt = findopt_name(&p, &oname, &err);
421 if (curropt != NULL)
422 {
423 /*
424 * Got a match.
425 * Remember the option and
426 * display the full option name.
427 */
428 cmd_reset();
429 mca_opt_toggle();
430 for (p = oname; *p != '\0'; p++)
431 {
432 c = *p;
433 if (!opt_lower && ASCII_IS_LOWER(c))
434 c = ASCII_TO_UPPER(c);
435 if (cmd_char(c) != CC_OK)
436 return (MCA_DONE);
437 }
438 } else if (err != OPT_AMBIG)
439 {
440 bell();
441 }
442 return (MCA_MORE);
443 }
444
445 /*
446 * Handle a char of an option toggle command.
447 */
448 static int
mca_opt_char(c)449 mca_opt_char(c)
450 int c;
451 {
452 PARG parg;
453
454 /*
455 * This may be a short option (single char),
456 * or one char of a long option name,
457 * or one char of the option parameter.
458 */
459 if (curropt == NULL && len_cmdbuf() == 0)
460 {
461 int ret = mca_opt_first_char(c);
462 if (ret != NO_MCA)
463 return (ret);
464 }
465 if (optgetname)
466 {
467 /* We're getting a long option name. */
468 if (!is_newline_char(c))
469 return (mca_opt_nonfirst_char(c));
470 if (curropt == NULL)
471 {
472 parg.p_string = get_cmdbuf();
473 error("There is no --%s option", &parg);
474 return (MCA_DONE);
475 }
476 optgetname = FALSE;
477 cmd_reset();
478 } else
479 {
480 if (is_erase_char(c))
481 return (NO_MCA);
482 if (curropt != NULL)
483 /* We're getting the option parameter. */
484 return (NO_MCA);
485 curropt = findopt(c);
486 if (curropt == NULL)
487 {
488 parg.p_string = propt(c);
489 error("There is no %s option", &parg);
490 return (MCA_DONE);
491 }
492 opt_lower = ASCII_IS_LOWER(c);
493 }
494 /*
495 * If the option which was entered does not take a
496 * parameter, toggle the option immediately,
497 * so user doesn't have to hit RETURN.
498 */
499 if ((optflag & ~OPT_NO_PROMPT) != OPT_TOGGLE ||
500 !opt_has_param(curropt))
501 {
502 toggle_option(curropt, opt_lower, "", optflag);
503 return (MCA_DONE);
504 }
505 /*
506 * Display a prompt appropriate for the option parameter.
507 */
508 start_mca(A_OPT_TOGGLE, opt_prompt(curropt), (void*)NULL, 0);
509 return (MCA_MORE);
510 }
511
512 /*
513 * Handle a char of a search command.
514 */
515 static int
mca_search_char(c)516 mca_search_char(c)
517 int c;
518 {
519 int flag = 0;
520
521 /*
522 * Certain characters as the first char of
523 * the pattern have special meaning:
524 * ! Toggle the NO_MATCH flag
525 * * Toggle the PAST_EOF flag
526 * @ Toggle the FIRST_FILE flag
527 */
528 if (len_cmdbuf() > 0)
529 return (NO_MCA);
530
531 switch (c)
532 {
533 case '*':
534 if (less_is_more)
535 break;
536 case CONTROL('E'): /* ignore END of file */
537 if (mca != A_FILTER)
538 flag = SRCH_PAST_EOF;
539 break;
540 case '@':
541 if (less_is_more)
542 break;
543 case CONTROL('F'): /* FIRST file */
544 if (mca != A_FILTER)
545 flag = SRCH_FIRST_FILE;
546 break;
547 case CONTROL('K'): /* KEEP position */
548 if (mca != A_FILTER)
549 flag = SRCH_NO_MOVE;
550 break;
551 case CONTROL('W'): /* WRAP around */
552 if (mca != A_FILTER)
553 flag = SRCH_WRAP;
554 break;
555 case CONTROL('R'): /* Don't use REGULAR EXPRESSIONS */
556 flag = SRCH_NO_REGEX;
557 break;
558 case CONTROL('N'): /* NOT match */
559 case '!':
560 flag = SRCH_NO_MATCH;
561 break;
562 }
563
564 if (flag != 0)
565 {
566 /* Toggle flag, but keep PAST_EOF and WRAP mutually exclusive. */
567 search_type ^= flag | (search_type & (SRCH_PAST_EOF|SRCH_WRAP));
568 mca_search();
569 return (MCA_MORE);
570 }
571 return (NO_MCA);
572 }
573
574 /*
575 * Handle a character of a multi-character command.
576 */
577 static int
mca_char(c)578 mca_char(c)
579 int c;
580 {
581 int ret;
582
583 switch (mca)
584 {
585 case 0:
586 /*
587 * We're not in a multicharacter command.
588 */
589 return (NO_MCA);
590
591 case A_PREFIX:
592 /*
593 * In the prefix of a command.
594 * This not considered a multichar command
595 * (even tho it uses cmdbuf, etc.).
596 * It is handled in the commands() switch.
597 */
598 return (NO_MCA);
599
600 case A_DIGIT:
601 /*
602 * Entering digits of a number.
603 * Terminated by a non-digit.
604 */
605 if ((c >= '0' && c <= '9') || c == '.')
606 break;
607 switch (editchar(c, ECF_PEEK|ECF_NOHISTORY|ECF_NOCOMPLETE|ECF_NORIGHTLEFT))
608 {
609 case A_NOACTION:
610 /*
611 * Ignore this char and get another one.
612 */
613 return (MCA_MORE);
614 case A_INVALID:
615 /*
616 * Not part of the number.
617 * End the number and treat this char
618 * as a normal command character.
619 */
620 number = cmd_int(&fraction);
621 clear_mca();
622 cmd_accept();
623 return (NO_MCA);
624 }
625 break;
626
627 case A_OPT_TOGGLE:
628 ret = mca_opt_char(c);
629 if (ret != NO_MCA)
630 return (ret);
631 break;
632
633 case A_F_SEARCH:
634 case A_B_SEARCH:
635 case A_FILTER:
636 ret = mca_search_char(c);
637 if (ret != NO_MCA)
638 return (ret);
639 break;
640
641 default:
642 /* Other multicharacter command. */
643 break;
644 }
645
646 /*
647 * The multichar command is terminated by a newline.
648 */
649 if (is_newline_char(c))
650 {
651 /*
652 * Execute the command.
653 */
654 exec_mca();
655 return (MCA_DONE);
656 }
657
658 /*
659 * Append the char to the command buffer.
660 */
661 if (cmd_char(c) == CC_QUIT)
662 /*
663 * Abort the multi-char command.
664 */
665 return (MCA_DONE);
666
667 switch (mca)
668 {
669 case A_F_BRACKET:
670 case A_B_BRACKET:
671 if (len_cmdbuf() >= 2)
672 {
673 /*
674 * Special case for the bracket-matching commands.
675 * Execute the command after getting exactly two
676 * characters from the user.
677 */
678 exec_mca();
679 return (MCA_DONE);
680 }
681 break;
682 case A_F_SEARCH:
683 case A_B_SEARCH:
684 if (incr_search)
685 {
686 /* Incremental search: do a search after every input char. */
687 int st = (search_type & (SRCH_FORW|SRCH_BACK|SRCH_NO_MATCH|SRCH_NO_REGEX|SRCH_NO_MOVE|SRCH_WRAP));
688 char *pattern = get_cmdbuf();
689 cmd_exec();
690 if (*pattern == '\0')
691 {
692 /* User has backspaced to an empty pattern. */
693 undo_search(1);
694 } else
695 {
696 if (search(st | SRCH_INCR, pattern, 1) != 0)
697 /* No match, invalid pattern, etc. */
698 undo_search(1);
699 }
700 /* Redraw the search prompt and search string. */
701 mca_search();
702 cmd_repaint(NULL);
703 }
704 break;
705 }
706
707 /*
708 * Need another character.
709 */
710 return (MCA_MORE);
711 }
712
713 /*
714 * Discard any buffered file data.
715 */
716 static void
clear_buffers(VOID_PARAM)717 clear_buffers(VOID_PARAM)
718 {
719 if (!(ch_getflags() & CH_CANSEEK))
720 return;
721 ch_flush();
722 clr_linenum();
723 #if HILITE_SEARCH
724 clr_hilite();
725 #endif
726 }
727
728 /*
729 * Make sure the screen is displayed.
730 */
731 static void
make_display(VOID_PARAM)732 make_display(VOID_PARAM)
733 {
734 /*
735 * If nothing is displayed yet, display starting from initial_scrpos.
736 */
737 if (empty_screen())
738 {
739 if (initial_scrpos.pos == NULL_POSITION)
740 jump_loc(ch_zero(), 1);
741 else
742 jump_loc(initial_scrpos.pos, initial_scrpos.ln);
743 } else if (screen_trashed)
744 {
745 int save_top_scroll = top_scroll;
746 int save_ignore_eoi = ignore_eoi;
747 top_scroll = 1;
748 ignore_eoi = 0;
749 if (screen_trashed == 2)
750 {
751 /* Special case used by ignore_eoi: re-open the input file
752 * and jump to the end of the file. */
753 reopen_curr_ifile();
754 jump_forw();
755 }
756 repaint();
757 top_scroll = save_top_scroll;
758 ignore_eoi = save_ignore_eoi;
759 }
760 }
761
762 /*
763 * Display the appropriate prompt.
764 */
765 static void
prompt(VOID_PARAM)766 prompt(VOID_PARAM)
767 {
768 constant char *p;
769
770 if (ungot != NULL && ungot->ug_char != CHAR_END_COMMAND)
771 {
772 /*
773 * No prompt necessary if commands are from
774 * ungotten chars rather than from the user.
775 */
776 return;
777 }
778
779 /*
780 * Make sure the screen is displayed.
781 */
782 make_display();
783 bottompos = position(BOTTOM_PLUS_ONE);
784
785 /*
786 * If we've hit EOF on the last file and the -E flag is set, quit.
787 */
788 if (get_quit_at_eof() == OPT_ONPLUS &&
789 eof_displayed() && !(ch_getflags() & CH_HELPFILE) &&
790 next_ifile(curr_ifile) == NULL_IFILE)
791 quit(QUIT_OK);
792
793 /*
794 * If the entire file is displayed and the -F flag is set, quit.
795 */
796 if (quit_if_one_screen &&
797 entire_file_displayed() && !(ch_getflags() & CH_HELPFILE) &&
798 next_ifile(curr_ifile) == NULL_IFILE)
799 quit(QUIT_OK);
800 quit_if_one_screen = FALSE; /* only get one chance at this */
801
802 #if MSDOS_COMPILER==WIN32C
803 /*
804 * In Win32, display the file name in the window title.
805 */
806 if (!(ch_getflags() & CH_HELPFILE))
807 {
808 WCHAR w[MAX_PATH+16];
809 p = pr_expand("Less?f - %f.", 0);
810 MultiByteToWideChar(CP_ACP, 0, p, -1, w, sizeof(w)/sizeof(*w));
811 SetConsoleTitleW(w);
812 }
813 #endif
814
815 /*
816 * Select the proper prompt and display it.
817 */
818 /*
819 * If the previous action was a forward movement,
820 * don't clear the bottom line of the display;
821 * just print the prompt since the forward movement guarantees
822 * that we're in the right position to display the prompt.
823 * Clearing the line could cause a problem: for example, if the last
824 * line displayed ended at the right screen edge without a newline,
825 * then clearing would clear the last displayed line rather than
826 * the prompt line.
827 */
828 if (!forw_prompt)
829 clear_bot();
830 clear_cmd();
831 forw_prompt = 0;
832 p = pr_string();
833 #if HILITE_SEARCH
834 if (is_filtering())
835 putstr("& ");
836 #endif
837 if (p == NULL || *p == '\0')
838 {
839 at_enter(AT_NORMAL|AT_COLOR_PROMPT);
840 putchr(':');
841 at_exit();
842 } else
843 {
844 #if MSDOS_COMPILER==WIN32C
845 WCHAR w[MAX_PATH*2];
846 char a[MAX_PATH*2];
847 MultiByteToWideChar(CP_ACP, 0, p, -1, w, sizeof(w)/sizeof(*w));
848 WideCharToMultiByte(utf_mode ? CP_UTF8 : GetConsoleOutputCP(),
849 0, w, -1, a, sizeof(a), NULL, NULL);
850 p = a;
851 #endif
852 at_enter(AT_STANDOUT|AT_COLOR_PROMPT);
853 putstr(p);
854 at_exit();
855 }
856 clear_eol();
857 }
858
859 /*
860 * Display the less version message.
861 */
862 public void
dispversion(VOID_PARAM)863 dispversion(VOID_PARAM)
864 {
865 PARG parg;
866
867 parg.p_string = version;
868 error("less %s", &parg);
869 }
870
871 /*
872 * Return a character to complete a partial command, if possible.
873 */
874 static LWCHAR
getcc_end_command(VOID_PARAM)875 getcc_end_command(VOID_PARAM)
876 {
877 switch (mca)
878 {
879 case A_DIGIT:
880 /* We have a number but no command. Treat as #g. */
881 return ('g');
882 case A_F_SEARCH:
883 case A_B_SEARCH:
884 /* We have "/string" but no newline. Add the \n. */
885 return ('\n');
886 default:
887 /* Some other incomplete command. Let user complete it. */
888 return ((ungot == NULL) ? getchr() : 0);
889 }
890 }
891
892 /*
893 * Get command character.
894 * The character normally comes from the keyboard,
895 * but may come from ungotten characters
896 * (characters previously given to ungetcc or ungetsc).
897 */
898 static LWCHAR
getccu(VOID_PARAM)899 getccu(VOID_PARAM)
900 {
901 LWCHAR c = 0;
902 while (c == 0)
903 {
904 if (ungot == NULL)
905 {
906 /* Normal case: no ungotten chars.
907 * Get char from the user. */
908 c = getchr();
909 } else
910 {
911 /* Ungotten chars available:
912 * Take the top of stack (most recent). */
913 struct ungot *ug = ungot;
914 c = ug->ug_char;
915 ungot = ug->ug_next;
916 free(ug);
917
918 if (c == CHAR_END_COMMAND)
919 c = getcc_end_command();
920 }
921 }
922 return (c);
923 }
924
925 /*
926 * Get a command character, but if we receive the orig sequence,
927 * convert it to the repl sequence.
928 */
929 static LWCHAR
getcc_repl(orig,repl,gr_getc,gr_ungetc)930 getcc_repl(orig, repl, gr_getc, gr_ungetc)
931 char const* orig;
932 char const* repl;
933 LWCHAR (*gr_getc)(VOID_PARAM);
934 void (*gr_ungetc)(LWCHAR);
935 {
936 LWCHAR c;
937 LWCHAR keys[16];
938 int ki = 0;
939
940 c = (*gr_getc)();
941 if (orig == NULL || orig[0] == '\0')
942 return c;
943 for (;;)
944 {
945 keys[ki] = c;
946 if (c != orig[ki] || ki >= sizeof(keys)-1)
947 {
948 /* This is not orig we have been receiving.
949 * If we have stashed chars in keys[],
950 * unget them and return the first one. */
951 while (ki > 0)
952 (*gr_ungetc)(keys[ki--]);
953 return keys[0];
954 }
955 if (orig[++ki] == '\0')
956 {
957 /* We've received the full orig sequence.
958 * Return the repl sequence. */
959 ki = strlen(repl)-1;
960 while (ki > 0)
961 (*gr_ungetc)(repl[ki--]);
962 return repl[0];
963 }
964 /* We've received a partial orig sequence (ki chars of it).
965 * Get next char and see if it continues to match orig. */
966 c = (*gr_getc)();
967 }
968 }
969
970 /*
971 * Get command character.
972 */
973 public int
getcc(VOID_PARAM)974 getcc(VOID_PARAM)
975 {
976 /* Replace kent (keypad Enter) with a newline. */
977 return getcc_repl(kent, "\n", getccu, ungetcc);
978 }
979
980 /*
981 * "Unget" a command character.
982 * The next getcc() will return this character.
983 */
984 public void
ungetcc(c)985 ungetcc(c)
986 LWCHAR c;
987 {
988 struct ungot *ug = (struct ungot *) ecalloc(1, sizeof(struct ungot));
989
990 ug->ug_char = c;
991 ug->ug_next = ungot;
992 ungot = ug;
993 }
994
995 /*
996 * "Unget" a command character.
997 * If any other chars are already ungotten, put this one after those.
998 */
999 public void
ungetcc_back(c)1000 ungetcc_back(c)
1001 LWCHAR c;
1002 {
1003 struct ungot *ug = (struct ungot *) ecalloc(1, sizeof(struct ungot));
1004 ug->ug_char = c;
1005 ug->ug_next = NULL;
1006 if (ungot == NULL)
1007 ungot = ug;
1008 else
1009 {
1010 struct ungot *pu;
1011 for (pu = ungot; pu->ug_next != NULL; pu = pu->ug_next)
1012 continue;
1013 pu->ug_next = ug;
1014 }
1015 }
1016
1017 /*
1018 * Unget a whole string of command characters.
1019 * The next sequence of getcc()'s will return this string.
1020 */
1021 public void
ungetsc(s)1022 ungetsc(s)
1023 char *s;
1024 {
1025 while (*s != '\0')
1026 ungetcc_back(*s++);
1027 }
1028
1029 /*
1030 * Peek the next command character, without consuming it.
1031 */
1032 public LWCHAR
peekcc(VOID_PARAM)1033 peekcc(VOID_PARAM)
1034 {
1035 LWCHAR c = getcc();
1036 ungetcc(c);
1037 return c;
1038 }
1039
1040 /*
1041 * Search for a pattern, possibly in multiple files.
1042 * If SRCH_FIRST_FILE is set, begin searching at the first file.
1043 * If SRCH_PAST_EOF is set, continue the search thru multiple files.
1044 */
1045 static void
multi_search(pattern,n,silent)1046 multi_search(pattern, n, silent)
1047 char *pattern;
1048 int n;
1049 int silent;
1050 {
1051 int nomore;
1052 IFILE save_ifile;
1053 int changed_file;
1054
1055 changed_file = 0;
1056 save_ifile = save_curr_ifile();
1057
1058 if (search_type & SRCH_FIRST_FILE)
1059 {
1060 /*
1061 * Start at the first (or last) file
1062 * in the command line list.
1063 */
1064 if (search_type & SRCH_FORW)
1065 nomore = edit_first();
1066 else
1067 nomore = edit_last();
1068 if (nomore)
1069 {
1070 unsave_ifile(save_ifile);
1071 return;
1072 }
1073 changed_file = 1;
1074 search_type &= ~SRCH_FIRST_FILE;
1075 }
1076
1077 for (;;)
1078 {
1079 n = search(search_type, pattern, n);
1080 /*
1081 * The SRCH_NO_MOVE flag doesn't "stick": it gets cleared
1082 * after being used once. This allows "n" to work after
1083 * using a /@@ search.
1084 */
1085 search_type &= ~SRCH_NO_MOVE;
1086 if (n == 0)
1087 {
1088 /*
1089 * Found it.
1090 */
1091 unsave_ifile(save_ifile);
1092 return;
1093 }
1094
1095 if (n < 0)
1096 /*
1097 * Some kind of error in the search.
1098 * Error message has been printed by search().
1099 */
1100 break;
1101
1102 if ((search_type & SRCH_PAST_EOF) == 0)
1103 /*
1104 * We didn't find a match, but we're
1105 * supposed to search only one file.
1106 */
1107 break;
1108 /*
1109 * Move on to the next file.
1110 */
1111 if (search_type & SRCH_FORW)
1112 nomore = edit_next(1);
1113 else
1114 nomore = edit_prev(1);
1115 if (nomore)
1116 break;
1117 changed_file = 1;
1118 }
1119
1120 /*
1121 * Didn't find it.
1122 * Print an error message if we haven't already.
1123 */
1124 if (n > 0 && !silent)
1125 error("Pattern not found", NULL_PARG);
1126
1127 if (changed_file)
1128 {
1129 /*
1130 * Restore the file we were originally viewing.
1131 */
1132 reedit_ifile(save_ifile);
1133 } else
1134 {
1135 unsave_ifile(save_ifile);
1136 }
1137 }
1138
1139 /*
1140 * Forward forever, or until a highlighted line appears.
1141 */
1142 static int
forw_loop(until_hilite)1143 forw_loop(until_hilite)
1144 int until_hilite;
1145 {
1146 POSITION curr_len;
1147
1148 if (ch_getflags() & CH_HELPFILE)
1149 return (A_NOACTION);
1150
1151 cmd_exec();
1152 jump_forw_buffered();
1153 curr_len = ch_length();
1154 highest_hilite = until_hilite ? curr_len : NULL_POSITION;
1155 ignore_eoi = 1;
1156 while (!sigs)
1157 {
1158 if (until_hilite && highest_hilite > curr_len)
1159 {
1160 bell();
1161 break;
1162 }
1163 make_display();
1164 forward(1, 0, 0);
1165 }
1166 ignore_eoi = 0;
1167 ch_set_eof();
1168
1169 /*
1170 * This gets us back in "F mode" after processing
1171 * a non-abort signal (e.g. window-change).
1172 */
1173 if (sigs && !ABORT_SIGS())
1174 return (until_hilite ? A_F_UNTIL_HILITE : A_F_FOREVER);
1175
1176 return (A_NOACTION);
1177 }
1178
1179 /*
1180 * Main command processor.
1181 * Accept and execute commands until a quit command.
1182 */
1183 public void
commands(VOID_PARAM)1184 commands(VOID_PARAM)
1185 {
1186 int c;
1187 int action;
1188 char *cbuf;
1189 int newaction;
1190 int save_jump_sline;
1191 int save_search_type;
1192 char *extra;
1193 char tbuf[2];
1194 PARG parg;
1195 IFILE old_ifile;
1196 IFILE new_ifile;
1197 char *tagfile;
1198
1199 search_type = SRCH_FORW;
1200 wscroll = (sc_height + 1) / 2;
1201 newaction = A_NOACTION;
1202
1203 for (;;)
1204 {
1205 clear_mca();
1206 cmd_accept();
1207 number = 0;
1208 curropt = NULL;
1209
1210 /*
1211 * See if any signals need processing.
1212 */
1213 if (sigs)
1214 {
1215 psignals();
1216 if (quitting)
1217 quit(QUIT_SAVED_STATUS);
1218 }
1219
1220 /*
1221 * See if window size changed, for systems that don't
1222 * generate SIGWINCH.
1223 */
1224 check_winch();
1225
1226 /*
1227 * Display prompt and accept a character.
1228 */
1229 cmd_reset();
1230 prompt();
1231 if (sigs)
1232 continue;
1233 if (newaction == A_NOACTION)
1234 c = getcc();
1235
1236 again:
1237 if (sigs)
1238 continue;
1239
1240 if (newaction != A_NOACTION)
1241 {
1242 action = newaction;
1243 newaction = A_NOACTION;
1244 } else
1245 {
1246 /*
1247 * If we are in a multicharacter command, call mca_char.
1248 * Otherwise we call fcmd_decode to determine the
1249 * action to be performed.
1250 */
1251 if (mca)
1252 switch (mca_char(c))
1253 {
1254 case MCA_MORE:
1255 /*
1256 * Need another character.
1257 */
1258 c = getcc();
1259 goto again;
1260 case MCA_DONE:
1261 /*
1262 * Command has been handled by mca_char.
1263 * Start clean with a prompt.
1264 */
1265 continue;
1266 case NO_MCA:
1267 /*
1268 * Not a multi-char command
1269 * (at least, not anymore).
1270 */
1271 break;
1272 }
1273
1274 /*
1275 * Decode the command character and decide what to do.
1276 */
1277 if (mca)
1278 {
1279 /*
1280 * We're in a multichar command.
1281 * Add the character to the command buffer
1282 * and display it on the screen.
1283 * If the user backspaces past the start
1284 * of the line, abort the command.
1285 */
1286 if (cmd_char(c) == CC_QUIT || len_cmdbuf() == 0)
1287 continue;
1288 cbuf = get_cmdbuf();
1289 } else
1290 {
1291 /*
1292 * Don't use cmd_char if we're starting fresh
1293 * at the beginning of a command, because we
1294 * don't want to echo the command until we know
1295 * it is a multichar command. We also don't
1296 * want erase_char/kill_char to be treated
1297 * as line editing characters.
1298 */
1299 tbuf[0] = c;
1300 tbuf[1] = '\0';
1301 cbuf = tbuf;
1302 }
1303 extra = NULL;
1304 action = fcmd_decode(cbuf, &extra);
1305 /*
1306 * If an "extra" string was returned,
1307 * process it as a string of command characters.
1308 */
1309 if (extra != NULL)
1310 ungetsc(extra);
1311 }
1312 /*
1313 * Clear the cmdbuf string.
1314 * (But not if we're in the prefix of a command,
1315 * because the partial command string is kept there.)
1316 */
1317 if (action != A_PREFIX)
1318 cmd_reset();
1319
1320 switch (action)
1321 {
1322 case A_DIGIT:
1323 /*
1324 * First digit of a number.
1325 */
1326 start_mca(A_DIGIT, ":", (void*)NULL, CF_QUIT_ON_ERASE);
1327 goto again;
1328
1329 case A_F_WINDOW:
1330 /*
1331 * Forward one window (and set the window size).
1332 */
1333 if (number > 0)
1334 swindow = (int) number;
1335 /* FALLTHRU */
1336 case A_F_SCREEN:
1337 /*
1338 * Forward one screen.
1339 */
1340 if (number <= 0)
1341 number = get_swindow();
1342 cmd_exec();
1343 if (show_attn)
1344 set_attnpos(bottompos);
1345 forward((int) number, 0, 1);
1346 break;
1347
1348 case A_B_WINDOW:
1349 /*
1350 * Backward one window (and set the window size).
1351 */
1352 if (number > 0)
1353 swindow = (int) number;
1354 /* FALLTHRU */
1355 case A_B_SCREEN:
1356 /*
1357 * Backward one screen.
1358 */
1359 if (number <= 0)
1360 number = get_swindow();
1361 cmd_exec();
1362 backward((int) number, 0, 1);
1363 break;
1364
1365 case A_F_LINE:
1366 /*
1367 * Forward N (default 1) line.
1368 */
1369 if (number <= 0)
1370 number = 1;
1371 cmd_exec();
1372 if (show_attn == OPT_ONPLUS && number > 1)
1373 set_attnpos(bottompos);
1374 forward((int) number, 0, 0);
1375 break;
1376
1377 case A_B_LINE:
1378 /*
1379 * Backward N (default 1) line.
1380 */
1381 if (number <= 0)
1382 number = 1;
1383 cmd_exec();
1384 backward((int) number, 0, 0);
1385 break;
1386
1387 case A_F_MOUSE:
1388 /*
1389 * Forward wheel_lines lines.
1390 */
1391 cmd_exec();
1392 forward(wheel_lines, 0, 0);
1393 break;
1394
1395 case A_B_MOUSE:
1396 /*
1397 * Backward wheel_lines lines.
1398 */
1399 cmd_exec();
1400 backward(wheel_lines, 0, 0);
1401 break;
1402
1403 case A_FF_LINE:
1404 /*
1405 * Force forward N (default 1) line.
1406 */
1407 if (number <= 0)
1408 number = 1;
1409 cmd_exec();
1410 if (show_attn == OPT_ONPLUS && number > 1)
1411 set_attnpos(bottompos);
1412 forward((int) number, 1, 0);
1413 break;
1414
1415 case A_BF_LINE:
1416 /*
1417 * Force backward N (default 1) line.
1418 */
1419 if (number <= 0)
1420 number = 1;
1421 cmd_exec();
1422 backward((int) number, 1, 0);
1423 break;
1424
1425 case A_FF_SCREEN:
1426 /*
1427 * Force forward one screen.
1428 */
1429 if (number <= 0)
1430 number = get_swindow();
1431 cmd_exec();
1432 if (show_attn == OPT_ONPLUS)
1433 set_attnpos(bottompos);
1434 forward((int) number, 1, 0);
1435 break;
1436
1437 case A_F_FOREVER:
1438 /*
1439 * Forward forever, ignoring EOF.
1440 */
1441 if (show_attn)
1442 set_attnpos(bottompos);
1443 newaction = forw_loop(0);
1444 break;
1445
1446 case A_F_UNTIL_HILITE:
1447 newaction = forw_loop(1);
1448 break;
1449
1450 case A_F_SCROLL:
1451 /*
1452 * Forward N lines
1453 * (default same as last 'd' or 'u' command).
1454 */
1455 if (number > 0)
1456 wscroll = (int) number;
1457 cmd_exec();
1458 if (show_attn == OPT_ONPLUS)
1459 set_attnpos(bottompos);
1460 forward(wscroll, 0, 0);
1461 break;
1462
1463 case A_B_SCROLL:
1464 /*
1465 * Forward N lines
1466 * (default same as last 'd' or 'u' command).
1467 */
1468 if (number > 0)
1469 wscroll = (int) number;
1470 cmd_exec();
1471 backward(wscroll, 0, 0);
1472 break;
1473
1474 case A_FREPAINT:
1475 /*
1476 * Flush buffers, then repaint screen.
1477 * Don't flush the buffers on a pipe!
1478 */
1479 clear_buffers();
1480 /* FALLTHRU */
1481 case A_REPAINT:
1482 /*
1483 * Repaint screen.
1484 */
1485 cmd_exec();
1486 repaint();
1487 break;
1488
1489 case A_GOLINE:
1490 /*
1491 * Go to line N, default beginning of file.
1492 * If N <= 0, ignore jump_sline in order to avoid
1493 * empty lines before the beginning of the file.
1494 */
1495 save_jump_sline = jump_sline;
1496 if (number <= 0)
1497 {
1498 number = 1;
1499 jump_sline = 0;
1500 }
1501 cmd_exec();
1502 jump_back(number);
1503 jump_sline = save_jump_sline;
1504 break;
1505
1506 case A_PERCENT:
1507 /*
1508 * Go to a specified percentage into the file.
1509 */
1510 if (number < 0)
1511 {
1512 number = 0;
1513 fraction = 0;
1514 }
1515 if (number > 100 || (number == 100 && fraction != 0))
1516 {
1517 number = 100;
1518 fraction = 0;
1519 }
1520 cmd_exec();
1521 jump_percent((int) number, fraction);
1522 break;
1523
1524 case A_GOEND:
1525 /*
1526 * Go to line N, default end of file.
1527 */
1528 cmd_exec();
1529 if (number <= 0)
1530 jump_forw();
1531 else
1532 jump_back(number);
1533 break;
1534
1535 case A_GOEND_BUF:
1536 /*
1537 * Go to line N, default last buffered byte.
1538 */
1539 cmd_exec();
1540 if (number <= 0)
1541 jump_forw_buffered();
1542 else
1543 jump_back(number);
1544 break;
1545
1546 case A_GOPOS:
1547 /*
1548 * Go to a specified byte position in the file.
1549 */
1550 cmd_exec();
1551 if (number < 0)
1552 number = 0;
1553 jump_line_loc((POSITION) number, jump_sline);
1554 break;
1555
1556 case A_STAT:
1557 /*
1558 * Print file name, etc.
1559 */
1560 if (ch_getflags() & CH_HELPFILE)
1561 break;
1562 cmd_exec();
1563 parg.p_string = eq_message();
1564 error("%s", &parg);
1565 break;
1566
1567 case A_VERSION:
1568 /*
1569 * Print version number.
1570 */
1571 cmd_exec();
1572 dispversion();
1573 break;
1574
1575 case A_QUIT:
1576 /*
1577 * Exit.
1578 */
1579 if (curr_ifile != NULL_IFILE &&
1580 ch_getflags() & CH_HELPFILE)
1581 {
1582 /*
1583 * Quit while viewing the help file
1584 * just means return to viewing the
1585 * previous file.
1586 */
1587 hshift = save_hshift;
1588 bs_mode = save_bs_mode;
1589 if (edit_prev(1) == 0)
1590 break;
1591 }
1592 if (extra != NULL)
1593 quit(*extra);
1594 quit(QUIT_OK);
1595 break;
1596
1597 /*
1598 * Define abbreviation for a commonly used sequence below.
1599 */
1600 #define DO_SEARCH() \
1601 if (number <= 0) number = 1; \
1602 mca_search(); \
1603 cmd_exec(); \
1604 multi_search((char *)NULL, (int) number, 0);
1605
1606
1607 case A_F_SEARCH:
1608 /*
1609 * Search forward for a pattern.
1610 * Get the first char of the pattern.
1611 */
1612 search_type = SRCH_FORW;
1613 if (number <= 0)
1614 number = 1;
1615 mca_search();
1616 c = getcc();
1617 goto again;
1618
1619 case A_B_SEARCH:
1620 /*
1621 * Search backward for a pattern.
1622 * Get the first char of the pattern.
1623 */
1624 search_type = SRCH_BACK;
1625 if (number <= 0)
1626 number = 1;
1627 mca_search();
1628 c = getcc();
1629 goto again;
1630
1631 case A_FILTER:
1632 #if HILITE_SEARCH
1633 search_type = SRCH_FORW | SRCH_FILTER;
1634 mca_search();
1635 c = getcc();
1636 goto again;
1637 #else
1638 error("Command not available", NULL_PARG);
1639 break;
1640 #endif
1641
1642 case A_AGAIN_SEARCH:
1643 /*
1644 * Repeat previous search.
1645 */
1646 DO_SEARCH();
1647 break;
1648
1649 case A_T_AGAIN_SEARCH:
1650 /*
1651 * Repeat previous search, multiple files.
1652 */
1653 search_type |= SRCH_PAST_EOF;
1654 DO_SEARCH();
1655 break;
1656
1657 case A_REVERSE_SEARCH:
1658 /*
1659 * Repeat previous search, in reverse direction.
1660 */
1661 save_search_type = search_type;
1662 search_type = SRCH_REVERSE(search_type);
1663 DO_SEARCH();
1664 search_type = save_search_type;
1665 break;
1666
1667 case A_T_REVERSE_SEARCH:
1668 /*
1669 * Repeat previous search,
1670 * multiple files in reverse direction.
1671 */
1672 save_search_type = search_type;
1673 search_type = SRCH_REVERSE(search_type);
1674 search_type |= SRCH_PAST_EOF;
1675 DO_SEARCH();
1676 search_type = save_search_type;
1677 break;
1678
1679 case A_UNDO_SEARCH:
1680 case A_CLR_SEARCH:
1681 /*
1682 * Clear search string highlighting.
1683 */
1684 undo_search(action == A_CLR_SEARCH);
1685 break;
1686
1687 case A_HELP:
1688 /*
1689 * Help.
1690 */
1691 if (ch_getflags() & CH_HELPFILE)
1692 break;
1693 cmd_exec();
1694 save_hshift = hshift;
1695 hshift = 0;
1696 save_bs_mode = bs_mode;
1697 bs_mode = BS_SPECIAL;
1698 (void) edit(FAKE_HELPFILE);
1699 break;
1700
1701 case A_EXAMINE:
1702 /*
1703 * Edit a new file. Get the filename.
1704 */
1705 #if EXAMINE
1706 if (!secure)
1707 {
1708 start_mca(A_EXAMINE, "Examine: ", ml_examine, 0);
1709 c = getcc();
1710 goto again;
1711 }
1712 #endif
1713 error("Command not available", NULL_PARG);
1714 break;
1715
1716 case A_VISUAL:
1717 /*
1718 * Invoke an editor on the input file.
1719 */
1720 #if EDITOR
1721 if (!secure)
1722 {
1723 if (ch_getflags() & CH_HELPFILE)
1724 break;
1725 if (strcmp(get_filename(curr_ifile), "-") == 0)
1726 {
1727 error("Cannot edit standard input", NULL_PARG);
1728 break;
1729 }
1730 if (get_altfilename(curr_ifile) != NULL)
1731 {
1732 error("WARNING: This file was viewed via LESSOPEN",
1733 NULL_PARG);
1734 }
1735 start_mca(A_SHELL, "!", ml_shell, 0);
1736 /*
1737 * Expand the editor prototype string
1738 * and pass it to the system to execute.
1739 * (Make sure the screen is displayed so the
1740 * expansion of "+%lm" works.)
1741 */
1742 make_display();
1743 cmd_exec();
1744 lsystem(pr_expand(editproto, 0), (char*)NULL);
1745 break;
1746 }
1747 #endif
1748 error("Command not available", NULL_PARG);
1749 break;
1750
1751 case A_NEXT_FILE:
1752 /*
1753 * Examine next file.
1754 */
1755 #if TAGS
1756 if (ntags())
1757 {
1758 error("No next file", NULL_PARG);
1759 break;
1760 }
1761 #endif
1762 if (number <= 0)
1763 number = 1;
1764 if (edit_next((int) number))
1765 {
1766 if (get_quit_at_eof() && eof_displayed() &&
1767 !(ch_getflags() & CH_HELPFILE))
1768 quit(QUIT_OK);
1769 parg.p_string = (number > 1) ? "(N-th) " : "";
1770 error("No %snext file", &parg);
1771 }
1772 break;
1773
1774 case A_PREV_FILE:
1775 /*
1776 * Examine previous file.
1777 */
1778 #if TAGS
1779 if (ntags())
1780 {
1781 error("No previous file", NULL_PARG);
1782 break;
1783 }
1784 #endif
1785 if (number <= 0)
1786 number = 1;
1787 if (edit_prev((int) number))
1788 {
1789 parg.p_string = (number > 1) ? "(N-th) " : "";
1790 error("No %sprevious file", &parg);
1791 }
1792 break;
1793
1794 case A_NEXT_TAG:
1795 /*
1796 * Jump to the next tag in the current tag list.
1797 */
1798 #if TAGS
1799 if (number <= 0)
1800 number = 1;
1801 tagfile = nexttag((int) number);
1802 if (tagfile == NULL)
1803 {
1804 error("No next tag", NULL_PARG);
1805 break;
1806 }
1807 cmd_exec();
1808 if (edit(tagfile) == 0)
1809 {
1810 POSITION pos = tagsearch();
1811 if (pos != NULL_POSITION)
1812 jump_loc(pos, jump_sline);
1813 }
1814 #else
1815 error("Command not available", NULL_PARG);
1816 #endif
1817 break;
1818
1819 case A_PREV_TAG:
1820 /*
1821 * Jump to the previous tag in the current tag list.
1822 */
1823 #if TAGS
1824 if (number <= 0)
1825 number = 1;
1826 tagfile = prevtag((int) number);
1827 if (tagfile == NULL)
1828 {
1829 error("No previous tag", NULL_PARG);
1830 break;
1831 }
1832 cmd_exec();
1833 if (edit(tagfile) == 0)
1834 {
1835 POSITION pos = tagsearch();
1836 if (pos != NULL_POSITION)
1837 jump_loc(pos, jump_sline);
1838 }
1839 #else
1840 error("Command not available", NULL_PARG);
1841 #endif
1842 break;
1843
1844 case A_INDEX_FILE:
1845 /*
1846 * Examine a particular file.
1847 */
1848 if (number <= 0)
1849 number = 1;
1850 if (edit_index((int) number))
1851 error("No such file", NULL_PARG);
1852 break;
1853
1854 case A_REMOVE_FILE:
1855 /*
1856 * Remove a file from the input file list.
1857 */
1858 if (ch_getflags() & CH_HELPFILE)
1859 break;
1860 old_ifile = curr_ifile;
1861 new_ifile = getoff_ifile(curr_ifile);
1862 if (new_ifile == NULL_IFILE)
1863 {
1864 bell();
1865 break;
1866 }
1867 if (edit_ifile(new_ifile) != 0)
1868 {
1869 reedit_ifile(old_ifile);
1870 break;
1871 }
1872 del_ifile(old_ifile);
1873 break;
1874
1875 case A_OPT_TOGGLE:
1876 /*
1877 * Change the setting of an option.
1878 */
1879 optflag = OPT_TOGGLE;
1880 optgetname = FALSE;
1881 mca_opt_toggle();
1882 c = getcc();
1883 cbuf = opt_toggle_disallowed(c);
1884 if (cbuf != NULL)
1885 {
1886 error(cbuf, NULL_PARG);
1887 break;
1888 }
1889 goto again;
1890
1891 case A_DISP_OPTION:
1892 /*
1893 * Report the setting of an option.
1894 */
1895 optflag = OPT_NO_TOGGLE;
1896 optgetname = FALSE;
1897 mca_opt_toggle();
1898 c = getcc();
1899 goto again;
1900
1901 case A_FIRSTCMD:
1902 /*
1903 * Set an initial command for new files.
1904 */
1905 start_mca(A_FIRSTCMD, "+", (void*)NULL, 0);
1906 c = getcc();
1907 goto again;
1908
1909 case A_SHELL:
1910 /*
1911 * Shell escape.
1912 */
1913 #if SHELL_ESCAPE
1914 if (!secure)
1915 {
1916 start_mca(A_SHELL, "!", ml_shell, 0);
1917 c = getcc();
1918 goto again;
1919 }
1920 #endif
1921 error("Command not available", NULL_PARG);
1922 break;
1923
1924 case A_SETMARK:
1925 case A_SETMARKBOT:
1926 /*
1927 * Set a mark.
1928 */
1929 if (ch_getflags() & CH_HELPFILE)
1930 break;
1931 start_mca(A_SETMARK, "set mark: ", (void*)NULL, 0);
1932 c = getcc();
1933 if (is_erase_char(c) || is_newline_char(c))
1934 break;
1935 setmark(c, action == A_SETMARKBOT ? BOTTOM : TOP);
1936 repaint();
1937 break;
1938
1939 case A_CLRMARK:
1940 /*
1941 * Clear a mark.
1942 */
1943 start_mca(A_CLRMARK, "clear mark: ", (void*)NULL, 0);
1944 c = getcc();
1945 if (is_erase_char(c) || is_newline_char(c))
1946 break;
1947 clrmark(c);
1948 repaint();
1949 break;
1950
1951 case A_GOMARK:
1952 /*
1953 * Jump to a marked position.
1954 */
1955 start_mca(A_GOMARK, "goto mark: ", (void*)NULL, 0);
1956 c = getcc();
1957 if (is_erase_char(c) || is_newline_char(c))
1958 break;
1959 cmd_exec();
1960 gomark(c);
1961 break;
1962
1963 case A_PIPE:
1964 /*
1965 * Write part of the input to a pipe to a shell command.
1966 */
1967 #if PIPEC
1968 if (!secure)
1969 {
1970 start_mca(A_PIPE, "|mark: ", (void*)NULL, 0);
1971 c = getcc();
1972 if (is_erase_char(c))
1973 break;
1974 if (is_newline_char(c))
1975 c = '.';
1976 if (badmark(c))
1977 break;
1978 pipec = c;
1979 start_mca(A_PIPE, "!", ml_shell, 0);
1980 c = getcc();
1981 goto again;
1982 }
1983 #endif
1984 error("Command not available", NULL_PARG);
1985 break;
1986
1987 case A_B_BRACKET:
1988 case A_F_BRACKET:
1989 start_mca(action, "Brackets: ", (void*)NULL, 0);
1990 c = getcc();
1991 goto again;
1992
1993 case A_LSHIFT:
1994 /*
1995 * Shift view left.
1996 */
1997 if (number > 0)
1998 shift_count = number;
1999 else
2000 number = (shift_count > 0) ?
2001 shift_count : sc_width / 2;
2002 if (number > hshift)
2003 number = hshift;
2004 hshift -= number;
2005 screen_trashed = 1;
2006 break;
2007
2008 case A_RSHIFT:
2009 /*
2010 * Shift view right.
2011 */
2012 if (number > 0)
2013 shift_count = number;
2014 else
2015 number = (shift_count > 0) ?
2016 shift_count : sc_width / 2;
2017 hshift += number;
2018 screen_trashed = 1;
2019 break;
2020
2021 case A_LLSHIFT:
2022 /*
2023 * Shift view left to margin.
2024 */
2025 hshift = 0;
2026 screen_trashed = 1;
2027 break;
2028
2029 case A_RRSHIFT:
2030 /*
2031 * Shift view right to view rightmost char on screen.
2032 */
2033 hshift = rrshift();
2034 screen_trashed = 1;
2035 break;
2036
2037 case A_PREFIX:
2038 /*
2039 * The command is incomplete (more chars are needed).
2040 * Display the current char, so the user knows
2041 * what's going on, and get another character.
2042 */
2043 if (mca != A_PREFIX)
2044 {
2045 cmd_reset();
2046 start_mca(A_PREFIX, " ", (void*)NULL,
2047 CF_QUIT_ON_ERASE);
2048 (void) cmd_char(c);
2049 }
2050 c = getcc();
2051 goto again;
2052
2053 case A_NOACTION:
2054 break;
2055
2056 default:
2057 bell();
2058 break;
2059 }
2060 }
2061 }
2062