![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vcmd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / g / usr / bin / vi|
Return to vcmd.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / bin / vi |
1.1 root 1: /* vcmd.c */
2:
3: /* Author:
4: * Steve Kirkendall
5: * 14407 SW Teal Blvd. #C
6: * Beaverton, OR 97005
7: * [email protected]
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, 0);
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 delta = 0;/* 1 to take autoindent from line below, -1 for above */
365:
366: DEFAULT(1);
367:
368: ChangeText
369: {
370: /* tweak the insertion point, based on command key */
371: switch (key)
372: {
373: case 'i':
374: break;
375:
376: case 'a':
377: pfetch(markline(m));
378: if (plen > 0)
379: {
380: m++;
381: }
382: break;
383:
384: case 'I':
385: m = m_front(m, 1L);
386: break;
387:
388: case 'A':
389: pfetch(markline(m));
390: m = (m & ~(BLKSIZE - 1)) + plen;
391: break;
392:
393: case 'O':
394: m &= ~(BLKSIZE - 1);
395: add(m, "\n");
396: delta = 1;
397: break;
398:
399: case 'o':
400: m = (m & ~(BLKSIZE - 1)) + BLKSIZE;
401: add(m, "\n");
402: delta = -1;
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, delta) + 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, 0);
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, 0);
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 "save & exit" doesn't care)
968: */
969: if (sel != 9)
970: redraw(MARK_UNSET, FALSE);
971:
972: return m;
973: }
974: #endif /* undef NO_POPUP */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.