![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ex_vmain.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ucb / ex|
Return to ex_vmain.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ucb / ex |
1.1 root 1: /*
2: * Copyright (c) 1980 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: */
6:
7: #ifndef lint
8: static char *sccsid = "@(#)ex_vmain.c 7.7 (Berkeley) 6/7/85";
9: #endif not lint
10:
11: #include "ex.h"
12: #include "ex_tty.h"
13: #include "ex_vis.h"
14:
15: /*
16: * This is the main routine for visual.
17: * We here decode the count and possible named buffer specification
18: * preceding a command and interpret a few of the commands.
19: * Commands which involve a target (i.e. an operator) are decoded
20: * in the routine operate in ex_voperate.c.
21: */
22:
23: #define forbid(a) { if (a) goto fonfon; }
24:
25: vmain()
26: {
27: register int c, cnt, i;
28: char esave[TUBECOLS];
29: char *oglobp;
30: short d;
31: line *addr;
32: int ind, nlput;
33: int shouldpo = 0;
34: int onumber, olist, (*OPline)(), (*OPutchar)();
35:
36: vch_mac = VC_NOTINMAC;
37:
38: /*
39: * If we started as a vi command (on the command line)
40: * then go process initial commands (recover, next or tag).
41: */
42: if (initev) {
43: oglobp = globp;
44: globp = initev;
45: hadcnt = cnt = 0;
46: i = tchng;
47: addr = dot;
48: goto doinit;
49: }
50:
51: /*
52: * NB:
53: *
54: * The current line is always in the line buffer linebuf,
55: * and the cursor at the position cursor. You should do
56: * a vsave() before moving off the line to make sure the disk
57: * copy is updated if it has changed, and a getDOT() to get
58: * the line back if you mung linebuf. The motion
59: * routines in ex_vwind.c handle most of this.
60: */
61: for (;;) {
62: /*
63: * Decode a visual command.
64: * First sync the temp file if there has been a reasonable
65: * amount of change. Clear state for decoding of next
66: * command.
67: */
68: TSYNC();
69: vglobp = 0;
70: vreg = 0;
71: hold = 0;
72: seenprompt = 1;
73: wcursor = 0;
74: Xhadcnt = hadcnt = 0;
75: Xcnt = cnt = 1;
76: splitw = 0;
77: if (i = holdupd) {
78: if (state == VISUAL)
79: ignore(peekkey());
80: holdupd = 0;
81: /*
82: if (LINE(0) < ZERO) {
83: vclear();
84: vcnt = 0;
85: i = 3;
86: }
87: */
88: if (state != VISUAL) {
89: vcnt = 0;
90: vsave();
91: vrepaint(cursor);
92: } else if (i == 3)
93: vredraw(WTOP);
94: else
95: vsync(WTOP);
96: vfixcurs();
97: }
98:
99: /*
100: * Gobble up counts and named buffer specifications.
101: */
102: for (;;) {
103: looptop:
104: #ifdef MDEBUG
105: if (trace)
106: fprintf(trace, "pc=%c",peekkey());
107: #endif
108: if (isdigit(peekkey()) && peekkey() != '0') {
109: hadcnt = 1;
110: cnt = vgetcnt();
111: forbid (cnt <= 0);
112: }
113: if (peekkey() != '"')
114: break;
115: ignore(getkey()), c = getkey();
116: /*
117: * Buffer names be letters or digits.
118: * But not '0' as that is the source of
119: * an 'empty' named buffer spec in the routine
120: * kshift (see ex_temp.c).
121: */
122: forbid (c == '0' || !isalpha(c) && !isdigit(c));
123: vreg = c;
124: }
125: reread:
126: /*
127: * Come to reread from below after some macro expansions.
128: * The call to map allows use of function key pads
129: * by performing a terminal dependent mapping of inputs.
130: */
131: #ifdef MDEBUG
132: if (trace)
133: fprintf(trace,"pcb=%c,",peekkey());
134: #endif
135: op = getkey();
136: maphopcnt = 0;
137: do {
138: /*
139: * Keep mapping the char as long as it changes.
140: * This allows for double mappings, e.g., q to #,
141: * #1 to something else.
142: */
143: c = op;
144: op = map(c,arrows);
145: #ifdef MDEBUG
146: if (trace)
147: fprintf(trace,"pca=%c,",c);
148: #endif
149: /*
150: * Maybe the mapped to char is a count. If so, we have
151: * to go back to the "for" to interpret it. Likewise
152: * for a buffer name.
153: */
154: if ((isdigit(c) && c!='0') || c == '"') {
155: ungetkey(c);
156: goto looptop;
157: }
158: if (!value(REMAP)) {
159: c = op;
160: break;
161: }
162: if (++maphopcnt > 256)
163: error("Infinite macro loop");
164: } while (c != op);
165:
166: /*
167: * Begin to build an image of this command for possible
168: * later repeat in the buffer workcmd. It will be copied
169: * to lastcmd by the routine setLAST
170: * if/when completely specified.
171: */
172: lastcp = workcmd;
173: if (!vglobp)
174: *lastcp++ = c;
175:
176: /*
177: * First level command decode.
178: */
179: switch (c) {
180:
181: /*
182: * ^L Clear screen e.g. after transmission error.
183: */
184:
185: /*
186: * ^R Retype screen, getting rid of @ lines.
187: * If in open, equivalent to ^L.
188: * On terminals where the right arrow key sends
189: * ^L we make ^R act like ^L, since there is no
190: * way to get ^L. These terminals (adm31, tvi)
191: * are intelligent so ^R is useless. Soroc
192: * will probably foul this up, but nobody has
193: * one of them.
194: */
195: case CTRL(l):
196: case CTRL(r):
197: if (c == CTRL(l) || (KR && *KR==CTRL(l))) {
198: vclear();
199: vdirty(0, vcnt);
200: }
201: if (state != VISUAL) {
202: /*
203: * Get a clean line, throw away the
204: * memory of what is displayed now,
205: * and move back onto the current line.
206: */
207: vclean();
208: vcnt = 0;
209: vmoveto(dot, cursor, 0);
210: continue;
211: }
212: vredraw(WTOP);
213: /*
214: * Weird glitch -- when we enter visual
215: * in a very small window we may end up with
216: * no lines on the screen because the line
217: * at the top is too long. This forces the screen
218: * to be expanded to make room for it (after
219: * we have printed @'s ick showing we goofed).
220: */
221: if (vcnt == 0)
222: vrepaint(cursor);
223: vfixcurs();
224: continue;
225:
226: /*
227: * $ Escape just cancels the current command
228: * with a little feedback.
229: */
230: case ESCAPE:
231: beep();
232: continue;
233:
234: /*
235: * @ Macros. Bring in the macro and put it
236: * in vmacbuf, point vglobp there and punt.
237: */
238: case '@':
239: c = getesc();
240: if (c == 0)
241: continue;
242: if (c == '@')
243: c = lastmac;
244: if (isupper(c))
245: c = tolower(c);
246: forbid(!islower(c));
247: lastmac = c;
248: vsave();
249: CATCH
250: char tmpbuf[BUFSIZ];
251:
252: regbuf(c,tmpbuf,sizeof(vmacbuf));
253: macpush(tmpbuf, 1);
254: ONERR
255: lastmac = 0;
256: splitw = 0;
257: getDOT();
258: vrepaint(cursor);
259: continue;
260: ENDCATCH
261: vmacp = vmacbuf;
262: goto reread;
263:
264: /*
265: * . Repeat the last (modifying) open/visual command.
266: */
267: case '.':
268: /*
269: * Check that there was a last command, and
270: * take its count and named buffer unless they
271: * were given anew. Special case if last command
272: * referenced a numeric named buffer -- increment
273: * the number and go to a named buffer again.
274: * This allows a sequence like "1pu.u.u...
275: * to successively look for stuff in the kill chain
276: * much as one does in EMACS with C-Y and M-Y.
277: */
278: forbid (lastcmd[0] == 0);
279: if (hadcnt)
280: lastcnt = cnt;
281: if (vreg)
282: lastreg = vreg;
283: else if (isdigit(lastreg) && lastreg < '9')
284: lastreg++;
285: vreg = lastreg;
286: cnt = lastcnt;
287: hadcnt = lasthad;
288: vglobp = lastcmd;
289: goto reread;
290:
291: /*
292: * ^U Scroll up. A count sticks around for
293: * future scrolls as the scroll amount.
294: * Attempt to hold the indentation from the
295: * top of the screen (in logical lines).
296: *
297: * BUG: A ^U near the bottom of the screen
298: * on a dumb terminal (which can't roll back)
299: * causes the screen to be cleared and then
300: * redrawn almost as it was. In this case
301: * one should simply move the cursor.
302: */
303: case CTRL(u):
304: if (hadcnt)
305: vSCROLL = cnt;
306: cnt = vSCROLL;
307: if (state == VISUAL)
308: ind = vcline, cnt += ind;
309: else
310: ind = 0;
311: vmoving = 0;
312: vup(cnt, ind, 1);
313: vnline(NOSTR);
314: continue;
315:
316: /*
317: * ^D Scroll down. Like scroll up.
318: */
319: case CTRL(d):
320: #ifdef TRACE
321: if (trace)
322: fprintf(trace, "before vdown in ^D, dot=%d, wdot=%d, dol=%d\n", lineno(dot), lineno(wdot), lineno(dol));
323: #endif
324: if (hadcnt)
325: vSCROLL = cnt;
326: cnt = vSCROLL;
327: if (state == VISUAL)
328: ind = vcnt - vcline - 1, cnt += ind;
329: else
330: ind = 0;
331: vmoving = 0;
332: vdown(cnt, ind, 1);
333: #ifdef TRACE
334: if (trace)
335: fprintf(trace, "before vnline in ^D, dot=%d, wdot=%d, dol=%d\n", lineno(dot), lineno(wdot), lineno(dol));
336: #endif
337: vnline(NOSTR);
338: #ifdef TRACE
339: if (trace)
340: fprintf(trace, "after vnline in ^D, dot=%d, wdot=%d, dol=%d\n", lineno(dot), lineno(wdot), lineno(dol));
341: #endif
342: continue;
343:
344: /*
345: * ^E Glitch the screen down (one) line.
346: * Cursor left on same line in file.
347: */
348: case CTRL(e):
349: if (state != VISUAL)
350: continue;
351: if (!hadcnt)
352: cnt = 1;
353: /* Bottom line of file already on screen */
354: forbid(lineDOL()-lineDOT() <= vcnt-1-vcline);
355: ind = vcnt - vcline - 1 + cnt;
356: vdown(ind, ind, 1);
357: vnline(cursor);
358: continue;
359:
360: /*
361: * ^Y Like ^E but up
362: */
363: case CTRL(y):
364: if (state != VISUAL)
365: continue;
366: if (!hadcnt)
367: cnt = 1;
368: forbid(lineDOT()-1<=vcline); /* line 1 already there */
369: ind = vcline + cnt;
370: vup(ind, ind, 1);
371: vnline(cursor);
372: continue;
373:
374:
375: /*
376: * m Mark position in mark register given
377: * by following letter. Return is
378: * accomplished via ' or `; former
379: * to beginning of line where mark
380: * was set, latter to column where marked.
381: */
382: case 'm':
383: /*
384: * Getesc is generally used when a character
385: * is read as a latter part of a command
386: * to allow one to hit rubout/escape to cancel
387: * what you have typed so far. These characters
388: * are mapped to 0 by the subroutine.
389: */
390: c = getesc();
391: if (c == 0)
392: continue;
393:
394: /*
395: * Markreg checks that argument is a letter
396: * and also maps ' and ` to the end of the range
397: * to allow '' or `` to reference the previous
398: * context mark.
399: */
400: c = markreg(c);
401: forbid (c == 0);
402: vsave();
403: names[c - 'a'] = (*dot &~ 01);
404: ncols[c - 'a'] = cursor;
405: anymarks = 1;
406: continue;
407:
408: /*
409: * ^F Window forwards, with 2 lines of continuity.
410: * Count repeats.
411: */
412: case CTRL(f):
413: vsave();
414: if (vcnt > 2) {
415: addr = dot + (vcnt - vcline) - 2 + (cnt-1)*basWLINES;
416: forbid(addr > dol);
417: dot = addr;
418: vcnt = vcline = 0;
419: }
420: vzop(0, 0, '+');
421: continue;
422:
423: /*
424: * ^B Window backwards, with 2 lines of continuity.
425: * Inverse of ^F.
426: */
427: case CTRL(b):
428: vsave();
429: if (one + vcline != dot && vcnt > 2) {
430: addr = dot - vcline + 2 - (cnt-1)*basWLINES;
431: forbid (addr <= zero);
432: dot = addr;
433: vcnt = vcline = 0;
434: }
435: vzop(0, 0, '^');
436: continue;
437:
438: /*
439: * z Screen adjustment, taking a following character:
440: * z<CR> current line to top
441: * z<NL> like z<CR>
442: * z- current line to bottom
443: * also z+, z^ like ^F and ^B.
444: * A preceding count is line to use rather
445: * than current line. A count between z and
446: * specifier character changes the screen size
447: * for the redraw.
448: *
449: */
450: case 'z':
451: if (state == VISUAL) {
452: i = vgetcnt();
453: if (i > 0)
454: vsetsiz(i);
455: c = getesc();
456: if (c == 0)
457: continue;
458: }
459: vsave();
460: vzop(hadcnt, cnt, c);
461: continue;
462:
463: /*
464: * Y Yank lines, abbreviation for y_ or yy.
465: * Yanked lines can be put later if no
466: * changes intervene, or can be put in named
467: * buffers and put anytime in this session.
468: */
469: case 'Y':
470: ungetkey('_');
471: c = 'y';
472: break;
473:
474: /*
475: * J Join lines, 2 by default. Count is number
476: * of lines to join (no join operator sorry.)
477: */
478: case 'J':
479: forbid (dot == dol);
480: if (cnt == 1)
481: cnt = 2;
482: if (cnt > (i = dol - dot + 1))
483: cnt = i;
484: vsave();
485: vmacchng(1);
486: setLAST();
487: cursor = strend(linebuf);
488: vremote(cnt, join, 0);
489: notenam = "join";
490: vmoving = 0;
491: killU();
492: vreplace(vcline, cnt, 1);
493: if (!*cursor && cursor > linebuf)
494: cursor--;
495: if (notecnt == 2)
496: notecnt = 0;
497: vrepaint(cursor);
498: continue;
499:
500: /*
501: * S Substitute text for whole lines, abbrev for c_.
502: * Count is number of lines to change.
503: */
504: case 'S':
505: ungetkey('_');
506: c = 'c';
507: break;
508:
509: /*
510: * O Create a new line above current and accept new
511: * input text, to an escape, there.
512: * A count specifies, for dumb terminals when
513: * slowopen is not set, the number of physical
514: * line space to open on the screen.
515: *
516: * o Like O, but opens lines below.
517: */
518: case 'O':
519: case 'o':
520: vmacchng(1);
521: voOpen(c, cnt);
522: continue;
523:
524: /*
525: * C Change text to end of line, short for c$.
526: */
527: case 'C':
528: if (*cursor) {
529: ungetkey('$'), c = 'c';
530: break;
531: }
532: goto appnd;
533:
534: /*
535: * ~ Switch case of letter under cursor
536: */
537: case '~':
538: {
539: char mbuf[4];
540: setLAST();
541: mbuf[0] = 'r';
542: mbuf[1] = *cursor;
543: mbuf[2] = cursor[1]==0 ? 0 : ' ';
544: mbuf[3] = 0;
545: if (isalpha(mbuf[1]))
546: mbuf[1] ^= ' '; /* toggle the case */
547: macpush(mbuf, 1);
548: }
549: continue;
550:
551:
552: /*
553: * A Append at end of line, short for $a.
554: */
555: case 'A':
556: operate('$', 1);
557: appnd:
558: c = 'a';
559: /* fall into ... */
560:
561: /*
562: * a Appends text after cursor. Text can continue
563: * through arbitrary number of lines.
564: */
565: case 'a':
566: if (*cursor) {
567: if (state == HARDOPEN)
568: putchar(*cursor);
569: cursor++;
570: }
571: goto insrt;
572:
573: /*
574: * I Insert at beginning of whitespace of line,
575: * short for ^i.
576: */
577: case 'I':
578: operate('^', 1);
579: c = 'i';
580: /* fall into ... */
581:
582: /*
583: * R Replace characters, one for one, by input
584: * (logically), like repeated r commands.
585: *
586: * BUG: This is like the typeover mode of many other
587: * editors, and is only rarely useful. Its
588: * implementation is a hack in a low level
589: * routine and it doesn't work very well, e.g.
590: * you can't move around within a R, etc.
591: */
592: case 'R':
593: /* fall into... */
594:
595: /*
596: * i Insert text to an escape in the buffer.
597: * Text is arbitrary. This command reminds of
598: * the i command in bare teco.
599: */
600: case 'i':
601: insrt:
602: /*
603: * Common code for all the insertion commands.
604: * Save for redo, position cursor, prepare for append
605: * at command and in visual undo. Note that nothing
606: * is doomed, unless R when all is, and save the
607: * current line in a the undo temporary buffer.
608: */
609: vmacchng(1);
610: setLAST();
611: vcursat(cursor);
612: prepapp();
613: vnoapp();
614: doomed = c == 'R' ? 10000 : 0;
615: if(FIXUNDO)
616: vundkind = VCHNG;
617: vmoving = 0;
618: CP(vutmp, linebuf);
619:
620: /*
621: * If this is a repeated command, then suppress
622: * fake insert mode on dumb terminals which looks
623: * ridiculous and wastes lots of time even at 9600B.
624: */
625: if (vglobp)
626: hold = HOLDQIK;
627: vappend(c, cnt, 0);
628: continue;
629:
630: /*
631: * ^? An attention, normally a ^?, just beeps.
632: * If you are a vi command within ex, then
633: * two ATTN's will drop you back to command mode.
634: */
635: case ATTN:
636: beep();
637: if (initev || peekkey() != ATTN)
638: continue;
639: /* fall into... */
640:
641: /*
642: * ^\ A quit always gets command mode.
643: */
644: case QUIT:
645: /*
646: * Have to be careful if we were called
647: * g/xxx/vi
648: * since a return will just start up again.
649: * So we simulate an interrupt.
650: */
651: if (inglobal)
652: onintr();
653: /* fall into... */
654:
655: #ifdef notdef
656: /*
657: * q Quit back to command mode, unless called as
658: * vi on command line in which case dont do it
659: */
660: case 'q': /* quit */
661: if (initev) {
662: vsave();
663: CATCH
664: error("Q gets ex command mode, :q leaves vi");
665: ENDCATCH
666: splitw = 0;
667: getDOT();
668: vrepaint(cursor);
669: continue;
670: }
671: #endif
672: /* fall into... */
673:
674: /*
675: * Q Is like q, but always gets to command mode
676: * even if command line invocation was as vi.
677: */
678: case 'Q':
679: vsave();
680: /*
681: * If we are in the middle of a macro, throw away
682: * the rest and fix up undo.
683: * This code copied from getbr().
684: */
685: if (vmacp) {
686: vmacp = 0;
687: if (inopen == -1) /* don't screw up undo for esc esc */
688: vundkind = VMANY;
689: inopen = 1; /* restore old setting now that macro done */
690: }
691: return;
692:
693:
694: /*
695: * ZZ Like :x
696: */
697: case 'Z':
698: forbid(getkey() != 'Z');
699: oglobp = globp;
700: globp = "x";
701: vclrech(0);
702: goto gogo;
703:
704: /*
705: * P Put back text before cursor or before current
706: * line. If text was whole lines goes back
707: * as whole lines. If part of a single line
708: * or parts of whole lines splits up current
709: * line to form many new lines.
710: * May specify a named buffer, or the delete
711: * saving buffers 1-9.
712: *
713: * p Like P but after rather than before.
714: */
715: case 'P':
716: case 'p':
717: vmoving = 0;
718: #ifdef notdef
719: forbid (!vreg && value(UNDOMACRO) && inopen < 0);
720: #endif
721: /*
722: * If previous delete was partial line, use an
723: * append or insert to put it back so as to
724: * use insert mode on intelligent terminals.
725: */
726: if (!vreg && DEL[0]) {
727: forbid ((DEL[0] & (QUOTE|TRIM)) == OVERBUF);
728: vglobp = DEL;
729: ungetkey(c == 'p' ? 'a' : 'i');
730: goto reread;
731: }
732:
733: /*
734: * If a register wasn't specified, then make
735: * sure there is something to put back.
736: */
737: forbid (!vreg && unddol == dol);
738: /*
739: * If we just did a macro the whole buffer is in
740: * the undo save area. We don't want to put THAT.
741: */
742: forbid (vundkind == VMANY && undkind==UNDALL);
743: vsave();
744: vmacchng(1);
745: setLAST();
746: i = 0;
747: if (vreg && partreg(vreg) || !vreg && pkill[0]) {
748: /*
749: * Restoring multiple lines which were partial
750: * lines; will leave cursor in middle
751: * of line after shoving restored text in to
752: * split the current line.
753: */
754: i++;
755: if (c == 'p' && *cursor)
756: cursor++;
757: } else {
758: /*
759: * In whole line case, have to back up dot
760: * for P; also want to clear cursor so
761: * cursor will eventually be positioned
762: * at the beginning of the first put line.
763: */
764: cursor = 0;
765: if (c == 'P') {
766: dot--, vcline--;
767: c = 'p';
768: }
769: }
770: killU();
771:
772: /*
773: * The call to putreg can potentially
774: * bomb since there may be nothing in a named buffer.
775: * We thus put a catch in here. If we didn't and
776: * there was an error we would end up in command mode.
777: */
778: addr = dol; /* old dol */
779: CATCH
780: vremote(1, vreg ? putreg : put, vreg);
781: ONERR
782: if (vreg == -1) {
783: splitw = 0;
784: if (op == 'P')
785: dot++, vcline++;
786: goto pfixup;
787: }
788: ENDCATCH
789: splitw = 0;
790: nlput = dol - addr + 1;
791: if (!i) {
792: /*
793: * Increment undap1, undap2 to make up
794: * for their incorrect initialization in the
795: * routine vremote before calling put/putreg.
796: */
797: if (FIXUNDO)
798: undap1++, undap2++;
799: vcline++;
800: nlput--;
801:
802: /*
803: * After a put want current line first line,
804: * and dot was made the last line put in code
805: * run so far. This is why we increment vcline
806: * above and decrease dot here.
807: */
808: dot -= nlput - 1;
809: }
810: #ifdef TRACE
811: if (trace)
812: fprintf(trace, "vreplace(%d, %d, %d), undap1=%d, undap2=%d, dot=%d\n", vcline, i, nlput, lineno(undap1), lineno(undap2), lineno(dot));
813: #endif
814: vreplace(vcline, i, nlput);
815: if (state != VISUAL) {
816: /*
817: * Special case in open mode.
818: * Force action on the screen when a single
819: * line is put even if it is identical to
820: * the current line, e.g. on YP; otherwise
821: * you can't tell anything happened.
822: */
823: vjumpto(dot, cursor, '.');
824: continue;
825: }
826: pfixup:
827: vrepaint(cursor);
828: vfixcurs();
829: continue;
830:
831: /*
832: * ^^ Return to previous file.
833: * Like a :e #, and thus can be used after a
834: * "No Write" diagnostic.
835: */
836: case CTRL(^):
837: forbid (hadcnt);
838: vsave();
839: ckaw();
840: oglobp = globp;
841: if (value(AUTOWRITE))
842: globp = "e! #";
843: else
844: globp = "e #";
845: goto gogo;
846:
847: /*
848: * ^] Takes word after cursor as tag, and then does
849: * tag command. Read ``go right to''.
850: */
851: case CTRL(]):
852: grabtag();
853: oglobp = globp;
854: globp = "tag";
855: goto gogo;
856:
857: /*
858: * & Like :&
859: */
860: case '&':
861: oglobp = globp;
862: globp = "&";
863: goto gogo;
864:
865: /*
866: * ^G Bring up a status line at the bottom of
867: * the screen, like a :file command.
868: *
869: * BUG: Was ^S but doesn't work in cbreak mode
870: */
871: case CTRL(g):
872: oglobp = globp;
873: globp = "file";
874: gogo:
875: addr = dot;
876: vsave();
877: goto doinit;
878:
879: #ifdef SIGTSTP
880: /*
881: * ^Z: suspend editor session and temporarily return
882: * to shell. Only works with Berkeley/IIASA process
883: * control in kernel.
884: */
885: case CTRL(z):
886: forbid(dosusp == 0 || !ldisc);
887: vsave();
888: oglobp = globp;
889: globp = "stop";
890: goto gogo;
891: #endif
892:
893: /*
894: * : Read a command from the echo area and
895: * execute it in command mode.
896: */
897: case ':':
898: forbid (hadcnt);
899: vsave();
900: i = tchng;
901: addr = dot;
902: if (readecho(c)) {
903: esave[0] = 0;
904: goto fixup;
905: }
906: getDOT();
907: /*
908: * Use the visual undo buffer to store the global
909: * string for command mode, since it is idle right now.
910: */
911: oglobp = globp; strcpy(vutmp, genbuf+1); globp = vutmp;
912: doinit:
913: esave[0] = 0;
914: fixech();
915:
916: /*
917: * Have to finagle around not to lose last
918: * character after this command (when run from ex
919: * command mode). This is clumsy.
920: */
921: d = peekc; ungetchar(0);
922: if (shouldpo) {
923: /*
924: * So after a "Hit return..." ":", we do
925: * another "Hit return..." the next time
926: */
927: pofix();
928: shouldpo = 0;
929: }
930: CATCH
931: /*
932: * Save old values of options so we can
933: * notice when they change; switch into
934: * cooked mode so we are interruptible.
935: */
936: onumber = value(NUMBER);
937: olist = value(LIST);
938: OPline = Pline;
939: OPutchar = Putchar;
940: #ifndef CBREAK
941: vcook();
942: #endif
943: commands(1, 1);
944: if (dot == zero && dol > zero)
945: dot = one;
946: #ifndef CBREAK
947: vraw();
948: #endif
949: ONERR
950: #ifndef CBREAK
951: vraw();
952: #endif
953: copy(esave, vtube[WECHO], TUBECOLS);
954: ENDCATCH
955: fixol();
956: Pline = OPline;
957: Putchar = OPutchar;
958: ungetchar(d);
959: globp = oglobp;
960:
961: /*
962: * If we ended up with no lines in the buffer, make
963: * a line, and don't consider the buffer changed.
964: */
965: if (dot == zero) {
966: fixzero();
967: sync();
968: }
969: splitw = 0;
970:
971: /*
972: * Special case: did list/number options change?
973: */
974: if (onumber != value(NUMBER))
975: setnumb(value(NUMBER));
976: if (olist != value(LIST))
977: setlist(value(LIST));
978:
979: fixup:
980: /*
981: * If a change occurred, other than
982: * a write which clears changes, then
983: * we should allow an undo even if .
984: * didn't move.
985: *
986: * BUG: You can make this wrong by
987: * tricking around with multiple commands
988: * on one line of : escape, and including
989: * a write command there, but its not
990: * worth worrying about.
991: */
992: if (FIXUNDO && tchng && tchng != i)
993: vundkind = VMANY, cursor = 0;
994:
995: /*
996: * If we are about to do another :, hold off
997: * updating of screen.
998: */
999: if (vcnt < 0 && Peekkey == ':') {
1000: getDOT();
1001: shouldpo = 1;
1002: continue;
1003: }
1004: shouldpo = 0;
1005:
1006: /*
1007: * In the case where the file being edited is
1008: * new; e.g. if the initial state hasn't been
1009: * saved yet, then do so now.
1010: */
1011: if (unddol == truedol) {
1012: vundkind = VNONE;
1013: Vlines = lineDOL();
1014: if (!inglobal)
1015: savevis();
1016: addr = zero;
1017: vcnt = 0;
1018: if (esave[0] == 0)
1019: copy(esave, vtube[WECHO], TUBECOLS);
1020: }
1021:
1022: /*
1023: * If the current line moved reset the cursor position.
1024: */
1025: if (dot != addr) {
1026: vmoving = 0;
1027: cursor = 0;
1028: }
1029:
1030: /*
1031: * If current line is not on screen or if we are
1032: * in open mode and . moved, then redraw.
1033: */
1034: i = vcline + (dot - addr);
1035: if (i < 0 || i >= vcnt && i >= -vcnt || state != VISUAL && dot != addr) {
1036: if (state == CRTOPEN)
1037: vup1();
1038: if (vcnt > 0)
1039: vcnt = 0;
1040: vjumpto(dot, (char *) 0, '.');
1041: } else {
1042: /*
1043: * Current line IS on screen.
1044: * If we did a [Hit return...] then
1045: * restore vcnt and clear screen if in visual
1046: */
1047: vcline = i;
1048: if (vcnt < 0) {
1049: vcnt = -vcnt;
1050: if (state == VISUAL)
1051: vclear();
1052: else if (state == CRTOPEN) {
1053: vcnt = 0;
1054: }
1055: }
1056:
1057: /*
1058: * Limit max value of vcnt based on $
1059: */
1060: i = vcline + lineDOL() - lineDOT() + 1;
1061: if (i < vcnt)
1062: vcnt = i;
1063:
1064: /*
1065: * Dirty and repaint.
1066: */
1067: vdirty(0, LINES);
1068: vrepaint(cursor);
1069: }
1070:
1071: /*
1072: * If in visual, put back the echo area
1073: * if it was clobberred.
1074: */
1075: if (state == VISUAL) {
1076: int sdc = destcol, sdl = destline;
1077:
1078: splitw++;
1079: vigoto(WECHO, 0);
1080: for (i = 0; i < TUBECOLS - 1; i++) {
1081: if (esave[i] == 0)
1082: break;
1083: vputchar(esave[i]);
1084: }
1085: splitw = 0;
1086: vgoto(sdl, sdc);
1087: }
1088: continue;
1089:
1090: /*
1091: * u undo the last changing command.
1092: */
1093: case 'u':
1094: vundo(1);
1095: continue;
1096:
1097: /*
1098: * U restore current line to initial state.
1099: */
1100: case 'U':
1101: vUndo();
1102: continue;
1103:
1104: fonfon:
1105: beep();
1106: vmacp = 0;
1107: inopen = 1; /* might have been -1 */
1108: continue;
1109: }
1110:
1111: /*
1112: * Rest of commands are decoded by the operate
1113: * routine.
1114: */
1115: operate(c, cnt);
1116: }
1117: }
1118:
1119: /*
1120: * Grab the word after the cursor so we can look for it as a tag.
1121: */
1122: grabtag()
1123: {
1124: register char *cp, *dp;
1125:
1126: cp = vpastwh(cursor);
1127: if (*cp) {
1128: dp = lasttag;
1129: do {
1130: if (dp < &lasttag[sizeof lasttag - 2])
1131: *dp++ = *cp;
1132: cp++;
1133: } while (isalpha(*cp) || isdigit(*cp) || *cp == '_'
1134: #ifdef LISPCODE
1135: || (value(LISP) && *cp == '-')
1136: #endif LISPCODE
1137: );
1138: *dp++ = 0;
1139: }
1140: }
1141:
1142: /*
1143: * Before appending lines, set up addr1 and
1144: * the command mode undo information.
1145: */
1146: prepapp()
1147: {
1148:
1149: addr1 = dot;
1150: deletenone();
1151: addr1++;
1152: appendnone();
1153: }
1154:
1155: /*
1156: * Execute function f with the address bounds addr1
1157: * and addr2 surrounding cnt lines starting at dot.
1158: */
1159: vremote(cnt, f, arg)
1160: int cnt, (*f)(), arg;
1161: {
1162: register int oing = inglobal;
1163:
1164: addr1 = dot;
1165: addr2 = dot + cnt - 1;
1166: inglobal = 0;
1167: if (FIXUNDO)
1168: undap1 = undap2 = dot;
1169: (*f)(arg);
1170: inglobal = oing;
1171: if (FIXUNDO)
1172: vundkind = VMANY;
1173: vmcurs = 0;
1174: }
1175:
1176: /*
1177: * Save the current contents of linebuf, if it has changed.
1178: */
1179: vsave()
1180: {
1181: char temp[LBSIZE];
1182:
1183: CP(temp, linebuf);
1184: if (FIXUNDO && vundkind == VCHNG || vundkind == VCAPU) {
1185: /*
1186: * If the undo state is saved in the temporary buffer
1187: * vutmp, then we sync this into the temp file so that
1188: * we will be able to undo even after we have moved off
1189: * the line. It would be possible to associate a line
1190: * with vutmp but we assume that vutmp is only associated
1191: * with line dot (e.g. in case ':') above, so beware.
1192: */
1193: prepapp();
1194: strcLIN(vutmp);
1195: putmark(dot);
1196: vremote(1, yank, 0);
1197: vundkind = VMCHNG;
1198: notecnt = 0;
1199: undkind = UNDCHANGE;
1200: }
1201: /*
1202: * Get the line out of the temp file and do nothing if it hasn't
1203: * changed. This may seem like a loss, but the line will
1204: * almost always be in a read buffer so this may well avoid disk i/o.
1205: */
1206: getDOT();
1207: if (strcmp(linebuf, temp) == 0)
1208: return;
1209: strcLIN(temp);
1210: putmark(dot);
1211: }
1212:
1213: #undef forbid
1214: #define forbid(a) if (a) { beep(); return; }
1215:
1216: /*
1217: * Do a z operation.
1218: * Code here is rather long, and very uninteresting.
1219: */
1220: vzop(hadcnt, cnt, c)
1221: bool hadcnt;
1222: int cnt;
1223: register int c;
1224: {
1225: register line *addr;
1226:
1227: if (state != VISUAL) {
1228: /*
1229: * Z from open; always like a z=.
1230: * This code is a mess and should be cleaned up.
1231: */
1232: vmoveitup(1, 1);
1233: vgoto(outline, 0);
1234: ostop(normf);
1235: setoutt();
1236: addr2 = dot;
1237: vclear();
1238: destline = WECHO;
1239: zop2(Xhadcnt ? Xcnt : value(WINDOW) - 1, '=');
1240: if (state == CRTOPEN)
1241: putnl();
1242: putNFL();
1243: termreset();
1244: Outchar = vputchar;
1245: ignore(ostart());
1246: vcnt = 0;
1247: outline = destline = 0;
1248: vjumpto(dot, cursor, 0);
1249: return;
1250: }
1251: if (hadcnt) {
1252: addr = zero + cnt;
1253: if (addr < one)
1254: addr = one;
1255: if (addr > dol)
1256: addr = dol;
1257: markit(addr);
1258: } else
1259: switch (c) {
1260:
1261: case '+':
1262: addr = dot + vcnt - vcline;
1263: break;
1264:
1265: case '^':
1266: addr = dot - vcline - 1;
1267: forbid (addr < one);
1268: c = '-';
1269: break;
1270:
1271: default:
1272: addr = dot;
1273: break;
1274: }
1275: switch (c) {
1276:
1277: case '.':
1278: case '-':
1279: break;
1280:
1281: case '^':
1282: forbid (addr <= one);
1283: break;
1284:
1285: case '+':
1286: forbid (addr >= dol);
1287: /* fall into ... */
1288:
1289: case CR:
1290: case NL:
1291: c = CR;
1292: break;
1293:
1294: default:
1295: beep();
1296: return;
1297: }
1298: vmoving = 0;
1299: vjumpto(addr, NOSTR, c);
1300: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.