home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / os2 / elvis / sources / vcmd.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-06-13  |  16.9 KB  |  976 lines
  1. /* vcmd.c */
  2.  
  3. /* Author:
  4.  *    Steve Kirkendall
  5.  *    14407 SW Teal Blvd. #C
  6.  *    Beaverton, OR 97005
  7.  *    kirkenda@cs.pdx.edu
  8.  */
  9.  
  10.  
  11. /* This file contains the functions that handle VI commands */
  12.  
  13.  
  14. #include "config.h"
  15. #include "ctype.h"
  16. #include "vi.h"
  17. #if MSDOS
  18. # include <process.h>
  19. # include <string.h>
  20. #endif
  21. #if TOS
  22. # include <osbind.h>
  23. # include <string.h>
  24. #endif
  25. #if OSK
  26. # include <stdio.h>
  27. #endif
  28.  
  29.  
  30. /* This function puts the editor in EX mode */
  31. MARK v_quit()
  32. {
  33.     move(LINES - 1, 0);
  34.     mode = MODE_EX;
  35.     return cursor;
  36. }
  37.  
  38. /* This function causes the screen to be redrawn */
  39. MARK v_redraw()
  40. {
  41.     redraw(MARK_UNSET, FALSE);
  42.     return cursor;
  43. }
  44.  
  45. /* This function executes a string of EX commands, and waits for a user keystroke
  46.  * before returning to the VI screen.  If that keystroke is another ':', then
  47.  * another EX command is read and executed.
  48.  */
  49. /*ARGSUSED*/
  50. MARK v_1ex(m, text)
  51.     MARK    m;    /* the current line */
  52.     char    *text;    /* the first command to execute */
  53. {
  54.     /* run the command.  be careful about modes & output */
  55.     exwrote = (mode == MODE_COLON);
  56.     doexcmd(text);
  57.     exrefresh();
  58.  
  59.     /* if mode is no longer MODE_VI, then we should quit right away! */
  60.     if (mode != MODE_VI && mode != MODE_COLON)
  61.         return cursor;
  62.  
  63.     /* The command did some output.  Wait for a keystoke. */
  64.     if (exwrote)
  65.     {
  66.         mode = MODE_VI;    
  67.         msg("[Hit <RETURN> to continue]");
  68.         if (getkey(0) == ':')
  69.         {    mode = MODE_COLON;
  70.             addch('\n');
  71.         }
  72.         else
  73.             redraw(MARK_UNSET, FALSE);
  74.     }
  75.  
  76.     return cursor;
  77. }
  78.  
  79. /* This function undoes the last change */
  80. /*ARGSUSED*/
  81. MARK v_undo(m)
  82.     MARK    m;    /* (ignored) */
  83. {
  84.     if (undo())
  85.     {
  86.         redraw(MARK_UNSET, FALSE);
  87.     }
  88.     return cursor;
  89. }
  90.  
  91. /* This function deletes the character(s) that the cursor is on */
  92. MARK v_xchar(m, cnt, cmd)
  93.     MARK    m;    /* where to start deletions */
  94.     long    cnt;    /* number of chars to delete */
  95.     int    cmd;    /* either 'x' or 'X' */
  96. {
  97.     DEFAULT(1);
  98.  
  99.     /* for 'X', adjust so chars are deleted *BEFORE* cursor */
  100.     if (cmd == 'X')
  101.     {
  102.         if (markidx(m) < cnt)
  103.             return MARK_UNSET;
  104.         m -= cnt;
  105.     }
  106.  
  107.     /* make sure we don't try to delete more thars than there are */
  108.     pfetch(markline(m));
  109.     if (markidx(m + cnt) > plen)
  110.     {
  111.         cnt = plen - markidx(m);
  112.     }
  113.     if (cnt == 0L)
  114.     {
  115.         return MARK_UNSET;
  116.     }
  117.  
  118.     /* do it */
  119.     ChangeText
  120.     {
  121.         cut(m, m + cnt);
  122.         delete(m, m + cnt);
  123.     }
  124.     return m;
  125. }
  126.  
  127. /* This function defines a mark */
  128. /*ARGSUSED*/
  129. MARK v_mark(m, count, key)
  130.     MARK    m;    /* where the mark will be */
  131.     long    count;    /* (ignored) */
  132.     int    key;    /* the ASCII label of the mark */
  133. {
  134.     if (key < 'a' || key > 'z')
  135.     {
  136.         msg("Marks must be from a to z");
  137.     }
  138.     else
  139.     {
  140.         mark[key - 'a'] = m;
  141.     }
  142.     return m;
  143. }
  144.  
  145. /* This function toggles upper & lower case letters */
  146. MARK v_ulcase(m, cnt)
  147.     MARK    m;    /* where to make the change */
  148.     long    cnt;    /* number of chars to flip */
  149. {
  150.     REG char     *pos;
  151.     REG int        j;
  152.  
  153.     DEFAULT(1);
  154.  
  155.     /* fetch the current version of the line */
  156.     pfetch(markline(m));
  157.  
  158.     /* for each position in the line */
  159.     for (j = 0, pos = &ptext[markidx(m)]; j < cnt && *pos; j++, pos++)
  160.     {
  161.         if (isupper(*pos))
  162.         {
  163.             tmpblk.c[j] = tolower(*pos);
  164.         }
  165.         else
  166.         {
  167.             tmpblk.c[j] = toupper(*pos);
  168.         }
  169.     }
  170.  
  171.     /* if the new text is different from the old, then change it */
  172.     if (strncmp(tmpblk.c, &ptext[markidx(m)], j))
  173.     {
  174.         ChangeText
  175.         {
  176.             tmpblk.c[j] = '\0';
  177.             change(m, m + j, tmpblk.c);
  178.         }
  179.     }
  180.  
  181.     return m + j;
  182. }
  183.  
  184.  
  185. MARK v_replace(m, cnt, key)
  186.     MARK    m;    /* first char to be replaced */
  187.     long    cnt;    /* number of chars to replace */
  188.     int    key;    /* what to replace them with */
  189. {
  190.     REG char    *text;
  191.     REG int        i;
  192.  
  193.     DEFAULT(1);
  194.  
  195.     /* map ^M to '\n' */
  196.     if (key == '\r')
  197.     {
  198.         key = '\n';
  199.     }
  200.  
  201.     /* make sure the resulting line isn't too long */
  202.     if (cnt > BLKSIZE - 2 - markidx(m))
  203.     {
  204.         cnt = BLKSIZE - 2 - markidx(m);
  205.     }
  206.  
  207.     /* build a string of the desired character with the desired length */
  208.     for (text = tmpblk.c, i = cnt; i > 0; i--)
  209.     {
  210.         *text++ = key;
  211.     }
  212.     *text = '\0';
  213.  
  214.     /* make sure cnt doesn't extend past EOL */
  215.     pfetch(markline(m));
  216.     key = markidx(m);
  217.     if (key + cnt > plen)
  218.     {
  219.         cnt = plen - key;
  220.     }
  221.  
  222.     /* do the replacement */
  223.     ChangeText
  224.     {
  225.         change(m, m + cnt, tmpblk.c);
  226.     }
  227.  
  228.     if (*tmpblk.c == '\n')
  229.     {
  230.         return (m & ~(BLKSIZE - 1)) + cnt * BLKSIZE;
  231.     }
  232.     else
  233.     {
  234.         return m + cnt - 1;
  235.     }
  236. }
  237.  
  238. MARK v_overtype(m)
  239.     MARK        m;    /* where to start overtyping */
  240. {
  241.     MARK        end;    /* end of a substitution */
  242.     static long    width;    /* width of a single-line replace */
  243.  
  244.     /* the "doingdot" version of replace is really a substitution */
  245.     if (doingdot)
  246.     {
  247.         /* was the last one really repeatable? */
  248.         if (width < 0)
  249.         {
  250.             msg("Can't repeat a multi-line overtype command");
  251.             return MARK_UNSET;
  252.         }
  253.  
  254.         /* replacing nothing by nothing?  Don't bother */
  255.         if (width == 0)
  256.         {
  257.             return m;
  258.         }
  259.  
  260.         /* replace some chars by repeated text */
  261.         return v_subst(m, width);
  262.     }
  263.  
  264.     /* Normally, we input starting here, in replace mode */
  265.     ChangeText
  266.     {
  267.         end = input(m, m, WHEN_VIREP, FALSE);
  268.     }
  269.  
  270.     /* if we ended on the same line we started on, then this
  271.      * overtype is repeatable via the dot key.
  272.      */
  273.     if (markline(end) == markline(m) && end >= m - 1L)
  274.     {
  275.         width = end - m + 1L;
  276.     }
  277.     else /* it isn't repeatable */
  278.     {
  279.         width = -1L;
  280.     }
  281.  
  282.     return end;
  283. }
  284.  
  285.  
  286. /* This function selects which cut buffer to use */
  287. /*ARGSUSED*/
  288. MARK v_selcut(m, cnt, key)
  289.     MARK    m;
  290.     long    cnt;
  291.     int    key;
  292. {
  293.     cutname(key);
  294.     return m;
  295. }
  296.  
  297. /* This function pastes text from a cut buffer */
  298. /*ARGSUSED*/
  299. MARK v_paste(m, cnt, cmd)
  300.     MARK    m;    /* where to paste the text */
  301.     long    cnt;    /* (ignored) */
  302.     int    cmd;    /* either 'p' or 'P' */
  303. {
  304.     MARK    dest;
  305.  
  306.     ChangeText
  307.     {
  308.         /* paste the text, and find out where it ends */
  309.         dest = paste(m, cmd == 'p', TRUE);
  310.  
  311.         /* was that a line-mode paste? */
  312.         if (dest && markline(dest) != markline(m))
  313.         {
  314.             /* line-mode pastes leave the cursor at the front
  315.              * of the first pasted line.
  316.              */
  317.             dest = m;
  318.             if (cmd == 'p')
  319.             {
  320.                 dest += BLKSIZE;
  321.             }
  322.             force_flags |= FRNT;
  323.         }
  324.     }
  325.     return dest;
  326. }
  327.  
  328. /* This function yanks text into a cut buffer */
  329. MARK v_yank(m, n)
  330.     MARK    m, n;    /* range of text to yank */
  331. {
  332.     cut(m, n);
  333.     return m;
  334. }
  335.  
  336. /* This function deletes a range of text */
  337. MARK v_delete(m, n)
  338.     MARK    m, n;    /* range of text to delete */
  339. {
  340.     /* illegal to try and delete nothing */
  341.     if (n <= m)
  342.     {
  343.         return MARK_UNSET;
  344.     }
  345.  
  346.     /* Do it */
  347.     ChangeText
  348.     {
  349.         cut(m, n);
  350.         delete(m, n);
  351.     }
  352.     return m;
  353. }
  354.  
  355.  
  356. /* This starts input mode without deleting anything */
  357. MARK v_insert(m, cnt, key)
  358.     MARK    m;    /* where to start (sort of) */
  359.     long    cnt;    /* repeat how many times? */
  360.     int    key;    /* what command is this for? {a,A,i,I,o,O} */
  361. {
  362.     int    wasdot;
  363.     long    reps;
  364.     int    above;    /* boolean: new line going above old line? */
  365.  
  366.     DEFAULT(1);
  367.  
  368.     ChangeText
  369.     {
  370.         /* tweak the insertion point, based on command key */
  371.         above = FALSE;
  372.         switch (key)
  373.         {
  374.           case 'i':
  375.             break;
  376.  
  377.           case 'a':
  378.             pfetch(markline(m));
  379.             if (plen > 0)
  380.             {
  381.                 m++;
  382.             }
  383.             break;
  384.  
  385.           case 'I':
  386.             m = m_front(m, 1L);
  387.             break;
  388.  
  389.           case 'A':
  390.             pfetch(markline(m));
  391.             m = (m & ~(BLKSIZE - 1)) + plen;
  392.             break;
  393.  
  394.           case 'O':
  395.             m &= ~(BLKSIZE - 1);
  396.             add(m, "\n");
  397.             above = TRUE;
  398.             break;
  399.  
  400.           case 'o':
  401.             m = (m & ~(BLKSIZE - 1)) + BLKSIZE;
  402.             add(m, "\n");
  403.             break;
  404.         }
  405.  
  406.         /* insert the same text once or more */
  407.         for (reps = cnt, wasdot = doingdot; reps > 0; reps--, doingdot = TRUE)
  408.         {
  409.             m = input(m, m, WHEN_VIINP, above) + 1;
  410.         }
  411.         if (markidx(m) > 0)
  412.         {
  413.             m--;
  414.         }
  415.  
  416.         doingdot = wasdot;
  417.     }
  418.  
  419. #ifndef CRUNCH
  420. # ifndef NO_EXTENSIONS
  421.     if (key == 'i' && *o_inputmode && mode == MODE_VI)
  422.     {
  423.         msg("Now in command mode!  To return to input mode, hit <i>");
  424.     }
  425. # endif
  426. #endif
  427.  
  428.     return m;
  429. }
  430.  
  431. /* This starts input mode with some text deleted */
  432. MARK v_change(m, n)
  433.     MARK    m, n;    /* the range of text to change */
  434. {
  435.     int    lnmode;    /* is this a line-mode change? */
  436.  
  437.     /* swap them if they're in reverse order */
  438.     if (m > n)
  439.     {
  440.         MARK    tmp;
  441.         tmp = m;
  442.         m = n;
  443.         n = tmp;
  444.     }
  445.  
  446.     /* for line mode, retain the last newline char */
  447.     lnmode = (markidx(m) == 0 && markidx(n) == 0 && m != n);
  448.     if (lnmode)
  449.     {
  450.         n -= BLKSIZE;
  451.         pfetch(markline(n));
  452.         n = (n & ~(BLKSIZE - 1)) + plen;
  453.     }
  454.  
  455.     ChangeText
  456.     {
  457.         cut(m, n);
  458.         m = input(m, n, WHEN_VIINP, FALSE);
  459.     }
  460.  
  461.     return m;
  462. }
  463.  
  464. /* This function replaces a given number of characters with input */
  465. MARK v_subst(m, cnt)
  466.     MARK    m;    /* where substitutions start */
  467.     long    cnt;    /* number of chars to replace */
  468. {
  469.     DEFAULT(1);
  470.  
  471.     /* make sure we don't try replacing past EOL */
  472.     pfetch(markline(m));
  473.     if (markidx(m) + cnt > plen)
  474.     {
  475.         cnt = plen - markidx(m);
  476.     }
  477.  
  478.     /* Go for it! */
  479.     ChangeText
  480.     {
  481.         cut(m, m + cnt);
  482.         m = input(m, m + cnt, WHEN_VIINP, FALSE);
  483.     }
  484.     return m;
  485. }
  486.  
  487. /* This calls the ex "join" command to join some lines together */
  488. MARK v_join(m, cnt)
  489.     MARK    m;    /* the first line to be joined */
  490.     long    cnt;    /* number of other lines to join */
  491. {
  492.     MARK    joint;    /* where the lines were joined */
  493.  
  494.     DEFAULT(1);
  495.  
  496.     /* figure out where the joint will be */
  497.     pfetch(markline(m));
  498.     joint = (m & ~(BLKSIZE - 1)) + plen;
  499.  
  500.     /* join the lines */
  501.     cmd_join(m, m + MARK_AT_LINE(cnt), CMD_JOIN, 0, "");
  502.  
  503.     /* the cursor should be left at the joint */
  504.     return joint;
  505. }
  506.  
  507.  
  508. /* This calls the ex "<" command to shift some lines left */
  509. MARK v_lshift(m, n)
  510.     MARK    m, n;    /* range of lines to shift */
  511. {
  512.     /* adjust for inclusive endmarks in ex */
  513.     n -= BLKSIZE;
  514.  
  515.     cmd_shift(m, n, CMD_SHIFTL, FALSE, (char *)0);
  516.  
  517.     return m;
  518. }
  519.  
  520. /* This calls the ex ">" command to shift some lines right */
  521. MARK v_rshift(m, n)
  522.     MARK    m, n;    /* range of lines to shift */
  523. {
  524.     /* adjust for inclusive endmarks in ex */
  525.     n -= BLKSIZE;
  526.  
  527.     cmd_shift(m, n, CMD_SHIFTR, FALSE, (char *)0);
  528.  
  529.     return m;
  530. }
  531.  
  532. /* This filters some lines through a preset program, to reformat them */
  533. MARK v_reformat(m, n)
  534.     MARK    m, n;    /* range of lines to shift */
  535. {
  536.     /* adjust for inclusive endmarks in ex */
  537.     n -= BLKSIZE;
  538.  
  539.     /* run the filter command */
  540.     filter(m, n, o_equalprg, TRUE);
  541.  
  542.     redraw(MARK_UNSET, FALSE);
  543.     return m;
  544. }
  545.  
  546.  
  547. /* This runs some lines through a filter program */
  548. MARK v_filter(m, n)
  549.     MARK    m, n;    /* range of lines to shift */
  550. {
  551.     char    cmdln[150];    /* a shell command line */
  552.  
  553.     /* adjust for inclusive endmarks in ex */
  554.     n -= BLKSIZE;
  555.  
  556.     if (vgets('!', cmdln, sizeof(cmdln)) > 0)
  557.     {
  558.         filter(m, n, cmdln, TRUE);
  559.     }
  560.  
  561.     redraw(MARK_UNSET, FALSE);
  562.     return m;
  563. }
  564.  
  565.  
  566. /* This function runs the ex "file" command to show the file's status */
  567. MARK v_status()
  568. {
  569.     cmd_file(cursor, cursor, CMD_FILE, 0, "");
  570.     return cursor;
  571. }
  572.  
  573.  
  574. /* This function runs the ":&" command to repeat the previous :s// */
  575. MARK v_again(m, n)
  576.     MARK    m, n;
  577. {
  578.     cmd_substitute(m, n - BLKSIZE, CMD_SUBAGAIN, TRUE, "");
  579.     return cursor;
  580. }
  581.  
  582.  
  583.  
  584. /* This function switches to the previous file, if possible */
  585. MARK v_switch()
  586. {
  587.     if (!*prevorig)
  588.         msg("No previous file");
  589.     else
  590.     {    strcpy(tmpblk.c, prevorig);
  591.         cmd_edit(cursor, cursor, CMD_EDIT, 0, tmpblk.c);
  592.     }
  593.     return cursor;
  594. }
  595.  
  596. /* This function does a tag search on a keyword */
  597. /*ARGSUSED*/
  598. MARK v_tag(keyword, m, cnt)
  599.     char    *keyword;
  600.     MARK    m;
  601.     long    cnt;
  602. {
  603.     /* move the cursor to the start of the tag name, where m is */
  604.     cursor = m;
  605.  
  606.     /* perform the tag search */
  607.     cmd_tag(cursor, cursor, CMD_TAG, 0, keyword);
  608.  
  609.     return cursor;
  610. }
  611.  
  612. #ifndef NO_EXTENSIONS
  613. /* This function looks up a keyword by calling the helpprog program */
  614. /*ARGSUSED*/
  615. MARK v_keyword(keyword, m, cnt)
  616.     char    *keyword;
  617.     MARK    m;
  618.     long    cnt;
  619. {
  620.     int    waswarn;
  621.     char    cmdline[130];
  622.  
  623.     move(LINES - 1, 0);
  624.     addstr("---------------------------------------------------------\n");
  625.     clrtoeol();
  626.     refresh();
  627.     sprintf(cmdline, "%s %s", o_keywordprg, keyword);
  628.     waswarn = *o_warn;
  629.     *o_warn = FALSE;
  630.     suspend_curses();
  631.     if (system(cmdline))
  632.     {
  633.         addstr("<<< failed >>>\n");
  634.     }
  635.     resume_curses(FALSE);
  636.     mode = MODE_VI;
  637.     redraw(MARK_UNSET, FALSE);
  638.     *o_warn = waswarn;
  639.  
  640.     return m;
  641. }
  642.  
  643.  
  644.  
  645. MARK v_increment(keyword, m, cnt)
  646.     char    *keyword;
  647.     MARK    m;
  648.     long    cnt;
  649. {
  650.     static    sign;
  651.     char    newval[12];
  652.     long    atol();
  653.  
  654.     DEFAULT(1);
  655.  
  656.     /* get one more keystroke, unless doingdot */
  657.     if (!doingdot)
  658.     {
  659.         sign = getkey(0);
  660.     }
  661.  
  662.     /* adjust the number, based on that second keystroke */
  663.     switch (sign)
  664.     {
  665.       case '+':
  666.       case '#':
  667.         cnt = atol(keyword) + cnt;
  668.         break;
  669.  
  670.       case '-':
  671.         cnt = atol(keyword) - cnt;
  672.         break;
  673.  
  674.       case '=':
  675.         break;
  676.  
  677.       default:
  678.         return MARK_UNSET;
  679.     }
  680.     sprintf(newval, "%ld", cnt);
  681.  
  682.     ChangeText
  683.     {
  684.         change(m, m + strlen(keyword), newval);
  685.     }
  686.  
  687.     return m;
  688. }
  689. #endif
  690.  
  691.  
  692. /* This function acts like the EX command "xit" */
  693. /*ARGSUSED*/
  694. MARK v_xit(m, cnt, key)
  695.     MARK    m;    /* ignored */
  696.     long    cnt;    /* ignored */
  697.     int    key;    /* must be a second 'Z' */
  698. {
  699.     /* if second char wasn't 'Z', fail */
  700.     if (key != 'Z')
  701.     {
  702.         return MARK_UNSET;
  703.     }
  704.  
  705.     /* move the cursor to the bottom of the screen */
  706.     move(LINES - 1, 0);
  707.     clrtoeol();
  708.  
  709.     /* do the xit command */
  710.     cmd_xit(m, m, CMD_XIT, FALSE, "");
  711.  
  712.     /* return the cursor */
  713.     return m;
  714. }
  715.  
  716.  
  717. /* This function undoes changes to a single line, if possible */
  718. MARK v_undoline(m)
  719.     MARK    m;    /* where we hope to undo the change */
  720. {
  721.     /* make sure we have the right line in the buffer */
  722.     if (markline(m) != U_line)
  723.     {
  724.         return MARK_UNSET;
  725.     }
  726.  
  727.     /* fix it */
  728.     ChangeText
  729.     {
  730.         strcat(U_text, "\n");
  731.         change(MARK_AT_LINE(U_line), MARK_AT_LINE(U_line + 1), U_text);
  732.     }
  733.  
  734.     /* nothing in the buffer anymore */
  735.     U_line = -1L;
  736.  
  737.     /* return, with the cursor at the front of the line */
  738.     return m & ~(BLKSIZE - 1);
  739. }
  740.  
  741.  
  742. #ifndef NO_ERRLIST
  743. MARK v_errlist(m)
  744.     MARK    m;
  745. {
  746.     cmd_errlist(m, m, CMD_ERRLIST, FALSE, "");
  747.     return cursor;
  748. }
  749. #endif
  750.  
  751.  
  752. #ifndef NO_AT
  753. /*ARGSUSED*/
  754. MARK v_at(m, cnt, key)
  755.     MARK    m;
  756.     long    cnt;
  757.     int    key;
  758. {
  759.     int    size;
  760.  
  761.     size = cb2str(key, tmpblk.c, BLKSIZE);
  762.     if (size <= 0 || size == BLKSIZE)
  763.     {
  764.         return MARK_UNSET;
  765.     }
  766.  
  767.     execmap(0, tmpblk.c, FALSE);
  768.     return cursor;
  769. }
  770. #endif
  771.  
  772.  
  773. #ifdef SIGTSTP
  774. MARK v_suspend()
  775. {
  776.     cmd_suspend(MARK_UNSET, MARK_UNSET, CMD_SUSPEND, FALSE, "");
  777.     return MARK_UNSET;
  778. }
  779. #endif
  780.  
  781.  
  782. #ifndef NO_VISIBLE
  783. /*ARGSUSED*/
  784. MARK v_start(m, cnt, cmd)
  785.     MARK    m;    /* starting point for a v or V command */
  786.     long    cnt;    /* ignored */
  787.     int    cmd;    /* either 'v' or 'V' */
  788. {
  789.     if (V_from)
  790.     {
  791.         V_from = MARK_UNSET;
  792.     }
  793.     else
  794.     {
  795.         V_from = m;
  796.         V_linemd = isupper(cmd);
  797.     }
  798.     return m;
  799. }
  800. #endif
  801.  
  802. #ifndef NO_POPUP
  803. # define MENU_HEIGHT 11
  804. # define MENU_WIDTH  23
  805. MARK v_popup(m, n)
  806.     MARK        m, n;    /* the range of text to change */
  807. {
  808.     int        i;
  809.     int        y, x;    /* position where the window will pop up at */
  810.     int        key;    /* keystroke from the user */
  811.     int        sel;    /* index of the selected operation */
  812.     static int    dfltsel;/* default value of sel */
  813.     static char    *labels[11] =
  814.     {
  815.         "ESC cancel!         ",
  816.         " d  delete (cut)    ",
  817.         " y  yank (copy)     ",
  818.         " p  paste after     ",
  819.         " P  paste before    ",
  820.         " >  more indented   ",
  821.         " <  less indented   ",
  822.         " =  reformat        ",
  823.         " !  external filter ",
  824.         " ZZ save & exit     ",
  825.         " u  undo previous   "
  826.     };
  827.  
  828.     /* try to position the menu near the cursor */
  829.     x = physcol - (MENU_WIDTH / 2);
  830.     if (x < 0)
  831.         x = 0;
  832.     else if (x + MENU_WIDTH + 2 > COLS)
  833.         x = COLS - MENU_WIDTH - 2;
  834.     if (markline(cursor) < topline || markline(cursor) > botline)
  835.         y = 0;
  836.     else if (markline(cursor) + 1L + MENU_HEIGHT > botline)
  837.         y = (int)(markline(cursor) - topline) - MENU_HEIGHT;
  838.     else
  839.         y = (int)(markline(cursor) - topline) + 1L;
  840.  
  841.     /* draw the menu */
  842.     for (sel = 0; sel < MENU_HEIGHT; sel++)
  843.     {
  844.         move(y + sel, x);
  845.         do_POPUP();
  846.         if (sel == dfltsel)
  847.             qaddstr("-->");
  848.         else
  849.             qaddstr("   ");
  850.         qaddstr(labels[sel]);
  851.         do_SE();
  852.     }
  853.  
  854.     /* get a selection */
  855.     move(y + dfltsel, x + 4);
  856.     for (sel = dfltsel; (key = getkey(WHEN_POPUP)) != '\\' && key != '\r'; )
  857.     {
  858.         /* erase the selection arrow */
  859.         move(y + sel, x);
  860.         do_POPUP();
  861.         qaddstr("   ");
  862.         qaddstr(labels[sel]);
  863.         do_SE();
  864.  
  865.         /* process the user's keystroke */
  866.         if (key == 'j' && sel < MENU_HEIGHT - 1)
  867.         {
  868.             sel++;
  869.         }
  870.         else if (key == 'k' && sel > 0)
  871.         {
  872.             sel--;
  873.         }
  874.         else if (key == '\033')
  875.         {
  876.             sel = 0;
  877.             break;
  878.         }
  879.         else
  880.         {
  881.             for (i = 1; i < MENU_HEIGHT && labels[i][1] != key; i++)
  882.             {
  883.             }
  884.             if (i < MENU_HEIGHT)
  885.             {
  886.                 sel = i;
  887.                 break;
  888.             }
  889.         }
  890.  
  891.         /* redraw the arrow, possibly in a new place */
  892.         move(y + sel, x);
  893.         do_POPUP();
  894.         qaddstr("-->");
  895.         qaddstr(labels[sel]);
  896.         do_SE();
  897.         move(y + sel, x + 4);
  898.     }
  899.  
  900.     /* in most cases, the default selection is "paste after" */
  901.     dfltsel = 3;
  902.  
  903.     /* perform the appropriate action */
  904.     switch (sel)
  905.     {
  906.       case 0:
  907.         m = cursor;
  908.         dfltsel = 0;
  909.         break;
  910.  
  911.       case 1: /* delete (cut) */
  912.         m = v_delete(m, n);
  913.         break;
  914.  
  915.       case 2: /* yank (copy) */
  916.         m = v_yank(m, n);
  917.         break;
  918.  
  919.       case 3: /* paste after */
  920.         m = v_paste(n, 1L, 'P');
  921.         break;
  922.  
  923.       case 4: /* paste before */
  924.         m = v_paste(m, 1L, 'P');
  925.         dfltsel = 4;
  926.         break;
  927.  
  928.       case 5: /* more indented */
  929.         m = v_rshift(m, n);
  930.         dfltsel = 5;
  931.         break;
  932.  
  933.       case 6: /* less indented */
  934.         m = v_lshift(m, n);
  935.         dfltsel = 6;
  936.         break;
  937.  
  938.       case 7: /* reformat */
  939.         m = v_reformat(m, n);
  940.         dfltsel = 7;
  941.         break;
  942.  
  943.       case 8: /* external filter */
  944.         m = v_filter(m, n);
  945.         dfltsel = 0;
  946.         break;
  947.  
  948.       case 9: /* save & exit */
  949.         /* get confirmation first */
  950.         do
  951.         {
  952.             key = getkey(0);
  953.         } while (key != '\\' && key != 'Z' && key != '\r'    /* good */
  954.               && key != '\033');                 /* bad  */
  955.         if (key != '\033')
  956.         {
  957.             m = v_xit(m, 0L, 'Z');
  958.         }
  959.         break;
  960.  
  961.       case 10: /* undo previous */
  962.         m = v_undo(m);
  963.         dfltsel = 9;
  964.         break;
  965.     }
  966.  
  967.     /* arrange for the menu to be erased (except that "chg from kbd"
  968.      * already erased it, and "save & exit" doesn't care)
  969.      */
  970.     if (sel != 5 && sel != 9)
  971.         redraw(MARK_UNSET, FALSE);
  972.  
  973.     return m;
  974. }
  975. #endif /* undef NO_POPUP */
  976.