![[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 / d / usr / bin / elvis|
Return to vcmd.c CVS log | Up to [MW Coherent from dump] / coherent / d / usr / bin / elvis |
1.1 root 1: /* vcmd.c */
2:
3: /* Author:
4: * Steve Kirkendall
5: * 16820 SW Tallac Way
6: * Beaverton, OR 97006
7: * [email protected], or ...uunet!tektronix!psueea!jove!kirkenda
8: */
9:
10:
11: /* This file contains the functions that handle VI commands */
12:
13:
14: #include "config.h"
15: #include "vi.h"
16: #if MSDOS
17: #include <process.h>
18: #include <string.h>
19: #endif
20: #if TOS
21: #include <osbind.h>
22: #include <string.h>
23: #endif
24: #if OSK
25: # include <stdio.h>
26: #endif
27:
28:
29: /* This function puts the editor in EX mode */
30: MARK v_quit()
31: {
32: move(LINES - 1, 0);
33: mode = MODE_EX;
34: return cursor;
35: }
36:
37: /* This function causes the screen to be redrawn */
38: MARK v_redraw()
39: {
40: redraw(MARK_UNSET, FALSE);
41: return cursor;
42: }
43:
44: /* This function executes a single EX command, and waits for a user keystroke
45: * before returning to the VI screen. If that keystroke is another ':', then
46: * another EX command is read and executed.
47: */
48: /*ARGSUSED*/
49: MARK v_1ex(m, text)
50: MARK m; /* the current line */
51: char *text; /* the first command to execute */
52: {
53: /* run the command. be careful about modes & output */
54: exwrote = (mode == MODE_COLON);
55: doexcmd(text);
56: exrefresh();
57:
58: /* if mode is no longer MODE_VI, then we should quit right away! */
59: if (mode != MODE_VI && mode != MODE_COLON)
60: return cursor;
61:
62: /* The command did some output. Wait for a keystoke. */
63: if (exwrote)
64: {
65: mode = MODE_VI;
66: msg("[Hit <RETURN> to continue]");
67: if (getkey(0) == ':')
68: { mode = MODE_COLON;
69: addch('\n');
70: }
71: else
72: redraw(MARK_UNSET, FALSE);
73: }
74:
75: return cursor;
76: }
77:
78: /* This function undoes the last change */
79: /*ARGSUSED*/
80: MARK v_undo(m)
81: MARK m; /* (ignored) */
82: {
83: if (undo())
84: {
85: redraw(MARK_UNSET, FALSE);
86: }
87: return cursor;
88: }
89:
90: /* This function deletes the character(s) that the cursor is on */
91: MARK v_xchar(m, cnt, cmd)
92: MARK m; /* where to start deletions */
93: long cnt; /* number of chars to delete */
94: int cmd; /* either 'x' or 'X' */
95: {
96: DEFAULT(1);
97:
98: /* for 'X', adjust so chars are deleted *BEFORE* cursor */
99: if (cmd == 'X')
100: {
101: if (markidx(m) < cnt)
102: return MARK_UNSET;
103: m -= cnt;
104: }
105:
106: /* make sure we don't try to delete more thars than there are */
107: pfetch(markline(m));
108: if (markidx(m + cnt) > plen)
109: {
110: cnt = plen - markidx(m);
111: }
112: if (cnt == 0L)
113: {
114: return MARK_UNSET;
115: }
116:
117: /* do it */
118: ChangeText
119: {
120: cut(m, m + cnt);
121: delete(m, m + cnt);
122: }
123: return m;
124: }
125:
126: /* This function defines a mark */
127: /*ARGSUSED*/
128: MARK v_mark(m, count, key)
129: MARK m; /* where the mark will be */
130: long count; /* (ignored) */
131: int key; /* the ASCII label of the mark */
132: {
133: if (key < 'a' || key > 'z')
134: {
135: msg("Marks must be from a to z");
136: }
137: else
138: {
139: mark[key - 'a'] = m;
140: }
141: return m;
142: }
143:
144: /* This function toggles upper & lower case letters */
145: MARK v_ulcase(m, cnt)
146: MARK m; /* where to make the change */
147: long cnt; /* number of chars to flip */
148: {
149: REG char *pos;
150: REG int i, j;
151: static char flip[] =
152: "aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ[](){}<>";
153:
154: DEFAULT(1);
155:
156: /* fetch the current version of the line */
157: pfetch(markline(m));
158:
159: /* for each position in the line */
160: for (j = 0, i = markidx(m); j < cnt && ptext[i]; j++, i++)
161: {
162: tmpblk.c[j] = 0;
163:
164: /* one of the standard chars? */
165: for (pos = flip; *pos && *pos != ptext[i]; pos++)
166: {
167: }
168: if (*pos)
169: {
170: tmpblk.c[j] = flip[(int)(pos - flip) ^ 1];
171: }
172: #ifndef NO_DIGRAPH
173: else /* one of the non-standard chars? */
174: {
175: for (pos = o_flipcase; *pos && *pos != ptext[i]; pos++)
176: {
177: }
178: if (*pos)
179: {
180: tmpblk.c[j] = o_flipcase[(int)(pos - o_flipcase) ^ 1];
181: }
182: }
183: #endif
184:
185: /* if nothing special, then don't change it */
186: if (tmpblk.c[j] == 0)
187: {
188: tmpblk.c[j] = ptext[i];
189: }
190: }
191:
192: /* if the new text is different from the old, then change it */
193: if (strncmp(tmpblk.c, &ptext[markidx(m)], j))
194: {
195: ChangeText
196: {
197: tmpblk.c[j] = '\0';
198: change(m, m + j, tmpblk.c);
199: }
200: }
201:
202: return m + j;
203: }
204:
205:
206: MARK v_replace(m, cnt, key)
207: MARK m; /* first char to be replaced */
208: long cnt; /* number of chars to replace */
209: int key; /* what to replace them with */
210: {
211: REG char *text;
212: REG int i;
213:
214: DEFAULT(1);
215:
216: /* map ^M to '\n' */
217: if (key == '\r')
218: {
219: key = '\n';
220: }
221:
222: /* make sure the resulting line isn't too long */
223: if (cnt > BLKSIZE - 2 - markidx(m))
224: {
225: cnt = BLKSIZE - 2 - markidx(m);
226: }
227:
228: /* build a string of the desired character with the desired length */
229: for (text = tmpblk.c, i = cnt; i > 0; i--)
230: {
231: *text++ = key;
232: }
233: *text = '\0';
234:
235: /* make sure cnt doesn't extend past EOL */
236: pfetch(markline(m));
237: key = markidx(m);
238: if (key + cnt > plen)
239: {
240: cnt = plen - key;
241: }
242:
243: /* do the replacement */
244: ChangeText
245: {
246: change(m, m + cnt, tmpblk.c);
247: }
248:
249: if (*tmpblk.c == '\n')
250: {
251: return (m & ~(BLKSIZE - 1)) + cnt * BLKSIZE;
252: }
253: else
254: {
255: return m + cnt - 1;
256: }
257: }
258:
259: MARK v_overtype(m)
260: MARK m; /* where to start overtyping */
261: {
262: MARK end; /* end of a substitution */
263: static long width; /* width of a single-line replace */
264:
265: /* the "doingdot" version of replace is really a substitution */
266: if (doingdot)
267: {
268: /* was the last one really repeatable? */
269: if (width < 0)
270: {
271: msg("Can't repeat a multi-line overtype command");
272: return MARK_UNSET;
273: }
274:
275: /* replacing nothing by nothing? Don't bother */
276: if (width == 0)
277: {
278: return m;
279: }
280:
281: /* replace some chars by repeated text */
282: return v_subst(m, width);
283: }
284:
285: /* Normally, we input starting here, in replace mode */
286: ChangeText
287: {
288: end = input(m, m, WHEN_VIREP);
289: }
290:
291: /* if we ended on the same line we started on, then this
292: * overtype is repeatable via the dot key.
293: */
294: if (markline(end) == markline(m) && end >= m - 1L)
295: {
296: width = end - m + 1L;
297: }
298: else /* it isn't repeatable */
299: {
300: width = -1L;
301: }
302:
303: return end;
304: }
305:
306:
307: /* This function selects which cut buffer to use */
308: /*ARGSUSED*/
309: MARK v_selcut(m, cnt, key)
310: MARK m;
311: long cnt;
312: int key;
313: {
314: cutname(key);
315: return m;
316: }
317:
318: /* This function pastes text from a cut buffer */
319: /*ARGSUSED*/
320: MARK v_paste(m, cnt, cmd)
321: MARK m; /* where to paste the text */
322: long cnt; /* (ignored) */
323: int cmd; /* either 'p' or 'P' */
324: {
325: ChangeText
326: {
327: m = paste(m, cmd == 'p', FALSE);
328: }
329: return m;
330: }
331:
332: /* This function yanks text into a cut buffer */
333: MARK v_yank(m, n)
334: MARK m, n; /* range of text to yank */
335: {
336: cut(m, n);
337: return m;
338: }
339:
340: /* This function deletes a range of text */
341: MARK v_delete(m, n)
342: MARK m, n; /* range of text to delete */
343: {
344: /* illegal to try and delete nothing */
345: if (n <= m)
346: {
347: return MARK_UNSET;
348: }
349:
350: /* Do it */
351: ChangeText
352: {
353: cut(m, n);
354: delete(m, n);
355: }
356: return m;
357: }
358:
359:
360: /* This starts input mode without deleting anything */
361: MARK v_insert(m, cnt, key)
362: MARK m; /* where to start (sort of) */
363: long cnt; /* repeat how many times? */
364: int key; /* what command is this for? {a,A,i,I,o,O} */
365: {
366: int wasdot;
367: long reps;
368: int after; /* are we appending or inserting? */
369:
370: DEFAULT(1);
371:
372: ChangeText
373: {
374: /* tweak the insertion point, based on command key */
375: switch (key)
376: {
377: case 'i':
378: after = FALSE;
379: break;
380:
381: case 'a':
382: pfetch(markline(m));
383: if (plen > 0)
384: {
385: m++;
386: }
387: after = TRUE;
388: break;
389:
390: case 'I':
391: m = m_front(m, 1L);
392: after = FALSE;
393: break;
394:
395: case 'A':
396: pfetch(markline(m));
397: m = (m & ~(BLKSIZE - 1)) + plen;
398: after = TRUE;
399: break;
400:
401: case 'O':
402: m &= ~(BLKSIZE - 1);
403: add(m, "\n");
404: after = FALSE;
405: break;
406:
407: case 'o':
408: m = (m & ~(BLKSIZE - 1)) + BLKSIZE;
409: add(m, "\n");
410: after = FALSE;
411: break;
412: }
413:
414: /* insert the same text once or more */
415: for (reps = cnt, wasdot = doingdot; reps > 0; reps--, doingdot = TRUE)
416: {
417: m = input(m, m, WHEN_VIINP);
418: if (after)
419: {
420: m++;
421: }
422: }
423: if (after)
424: {
425: m--;
426: }
427:
428: doingdot = wasdot;
429: }
430:
431: #ifndef CRUNCH
432: # ifndef NO_EXTENSIONS
433: if (key == 'i' && *o_inputmode)
434: {
435: msg("Now in visual command mode! To return to input mode, hit <i>.");
436: }
437: # endif
438: #endif
439:
440: return m;
441: }
442:
443: /* This starts input mode with some text deleted */
444: MARK v_change(m, n)
445: MARK m, n; /* the range of text to change */
446: {
447: int lnmode; /* is this a line-mode change? */
448:
449: /* swap them if they're in reverse order */
450: if (m > n)
451: {
452: MARK tmp;
453: tmp = m;
454: m = n;
455: n = tmp;
456: }
457:
458: /* for line mode, retain the last newline char */
459: lnmode = (markidx(m) == 0 && markidx(n) == 0 && m != n);
460: if (lnmode)
461: {
462: n -= BLKSIZE;
463: pfetch(markline(n));
464: n = (n & ~(BLKSIZE - 1)) + plen;
465: }
466:
467: ChangeText
468: {
469: cut(m, n);
470: m = input(m, n, WHEN_VIINP);
471: }
472:
473: return m;
474: }
475:
476: /* This function replaces a given number of characters with input */
477: MARK v_subst(m, cnt)
478: MARK m; /* where substitutions start */
479: long cnt; /* number of chars to replace */
480: {
481: DEFAULT(1);
482:
483: /* make sure we don't try replacing past EOL */
484: pfetch(markline(m));
485: if (markidx(m) + cnt > plen)
486: {
487: cnt = plen - markidx(m);
488: }
489:
490: /* Go for it! */
491: ChangeText
492: {
493: cut(m, m + cnt);
494: m = input(m, m + cnt, WHEN_VIINP);
495: }
496: return m;
497: }
498:
499: /* This calls the ex "join" command to join some lines together */
500: MARK v_join(m, cnt)
501: MARK m; /* the first line to be joined */
502: long cnt; /* number of other lines to join */
503: {
504: MARK joint; /* where the lines were joined */
505:
506: DEFAULT(1);
507:
508: /* figure out where the joint will be */
509: pfetch(markline(m));
510: joint = (m & ~(BLKSIZE - 1)) + plen;
511:
512: /* join the lines */
513: cmd_join(m, m + MARK_AT_LINE(cnt), CMD_JOIN, 0, "");
514: mustredraw = TRUE;
515:
516: /* the cursor should be left at the joint */
517: return joint;
518: }
519:
520: /* This calls the ex shifter command to shift some lines */
521: static MARK shift_help(m, n, excmd)
522: MARK m, n; /* range of lines to shift */
523: CMD excmd; /* which way do we shift? */
524: {
525: /* adjust for inclusive endmarks in ex */
526: n -= BLKSIZE;
527:
528: cmd_shift(m, n, excmd, 0, "");
529: return m;
530: }
531:
532: /* This calls the ex "<" command to shift some lines left */
533: MARK v_lshift(m, n)
534: MARK m, n; /* range of lines to shift */
535: {
536: return shift_help(m, n, CMD_SHIFTL);
537: }
538:
539: /* This calls the ex ">" command to shift some lines right */
540: MARK v_rshift(m, n)
541: MARK m, n; /* range of lines to shift */
542: {
543: return shift_help(m, n, CMD_SHIFTR);
544: }
545:
546: /* This runs some lines through a filter program */
547: MARK v_filter(m, n)
548: MARK m, n; /* range of lines to shift */
549: {
550: char cmdln[100]; /* a shell command line */
551:
552: /* adjust for inclusive endmarks in ex */
553: n -= BLKSIZE;
554:
555: if (vgets('!', cmdln, sizeof(cmdln)) > 0)
556: {
557: filter(m, n, cmdln);
558: }
559:
560: redraw(MARK_UNSET, FALSE);
561: return m;
562: }
563:
564:
565: /* This function runs the ex "file" command to show the file's status */
566: MARK v_status()
567: {
568: cmd_file(cursor, cursor, CMD_FILE, 0, "");
569: return cursor;
570: }
571:
572:
573: /* This function runs the ":&" command to repeat the previous :s// */
574: MARK v_again(m, n)
575: MARK m, n;
576: {
577: cmd_substitute(m, n - BLKSIZE, CMD_SUBAGAIN, TRUE, "");
578: return cursor;
579: }
580:
581:
582:
583: /* This function switches to the previous file, if possible */
584: MARK v_switch()
585: {
586: if (!*prevorig)
587: msg("No previous file");
588: else
589: { strcpy(tmpblk.c, prevorig);
590: cmd_edit(cursor, cursor, CMD_EDIT, 0, tmpblk.c);
591: }
592: return cursor;
593: }
594:
595: /* This function does a tag search on a keyword */
596: /*ARGSUSED*/
597: MARK v_tag(keyword, m, cnt)
598: char *keyword;
599: MARK m;
600: long cnt;
601: {
602: /* move the cursor to the start of the tag name, where m is */
603: cursor = m;
604:
605: /* perform the tag search */
606: cmd_tag(cursor, cursor, CMD_TAG, 0, keyword);
607:
608: return cursor;
609: }
610:
611: #ifndef NO_EXTENSIONS
612: /* This function looks up a keyword by calling the helpprog program */
613: /*ARGSUSED*/
614: MARK v_keyword(keyword, m, cnt)
615: char *keyword;
616: MARK m;
617: long cnt;
618: {
619: int waswarn;
620: char cmdline[130];
621:
622: move(LINES - 1, 0);
623: addstr("---------------------------------------------------------\n");
624: clrtoeol();
625: refresh();
626: sprintf(cmdline, "%s %s", o_keywordprg, keyword);
627: waswarn = *o_warn;
628: *o_warn = FALSE;
629: suspend_curses();
630: if (system(cmdline))
631: {
632: addstr("<<< failed >>>\n");
633: }
634: resume_curses(FALSE);
635: mode = MODE_VI;
636: redraw(MARK_UNSET, FALSE);
637: *o_warn = waswarn;
638:
639: return m;
640: }
641:
642:
643:
644: MARK v_increment(keyword, m, cnt)
645: char *keyword;
646: MARK m;
647: long cnt;
648: {
649: static sign;
650: char newval[12];
651: long atol();
652:
653: DEFAULT(1);
654:
655: /* get one more keystroke, unless doingdot */
656: if (!doingdot)
657: {
658: sign = getkey(0);
659: }
660:
661: /* adjust the number, based on that second keystroke */
662: switch (sign)
663: {
664: case '+':
665: case '#':
666: cnt = atol(keyword) + cnt;
667: break;
668:
669: case '-':
670: cnt = atol(keyword) - cnt;
671: break;
672:
673: case '=':
674: break;
675:
676: default:
677: return MARK_UNSET;
678: }
679: sprintf(newval, "%ld", cnt);
680:
681: ChangeText
682: {
683: change(m, m + strlen(keyword), newval);
684: }
685:
686: return m;
687: }
688: #endif
689:
690:
691: /* This function acts like the EX command "xit" */
692: /*ARGSUSED*/
693: MARK v_xit(m, cnt, key)
694: MARK m; /* ignored */
695: long cnt; /* ignored */
696: int key; /* must be a second 'Z' */
697: {
698: /* if second char wasn't 'Z', fail */
699: if (key != 'Z')
700: {
701: return MARK_UNSET;
702: }
703:
704: /* move the cursor to the bottom of the screen */
705: move(LINES - 1, 0);
706: clrtoeol();
707:
708: /* do the xit command */
709: cmd_xit(m, m, CMD_XIT, FALSE, "");
710:
711: /* return the cursor */
712: return m;
713: }
714:
715:
716: /* This function undoes changes to a single line, if possible */
717: MARK v_undoline(m)
718: MARK m; /* where we hope to undo the change */
719: {
720: /* make sure we have the right line in the buffer */
721: if (markline(m) != U_line)
722: {
723: return MARK_UNSET;
724: }
725:
726: /* fix it */
727: ChangeText
728: {
729: strcat(U_text, "\n");
730: change(MARK_AT_LINE(U_line), MARK_AT_LINE(U_line + 1), U_text);
731: }
732:
733: /* nothing in the buffer anymore */
734: U_line = -1L;
735:
736: /* return, with the cursor at the front of the line */
737: return m & ~(BLKSIZE - 1);
738: }
739:
740:
741: #ifndef NO_ERRLIST
742: MARK v_errlist(m)
743: MARK m;
744: {
745: cmd_errlist(m, m, CMD_ERRLIST, FALSE, "");
746: return cursor;
747: }
748: #endif
749:
750:
751: #ifndef NO_AT
752: /*ARGSUSED*/
753: MARK v_at(m, cnt, key)
754: MARK m;
755: long cnt;
756: int key;
757: {
758: if (!fromcutbuf(key))
759: {
760: return MARK_UNSET;
761: }
762: return cursor;
763: }
764: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.