Added -clobber switch to mhstore(1) [Bug #11160].
[mmh] / docs / historical / mh-6.8.5 / miscellany / less-177 / command.c
1 /*
2  * User-level command processor.
3  */
4
5 #include "less.h"
6 #include "position.h"
7 #include "option.h"
8 #include "cmd.h"
9
10 #define NO_MCA          0
11 #define MCA_DONE        1
12 #define MCA_MORE        2
13
14 extern int erase_char, kill_char;
15 extern int ispipe;
16 extern int sigs;
17 extern int quit_at_eof;
18 extern int hit_eof;
19 extern int sc_width;
20 extern int sc_height;
21 extern int swindow;
22 extern int jump_sline;
23 extern int quitting;
24 extern int scroll;
25 extern int nohelp;
26 extern int ignore_eoi;
27 extern char *every_first_cmd;
28 extern char version[];
29 extern struct scrpos initial_scrpos;
30 extern IFILE curr_ifile;
31 #if EDITOR
32 extern char *editor;
33 extern char *editproto;
34 #endif
35 extern int screen_trashed;      /* The screen has been overwritten */
36
37 static char ungot[100];
38 static char *ungotp = NULL;
39 #if SHELL_ESCAPE
40 static char *shellcmd = NULL;   /* For holding last shell command for "!!" */
41 #endif
42 static int mca;                 /* The multicharacter command (action) */
43 static int search_type;         /* The previous type of search */
44 static int number;              /* The number typed by the user */
45 static char optchar;
46 static int optflag;
47 #if PIPEC
48 static char pipec;
49 #endif
50
51 static void multi_search();
52
53 /*
54  * Move the cursor to lower left before executing a command.
55  * This looks nicer if the command takes a long time before
56  * updating the screen.
57  */
58         static void
59 cmd_exec()
60 {
61         lower_left();
62         flush();
63 }
64
65 /*
66  * Set up the display to start a new multi-character command.
67  */
68         static void
69 start_mca(action, prompt)
70         int action;
71         char *prompt;
72 {
73         mca = action;
74         lower_left();
75         clear_eol();
76         cmd_putstr(prompt);
77 }
78
79 /*
80  * Set up the display to start a new search command.
81  */
82         static void
83 mca_search()
84 {
85         switch (SRCH_DIR(search_type))
86         {
87         case SRCH_FORW:
88                 mca = A_F_SEARCH;
89                 break;
90         case SRCH_BACK:
91                 mca = A_B_SEARCH;
92                 break;
93         }
94
95         lower_left();
96         clear_eol();
97
98         if (search_type & SRCH_FIRST_FILE)
99                 cmd_putstr("@");
100
101         if (search_type & SRCH_PAST_EOF)
102                 cmd_putstr("*");
103
104         if (search_type & SRCH_NOMATCH)
105                 cmd_putstr("!");
106
107         switch (SRCH_DIR(search_type))
108         {
109         case SRCH_FORW:
110                 cmd_putstr("/");
111                 break;
112         case SRCH_BACK:
113                 cmd_putstr("?");
114                 break;
115         }
116 }
117
118 /*
119  * Execute a multicharacter command.
120  */
121         static void
122 exec_mca()
123 {
124         register char *cbuf;
125         register char *s;
126
127         cmd_exec();
128         cbuf = get_cmdbuf();
129
130         switch (mca)
131         {
132         case A_F_SEARCH:
133         case A_B_SEARCH:
134                 multi_search(cbuf, number);
135                 break;
136         case A_FIRSTCMD:
137                 /*
138                  * Skip leading spaces or + signs in the string.
139                  */
140                 while (*cbuf == '+' || *cbuf == ' ')
141                         cbuf++;
142                 if (every_first_cmd != NULL)
143                         free(every_first_cmd);
144                 if (*cbuf == '\0')
145                         every_first_cmd = NULL;
146                 else
147                         every_first_cmd = save(cbuf);
148                 break;
149         case A_OPT_TOGGLE:
150                 toggle_option(optchar, cbuf, optflag);
151                 optchar = '\0';
152                 break;
153         case A_F_BRACKET:
154                 match_brac(cbuf[0], cbuf[1], 1, number);
155                 break;
156         case A_B_BRACKET:
157                 match_brac(cbuf[1], cbuf[0], 0, number);
158                 break;
159         case A_EXAMINE:
160                 /*
161                  * Ignore leading spaces and glob the filename.
162                  */
163                 cbuf = skipsp(cbuf);
164                 s = glob(cbuf);
165                 if (s != NULL)
166                 {
167                         edit_list(s);
168                         free(s);
169                 } else
170                         edit_list(cbuf);
171                 break;
172 #if SHELL_ESCAPE
173         case A_SHELL:
174                 /*
175                  * !! just uses whatever is in shellcmd.
176                  * Otherwise, copy cmdbuf to shellcmd,
177                  * expanding any special characters ("%" or "#").
178                  */
179                 if (*cbuf != '!')
180                 {
181                         if (shellcmd != NULL)
182                                 free(shellcmd);
183                         shellcmd = fexpand(cbuf);
184                         if (shellcmd == NULL)
185                                 break;
186                 }
187
188                 if (shellcmd == NULL)
189                         lsystem("");
190                 else
191                         lsystem(shellcmd);
192                 error("!done", NULL_PARG);
193                 break;
194 #endif
195 #if PIPEC
196         case A_PIPE:
197                 (void) pipe_mark(pipec, cbuf);
198                 error("|done", NULL_PARG);
199                 break;
200 #endif
201         }
202 }
203
204 /*
205  * Add a character to a multi-character command.
206  */
207         static int
208 mca_char(c)
209         int c;
210 {
211         char *p;
212         int flag;
213         char buf[3];
214
215         switch (mca)
216         {
217         case 0:
218                 /*
219                  * Not in a multicharacter command.
220                  */
221                 return (NO_MCA);
222
223         case A_PREFIX:
224                 /*
225                  * In the prefix of a command.
226                  * This not considered a multichar command
227                  * (even tho it uses cmdbuf, etc.).
228                  * It is handled in the commands() switch.
229                  */
230                 return (NO_MCA);
231
232         case A_DIGIT:
233                 /*
234                  * Entering digits of a number.
235                  * Terminated by a non-digit.
236                  */
237                 if ((c < '0' || c > '9') &&
238                         c != erase_char && c != kill_char)
239                 {
240                         /*
241                          * Not part of the number.
242                          * Treat as a normal command character.
243                          */
244                         number = cmd_int();
245                         mca = 0;
246                         return (NO_MCA);
247                 }
248                 break;
249
250         case A_OPT_TOGGLE:
251                 /*
252                  * Special case for the TOGGLE_OPTION command.
253                  * If the option letter which was entered is a
254                  * single-char option, execute the command immediately,
255                  * so user doesn't have to hit RETURN.
256                  * If the first char is + or -, this indicates
257                  * OPT_UNSET or OPT_SET respectively, instead of OPT_TOGGLE.
258                  */
259                 if (c == erase_char || c == kill_char)
260                         break;
261                 if (optchar != '\0' && optchar != '+' && optchar != '-')
262                         /*
263                          * We already have the option letter.
264                          */
265                         break;
266                 switch (c)
267                 {
268                 case '+':
269                         optflag = OPT_UNSET;
270                         break;
271                 case '-':
272                         optflag = OPT_SET;
273                         break;
274                 default:
275                         optchar = c;
276                         if (optflag != OPT_TOGGLE || single_char_option(c))
277                         {
278                                 toggle_option(c, "", optflag);
279                                 return (MCA_DONE);
280                         }
281                         break;
282                 }
283                 if (optchar == '+' || optchar == '-')
284                 {
285                         optchar = c;
286                         break;
287                 }
288                 /*
289                  * Display a prompt appropriate for the option letter.
290                  */
291                 if ((p = opt_prompt(c)) == NULL)
292                 {
293                         buf[0] = '-';
294                         buf[1] = c;
295                         buf[2] = '\0';
296                         p = buf;
297                 }
298                 start_mca(A_OPT_TOGGLE, p);
299                 return (MCA_MORE);
300
301         case A_F_SEARCH:
302         case A_B_SEARCH:
303                 /*
304                  * Special case for search commands.
305                  * Certain characters as the first char of 
306                  * the pattern have special meaning:
307                  *      !  Toggle the NOMATCH flag
308                  *      *  Toggle the PAST_EOF flag
309                  *      @  Toggle the FIRST_FILE flag
310                  */
311                 if (len_cmdbuf() > 0)
312                         /*
313                          * Only works for the first char of the pattern.
314                          */
315                         break;
316
317                 flag = 0;
318                 switch (c)
319                 {
320                 case '!':
321                         flag = SRCH_NOMATCH;
322                         break;
323                 case '@':
324                         flag = SRCH_FIRST_FILE;
325                         break;
326                 case '*':
327                         flag = SRCH_PAST_EOF;
328                         break;
329                 }
330                 if (flag != 0)
331                 {
332                         search_type ^= flag;
333                         mca_search();
334                         return (MCA_MORE);
335                 }
336                 break;
337         }
338
339         /*
340          * Any other multicharacter command
341          * is terminated by a newline.
342          */
343         if (c == '\n' || c == '\r')
344         {
345                 /*
346                  * Execute the command.
347                  */
348                 exec_mca();
349                 return (MCA_DONE);
350         }
351         /*
352          * Append the char to the command buffer.
353          */
354         if (cmd_char(c))
355                 /*
356                  * Abort the multi-char command.
357                  */
358                 return (MCA_DONE);
359
360         if ((mca == A_F_BRACKET || mca == A_B_BRACKET) && len_cmdbuf() >= 2)
361         {
362                 /*
363                  * Special case for the bracket-matching commands.
364                  * Execute the command after getting exactly two
365                  * characters from the user.
366                  */
367                 exec_mca();
368                 return (MCA_DONE);
369         }
370
371         /*
372          * Need another character.
373          */
374         return (MCA_MORE);
375 }
376
377 /*
378  * Display the appropriate prompt.
379  */
380         static void
381 prompt()
382 {
383         register char *p;
384
385         if (ungotp != NULL && ungotp > ungot)
386         {
387                 /*
388                  * No prompt necessary if commands are from 
389                  * ungotten chars rather than from the user.
390                  */
391                 return;
392         }
393
394         /*
395          * If nothing is displayed yet, display starting from initial_scrpos.
396          */
397         if (empty_screen())
398         {
399                 if (initial_scrpos.pos == NULL_POSITION)
400                         /*
401                          * {{ Maybe this should be:
402                          *    jump_loc(ch_zero(), jump_sline);
403                          *    but this behavior seems rather unexpected 
404                          *    on the first screen. }}
405                          */
406                         jump_loc(ch_zero(), 1);
407                 else
408                         jump_loc(initial_scrpos.pos, initial_scrpos.ln);
409         } else if (screen_trashed)
410                 repaint();
411
412         /*
413          * If the -E flag is set and we've hit EOF on the last file, quit.
414          */
415         if (quit_at_eof == 2 && hit_eof && 
416             next_ifile(curr_ifile) == NULL_IFILE)
417                 quit(0);
418
419         /*
420          * Select the proper prompt and display it.
421          */
422         lower_left();
423         clear_eol();
424         p = pr_string();
425         if (p == NULL)
426                 putchr(':');
427         else
428         {
429                 so_enter();
430                 putstr(p);
431                 so_exit();
432         }
433 #if __MSDOS__
434         scroll_bar();
435 #endif
436 }
437
438 /*
439  * Get command character.
440  * The character normally comes from the keyboard,
441  * but may come from ungotten characters
442  * (characters previously given to ungetcc or ungetsc).
443  */
444         static int
445 getcc()
446 {
447         if (ungotp == NULL)
448                 /*
449                  * Normal case: no ungotten chars, so get one from the user.
450                  */
451                 return (getchr());
452
453         if (ungotp > ungot)
454                 /*
455                  * Return the next ungotten char.
456                  */
457                 return (*--ungotp);
458
459         /*
460          * We have just run out of ungotten chars.
461          */
462         ungotp = NULL;
463         if (len_cmdbuf() == 0 || !empty_screen())
464                 return (getchr());
465         /*
466          * Command is incomplete, so try to complete it.
467          */
468         switch (mca)
469         {
470         case A_DIGIT:
471                 /*
472                  * We have a number but no command.  Treat as #g.
473                  */
474                 return ('g');
475
476         case A_F_SEARCH:
477         case A_B_SEARCH:
478                 /*
479                  * We have "/string" but no newline.  Add the \n.
480                  */
481                 return ('\n'); 
482
483         default:
484                 /*
485                  * Some other incomplete command.  Let user complete it.
486                  */
487                 return (getchr());
488         }
489 }
490
491 /*
492  * "Unget" a command character.
493  * The next getcc() will return this character.
494  */
495         public void
496 ungetcc(c)
497         int c;
498 {
499         if (ungotp == NULL)
500                 ungotp = ungot;
501         if (ungotp >= ungot + sizeof(ungot))
502         {
503                 error("ungetcc overflow", NULL_PARG);
504                 quit(1);
505         }
506         *ungotp++ = c;
507 }
508
509 /*
510  * Unget a whole string of command characters.
511  * The next sequence of getcc()'s will return this string.
512  */
513         public void
514 ungetsc(s)
515         char *s;
516 {
517         register char *p;
518
519         for (p = s + strlen(s) - 1;  p >= s;  p--)
520                 ungetcc(*p);
521 }
522
523 /*
524  * Search for a pattern, possibly in multiple files.
525  * If SRCH_FIRST_FILE is set, begin searching at the first file.
526  * If SRCH_PAST_EOF is set, continue the search thru multiple files.
527  */
528         static void
529 multi_search(pattern, n)
530         char *pattern;
531         int n;
532 {
533         register int nomore;
534         char *curr_filename;
535         int changed_file;
536
537         changed_file = 0;
538         curr_filename = get_filename(curr_ifile);
539
540         if (search_type & SRCH_FIRST_FILE)
541         {
542                 /*
543                  * Start at the first (or last) file 
544                  * in the command line list.
545                  */
546                 if (SRCH_DIR(search_type) == SRCH_FORW)
547                         nomore = edit_first();
548                 else
549                         nomore = edit_last();
550                 if (nomore)
551                         return;
552                 changed_file = 1;
553                 search_type &= ~SRCH_FIRST_FILE;
554         }
555
556         for (;;)
557         {
558                 if ((n = search(search_type, pattern, n)) == 0)
559                         /*
560                          * Found it.
561                          */
562                         return;
563
564                 if (n < 0)
565                         /*
566                          * Some kind of error in the search.
567                          * Error message has been printed by search().
568                          */
569                         break;
570
571                 if ((search_type & SRCH_PAST_EOF) == 0)
572                         /*
573                          * We didn't find a match, but we're
574                          * supposed to search only one file.
575                          */
576                         break;
577                 /*
578                  * Move on to the next file.
579                  */
580                 if (SRCH_DIR(search_type) == SRCH_BACK)
581                         nomore = edit_prev(1);
582                 else
583                         nomore = edit_next(1);
584                 if (nomore)
585                         break;
586                 changed_file = 1;
587         }
588
589         /*
590          * Didn't find it.
591          * Print an error message if we haven't already.
592          */
593         if (n > 0)
594                 error("Pattern not found", NULL_PARG);
595
596         if (changed_file)
597                 /*
598                  * Restore the file we were originally viewing.
599                  */
600                 (void) edit(curr_filename, 0);
601 }
602
603 /*
604  * Main command processor.
605  * Accept and execute commands until a quit command.
606  */
607         public void
608 commands()
609 {
610         register int c;
611         register int action;
612         register char *cbuf;
613         int save_search_type;
614         char *s;
615         char tbuf[2];
616         PARG parg;
617
618         search_type = SRCH_FORW;
619         scroll = (sc_height + 1) / 2;
620
621         for (;;)
622         {
623                 mca = 0;
624                 number = 0;
625                 optchar = '\0';
626
627                 /*
628                  * See if any signals need processing.
629                  */
630                 if (sigs)
631                 {
632                         psignals();
633                         if (quitting)
634                                 quit(-1);
635                 }
636                         
637                 /*
638                  * Display prompt and accept a character.
639                  */
640                 cmd_reset();
641                 prompt();
642                 if (sigs)
643                         continue;
644                 c = getcc();
645
646         again:
647                 if (sigs)
648                         continue;
649
650                 /*
651                  * If we are in a multicharacter command, call mca_char.
652                  * Otherwise we call cmd_decode to determine the
653                  * action to be performed.
654                  */
655                 if (mca)
656                         switch (mca_char(c))
657                         {
658                         case MCA_MORE:
659                                 /*
660                                  * Need another character.
661                                  */
662                                 c = getcc();
663                                 goto again;
664                         case MCA_DONE:
665                                 /*
666                                  * Command has been handled by mca_char.
667                                  * Start clean with a prompt.
668                                  */
669                                 continue;
670                         case NO_MCA:
671                                 /*
672                                  * Not a multi-char command
673                                  * (at least, not anymore).
674                                  */
675                                 break;
676                         }
677
678                 /*
679                  * Decode the command character and decide what to do.
680                  */
681                 if (mca)
682                 {
683                         /*
684                          * We're in a multichar command.
685                          * Add the character to the command buffer
686                          * and display it on the screen.
687                          * If the user backspaces past the start 
688                          * of the line, abort the command.
689                          */
690                         if (cmd_char(c) || len_cmdbuf() == 0)
691                                 continue;
692                         cbuf = get_cmdbuf();
693                 } else
694                 {
695                         /*
696                          * Don't use cmd_char if we're starting fresh
697                          * at the beginning of a command, because we
698                          * don't want to echo the command until we know
699                          * it is a multichar command.  We also don't
700                          * want erase_char/kill_char to be treated
701                          * as line editing characters.
702                          */
703                         tbuf[0] = c;
704                         tbuf[1] = '\0';
705                         cbuf = tbuf;
706                 }
707                 s = NULL;
708                 action = cmd_decode(cbuf, &s);
709                 /*
710                  * If an "extra" string was returned,
711                  * process it as a string of command characters.
712                  */
713                 if (s != NULL)
714                         ungetsc(s);
715                 /*
716                  * Clear the cmdbuf string.
717                  * (But not if we're in the prefix of a command,
718                  * because the partial command string is kept there.)
719                  */
720                 if (action != A_PREFIX)
721                         cmd_reset();
722
723                 switch (action)
724                 {
725                 case A_DIGIT:
726                         /*
727                          * First digit of a number.
728                          */
729                         start_mca(A_DIGIT, ":");
730                         goto again;
731
732                 case A_F_WINDOW:
733                         /*
734                          * Forward one window (and set the window size).
735                          */
736                         if (number > 0)
737                                 swindow = number;
738                         /* FALLTHRU */
739                 case A_F_SCREEN:
740                         /*
741                          * Forward one screen.
742                          */
743                         if (number <= 0)
744                                 number = swindow;
745                         cmd_exec();
746                         forward(number, 0, 1);
747                         break;
748
749                 case A_B_WINDOW:
750                         /*
751                          * Backward one window (and set the window size).
752                          */
753                         if (number > 0)
754                                 swindow = number;
755                         /* FALLTHRU */
756                 case A_B_SCREEN:
757                         /*
758                          * Backward one screen.
759                          */
760                         if (number <= 0)
761                                 number = swindow;
762                         cmd_exec();
763                         backward(number, 0, 1);
764                         break;
765
766                 case A_F_LINE:
767                         /*
768                          * Forward N (default 1) line.
769                          */
770                         if (number <= 0)
771                                 number = 1;
772                         cmd_exec();
773                         forward(number, 0, 0);
774                         break;
775
776                 case A_B_LINE:
777                         /*
778                          * Backward N (default 1) line.
779                          */
780                         if (number <= 0)
781                                 number = 1;
782                         cmd_exec();
783                         backward(number, 0, 0);
784                         break;
785
786                 case A_FF_LINE:
787                         /*
788                          * Force forward N (default 1) line.
789                          */
790                         if (number <= 0)
791                                 number = 1;
792                         cmd_exec();
793                         forward(number, 1, 0);
794                         break;
795
796                 case A_BF_LINE:
797                         /*
798                          * Force backward N (default 1) line.
799                          */
800                         if (number <= 0)
801                                 number = 1;
802                         cmd_exec();
803                         backward(number, 1, 0);
804                         break;
805                 
806                 case A_F_FOREVER:
807                         /*
808                          * Forward forever, ignoring EOF.
809                          */
810                         cmd_exec();
811                         jump_forw();
812                         ignore_eoi = 1;
813                         hit_eof = 0;
814                         while (sigs == 0)
815                                 forward(1, 0, 0);
816                         ignore_eoi = 0;
817                         break;
818
819                 case A_F_SCROLL:
820                         /*
821                          * Forward N lines 
822                          * (default same as last 'd' or 'u' command).
823                          */
824                         if (number > 0)
825                                 scroll = number;
826                         cmd_exec();
827                         forward(scroll, 0, 0);
828                         break;
829
830                 case A_B_SCROLL:
831                         /*
832                          * Forward N lines 
833                          * (default same as last 'd' or 'u' command).
834                          */
835                         if (number > 0)
836                                 scroll = number;
837                         cmd_exec();
838                         backward(scroll, 0, 0);
839                         break;
840
841                 case A_FREPAINT:
842                         /*
843                          * Flush buffers, then repaint screen.
844                          * Don't flush the buffers on a pipe!
845                          */
846                         ch_flush();
847                         if (!ispipe)
848                                 clr_linenum();
849                         /* FALLTHRU */
850                 case A_REPAINT:
851                         /*
852                          * Repaint screen.
853                          */
854                         cmd_exec();
855                         repaint();
856                         break;
857
858                 case A_GOLINE:
859                         /*
860                          * Go to line N, default beginning of file.
861                          */
862                         if (number <= 0)
863                                 number = 1;
864                         cmd_exec();
865                         jump_back(number);
866                         break;
867
868                 case A_PERCENT:
869                         /*
870                          * Go to a specified percentage into the file.
871                          */
872                         if (number < 0)
873                                 number = 0;
874                         if (number > 100)
875                                 number = 100;
876                         cmd_exec();
877                         jump_percent(number);
878                         break;
879
880                 case A_GOEND:
881                         /*
882                          * Go to line N, default end of file.
883                          */
884                         cmd_exec();
885                         if (number <= 0)
886                                 jump_forw();
887                         else
888                                 jump_back(number);
889                         break;
890
891                 case A_GOPOS:
892                         /*
893                          * Go to a specified byte position in the file.
894                          */
895                         cmd_exec();
896                         if (number < 0)
897                                 number = 0;
898                         jump_line_loc((POSITION)number, jump_sline);
899                         break;
900
901                 case A_STAT:
902                         /*
903                          * Print file name, etc.
904                          */
905                         cmd_exec();
906                         parg.p_string = eq_message();
907                         error("%s", &parg);
908                         break;
909                         
910                 case A_VERSION:
911                         /*
912                          * Print version number, without the "@(#)".
913                          */
914                         cmd_exec();
915                         parg.p_string = version+4;
916                         error("%s", &parg);
917                         break;
918
919                 case A_QUIT:
920                         /*
921                          * Exit.
922                          */
923                         quit(0);
924
925 /*
926  * Define abbreviation for a commonly used sequence below.
927  */
928 #define DO_SEARCH()     if (number <= 0) number = 1;    \
929                         mca_search();                   \
930                         cmd_exec();                     \
931                         multi_search((char *)NULL, number);
932
933
934                 case A_F_SEARCH:
935                         /*
936                          * Search forward for a pattern.
937                          * Get the first char of the pattern.
938                          */
939                         search_type = SRCH_FORW;
940                         if (number <= 0)
941                                 number = 1;
942                         mca_search();
943                         c = getcc();
944                         goto again;
945
946                 case A_B_SEARCH:
947                         /*
948                          * Search backward for a pattern.
949                          * Get the first char of the pattern.
950                          */
951                         search_type = SRCH_BACK;
952                         if (number <= 0)
953                                 number = 1;
954                         mca_search();
955                         c = getcc();
956                         goto again;
957
958                 case A_AGAIN_SEARCH:
959                         /*
960                          * Repeat previous search.
961                          */
962                         DO_SEARCH();
963                         break;
964                 
965                 case A_T_AGAIN_SEARCH:
966                         /*
967                          * Repeat previous search, multiple files.
968                          */
969                         search_type |= SRCH_PAST_EOF;
970                         DO_SEARCH();
971                         break;
972
973                 case A_REVERSE_SEARCH:
974                         /*
975                          * Repeat previous search, in reverse direction.
976                          */
977                         save_search_type = search_type;
978                         search_type = SRCH_REVERSE(search_type);
979                         DO_SEARCH();
980                         search_type = save_search_type;
981                         break;
982
983                 case A_T_REVERSE_SEARCH:
984                         /* 
985                          * Repeat previous search, 
986                          * multiple files in reverse direction.
987                          */
988                         save_search_type = search_type;
989                         search_type = SRCH_REVERSE(search_type);
990                         search_type |= SRCH_PAST_EOF;
991                         DO_SEARCH();
992                         search_type = save_search_type;
993                         break;
994
995                 case A_HELP:
996                         /*
997                          * Help.
998                          */
999                         if (nohelp)
1000                         {
1001                                 bell();
1002                                 break;
1003                         }
1004                         lower_left();
1005                         clear_eol();
1006                         putstr("help");
1007                         cmd_exec();
1008                         help();
1009                         break;
1010
1011                 case A_EXAMINE:
1012                         /*
1013                          * Edit a new file.  Get the filename.
1014                          */
1015                         start_mca(A_EXAMINE, "Examine: ");
1016                         c = getcc();
1017                         goto again;
1018                         
1019                 case A_VISUAL:
1020                         /*
1021                          * Invoke an editor on the input file.
1022                          */
1023 #if EDITOR
1024                         if (strcmp(get_filename(curr_ifile), "-") == 0)
1025                         {
1026                                 error("Cannot edit standard input", NULL_PARG);
1027                                 break;
1028                         }
1029                         /*
1030                          * Expand the editor prototype string
1031                          * and pass it to the system to execute.
1032                          */
1033                         cmd_exec();
1034                         lsystem(pr_expand(editproto, 0));
1035                         /*
1036                          * Re-edit the file, since data may have changed.
1037                          * Some editors even recreate the file, so flushing
1038                          * buffers is not sufficient.
1039                          */
1040                         (void) edit(get_filename(curr_ifile), 0);
1041                         break;
1042 #else
1043                         error("Command not available", NULL_PARG);
1044                         break;
1045 #endif
1046
1047                 case A_NEXT_FILE:
1048                         /*
1049                          * Examine next file.
1050                          */
1051                         if (number <= 0)
1052                                 number = 1;
1053                         if (edit_next(number))
1054                         {
1055                                 if (quit_at_eof && hit_eof)
1056                                         quit(0);
1057                                 parg.p_string = (number > 1) ? "(N-th) " : "";
1058                                 error("No %snext file", &parg);
1059                         }
1060                         break;
1061
1062                 case A_PREV_FILE:
1063                         /*
1064                          * Examine previous file.
1065                          */
1066                         if (number <= 0)
1067                                 number = 1;
1068                         if (edit_prev(number))
1069                         {
1070                                 parg.p_string = (number > 1) ? "(N-th) " : "";
1071                                 error("No %sprevious file", &parg);
1072                         }
1073                         break;
1074
1075                 case A_INDEX_FILE:
1076                         /*
1077                          * Examine a particular file.
1078                          */
1079                         if (number <= 0)
1080                                 number = 1;
1081                         if (edit_index(number))
1082                                 error("No such file", NULL_PARG);
1083                         break;
1084
1085                 case A_OPT_TOGGLE:
1086                         start_mca(A_OPT_TOGGLE, "-");
1087                         optflag = OPT_TOGGLE;
1088                         c = getcc();
1089                         goto again;
1090
1091                 case A_DISP_OPTION:
1092                         /*
1093                          * Report a flag setting.
1094                          */
1095                         start_mca(A_DISP_OPTION, "_");
1096                         c = getcc();
1097                         if (c == erase_char || c == kill_char)
1098                                 break;
1099                         toggle_option(c, "", OPT_NO_TOGGLE);
1100                         break;
1101
1102                 case A_FIRSTCMD:
1103                         /*
1104                          * Set an initial command for new files.
1105                          */
1106                         start_mca(A_FIRSTCMD, "+");
1107                         c = getcc();
1108                         goto again;
1109
1110                 case A_SHELL:
1111                         /*
1112                          * Shell escape.
1113                          */
1114 #if SHELL_ESCAPE
1115                         start_mca(A_SHELL, "!");
1116                         c = getcc();
1117                         goto again;
1118 #else
1119                         error("Command not available", NULL_PARG);
1120                         break;
1121 #endif
1122
1123                 case A_SETMARK:
1124                         /*
1125                          * Set a mark.
1126                          */
1127                         start_mca(A_SETMARK, "mark: ");
1128                         c = getcc();
1129                         if (c == erase_char || c == kill_char ||
1130                             c == '\n' || c == '\r')
1131                                 break;
1132                         setmark(c);
1133                         break;
1134
1135                 case A_GOMARK:
1136                         /*
1137                          * Go to a mark.
1138                          */
1139                         start_mca(A_GOMARK, "goto mark: ");
1140                         c = getcc();
1141                         if (c == erase_char || c == kill_char || 
1142                             c == '\n' || c == '\r')
1143                                 break;
1144                         gomark(c);
1145                         break;
1146
1147 #if PIPEC
1148                 case A_PIPE:
1149                         start_mca(A_PIPE, "|mark: ");
1150                         c = getcc();
1151                         if (c == erase_char || c == kill_char)
1152                                 break;
1153                         if (c == '\n' || c == '\r')
1154                                 c = '.';
1155                         if (badmark(c))
1156                                 break;
1157                         pipec = c;
1158                         start_mca(A_PIPE, "!");
1159                         c = getcc();
1160                         goto again;
1161 #endif
1162
1163                 case A_B_BRACKET:
1164                 case A_F_BRACKET:
1165                         start_mca(action, "Brackets: ");
1166                         c = getcc();
1167                         goto again;
1168
1169                 case A_PREFIX:
1170                         /*
1171                          * The command is incomplete (more chars are needed).
1172                          * Display the current char, so the user knows
1173                          * what's going on, and get another character.
1174                          */
1175                         if (mca != A_PREFIX)
1176                         {
1177                                 start_mca(A_PREFIX, " ");
1178                                 cmd_reset();
1179                                 (void) cmd_char(c);
1180                         }
1181                         c = getcc();
1182                         goto again;
1183
1184                 case A_NOACTION:
1185                         break;
1186
1187                 default:
1188                         bell();
1189                         break;
1190                 }
1191         }
1192 }