home *** CD-ROM | disk | FTP | other *** search
/ rtsi.com / 2014.01.www.rtsi.com.tar / www.rtsi.com / OS9 / OSK / SRC / less.v177.lzh / less / command.c < prev    next >
Text File  |  1991-07-16  |  21KB  |  1,193 lines
  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. }
  1193.