![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ex_vops2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 3BSD / cmd / ex|
Return to ex_vops2.c CVS log | Up to [CSRG BSD Unix] / 3BSD / cmd / ex |
1.1 root 1: /* Copyright (c) 1979 Regents of the University of California */
2: #include "ex.h"
3: #include "ex_tty.h"
4: #include "ex_vis.h"
5:
6: /*
7: * Low level routines for operations sequences,
8: * and mostly, insert mode (and a subroutine
9: * to read an input line, including in the echo area.)
10: */
11: char *vUA1, *vUA2;
12: char *vUD1, *vUD2;
13:
14: /*
15: * Obleeperate characters in hardcopy
16: * open with \'s.
17: */
18: bleep(i, cp)
19: register int i;
20: char *cp;
21: {
22:
23: i -= column(cp);
24: do
25: putchar('\\' | QUOTE);
26: while (--i >= 0);
27: rubble = 1;
28: }
29:
30: /*
31: * Common code for middle part of delete
32: * and change operating on parts of lines.
33: */
34: vdcMID()
35: {
36: register char *cp;
37:
38: squish();
39: setLAST();
40: vundkind = VCHNG, CP(vutmp, linebuf);
41: if (wcursor < cursor)
42: cp = wcursor, wcursor = cursor, cursor = cp;
43: vUD1 = vUA1 = vUA2 = cursor; vUD2 = wcursor;
44: return (column(wcursor - 1));
45: }
46:
47: /*
48: * Take text from linebuf and stick it
49: * in the VBSIZE buffer BUF. Used to save
50: * deleted text of part of line.
51: */
52: takeout(BUF)
53: char *BUF;
54: {
55: register char *cp;
56:
57: if (wcursor < linebuf)
58: wcursor = linebuf;
59: if (cursor == wcursor) {
60: beep();
61: return;
62: }
63: if (wcursor < cursor) {
64: cp = wcursor;
65: wcursor = cursor;
66: cursor = cp;
67: }
68: setBUF(BUF);
69: if ((BUF[0] & (QUOTE|TRIM)) == OVERBUF)
70: beep();
71: }
72:
73: /*
74: * Are we at the end of the printed representation of the
75: * line? Used internally in hardcopy open.
76: */
77: ateopr()
78: {
79: register int i, c;
80: register char *cp = vtube[destline] + destcol;
81:
82: for (i = WCOLS - destcol; i > 0; i--) {
83: c = *cp++;
84: if (c == 0)
85: return (1);
86: if (c != ' ' && (c & QUOTE) == 0)
87: return (0);
88: }
89: return (1);
90: }
91:
92: /*
93: * Append.
94: *
95: * This routine handles the top level append, doing work
96: * as each new line comes in, and arranging repeatability.
97: * It also handles append with repeat counts, and calculation
98: * of autoindents for new lines.
99: */
100: bool vaifirst;
101: bool gobbled;
102: char *ogcursor;
103:
104: vappend(ch, cnt, indent)
105: char ch;
106: int cnt, indent;
107: {
108: register int i;
109: register char *gcursor;
110: bool escape;
111: int repcnt;
112: short oldhold = hold;
113:
114: /*
115: * Before a move in hardopen when the line is dirty
116: * or we are in the middle of the printed representation,
117: * we retype the line to the left of the cursor so the
118: * insert looks clean.
119: */
120: if (ch != 'o' && state == HARDOPEN && (rubble || !ateopr())) {
121: rubble = 1;
122: gcursor = cursor;
123: i = *gcursor;
124: *gcursor = ' ';
125: wcursor = gcursor;
126: vmove();
127: *gcursor = i;
128: }
129: vaifirst = indent == 0;
130:
131: /*
132: * Handle replace character by (eventually)
133: * limiting the number of input characters allowed
134: * in the vgetline routine.
135: */
136: if (ch == 'r')
137: repcnt = 2;
138: else
139: repcnt = 0;
140:
141: /*
142: * If an autoindent is specified, then
143: * generate a mixture of blanks to tabs to implement
144: * it and place the cursor after the indent.
145: * Text read by the vgetline routine will be placed in genbuf,
146: * so the indent is generated there.
147: */
148: if (value(AUTOINDENT) && indent != 0) {
149: gcursor = genindent(indent);
150: *gcursor = 0;
151: vgotoCL(qcolumn(cursor - 1, genbuf));
152: } else {
153: gcursor = genbuf;
154: *gcursor = 0;
155: if (ch == 'o')
156: vfixcurs();
157: }
158:
159: /*
160: * Prepare for undo. Pointers delimit inserted portion of line.
161: */
162: vUA1 = vUA2 = cursor;
163:
164: /*
165: * If we are not in a repeated command and a ^@ comes in
166: * then this means the previous inserted text.
167: * If there is none or it was too long to be saved,
168: * then beep() and also arrange to undo any damage done
169: * so far (e.g. if we are a change.)
170: */
171: if ((vglobp && *vglobp == 0) || peekbr()) {
172: if ((INS[0] & (QUOTE|TRIM)) == OVERBUF) {
173: beep();
174: if (!splitw)
175: ungetkey('u');
176: doomed = 0;
177: hold = oldhold;
178: return;
179: }
180: /*
181: * Unread input from INS.
182: * An escape will be generated at end of string.
183: * Hold off n^^2 type update on dumb terminals.
184: */
185: vglobp = INS;
186: hold |= HOLDQIK;
187: } else if (vglobp == 0)
188: /*
189: * Not a repeated command, get
190: * a new inserted text for repeat.
191: */
192: INS[0] = 0;
193:
194: /*
195: * For wrapmargin to hack away second space after a '.'
196: * when the first space caused a line break we keep
197: * track that this happened in gobblebl, which says
198: * to gobble up a blank silently.
199: */
200: gobblebl = 0;
201:
202: /*
203: * Text gathering loop.
204: * New text goes into genbuf starting at gcursor.
205: * cursor preserves place in linebuf where text will eventually go.
206: */
207: if (*cursor == 0 || state == CRTOPEN)
208: hold |= HOLDROL;
209: for (;;) {
210: if (ch == 'r' && repcnt == 0)
211: escape = 0;
212: else {
213: gcursor = vgetline(repcnt, gcursor, &escape);
214:
215: /*
216: * After an append, stick information
217: * about the ^D's and ^^D's and 0^D's in
218: * the repeated text buffer so repeated
219: * inserts of stuff indented with ^D as backtab's
220: * can work.
221: */
222: if (HADUP)
223: addtext("^");
224: else if (HADZERO)
225: addtext("0");
226: while (CDCNT > 0)
227: addtext("\204"), CDCNT--;
228: if (gobbled)
229: addtext(" ");
230: addtext(ogcursor);
231: }
232: repcnt = 0;
233:
234: /*
235: * Smash the generated and preexisting indents together
236: * and generate one cleanly made out of tabs and spaces
237: * if we are using autoindent.
238: */
239: if (!vaifirst && value(AUTOINDENT)) {
240: i = fixindent(indent);
241: if (!HADUP)
242: indent = i;
243: gcursor = strend(genbuf);
244: }
245:
246: /*
247: * Limit the repetition count based on maximum
248: * possible line length; do output implied
249: * by further count (> 1) and cons up the new line
250: * in linebuf.
251: */
252: cnt = vmaxrep(ch, cnt);
253: CP(gcursor + 1, cursor);
254: do {
255: CP(cursor, genbuf);
256: if (cnt > 1) {
257: int oldhold = hold;
258:
259: Outchar = vinschar;
260: hold |= HOLDQIK;
261: printf("%s", genbuf);
262: hold = oldhold;
263: Outchar = vputchar;
264: }
265: cursor += gcursor - genbuf;
266: } while (--cnt > 0);
267: endim();
268: vUA2 = cursor;
269: if (escape != '\n')
270: CP(cursor, gcursor + 1);
271:
272: /*
273: * If doomed characters remain, clobber them,
274: * and reopen the line to get the display exact.
275: */
276: if (state != HARDOPEN) {
277: DEPTH(vcline) = 0;
278: if (doomed > 0) {
279: register int cind = cindent();
280:
281: physdc(cind, cind + doomed);
282: doomed = 0;
283: }
284: i = vreopen(LINE(vcline), lineDOT(), vcline);
285: }
286:
287: /*
288: * All done unless we are continuing on to another line.
289: */
290: if (escape != '\n')
291: break;
292:
293: /*
294: * Set up for the new line.
295: * First save the current line, then construct a new
296: * first image for the continuation line consisting
297: * of any new autoindent plus the pushed ahead text.
298: */
299: killU();
300: addtext(gobblebl ? " " : "\n");
301: vsave();
302: cnt = 1;
303: if (value(AUTOINDENT)) {
304: #ifdef LISPCODE
305: if (value(LISP))
306: indent = lindent(dot + 1);
307: else
308: #endif
309: if (!HADUP && vaifirst)
310: indent = whitecnt(linebuf);
311: vaifirst = 0;
312: strcLIN(vpastwh(gcursor + 1));
313: gcursor = genindent(indent);
314: *gcursor = 0;
315: if (gcursor + strlen(linebuf) > &genbuf[LBSIZE - 2])
316: gcursor = genbuf;
317: CP(gcursor, linebuf);
318: } else {
319: CP(genbuf, gcursor + 1);
320: gcursor = genbuf;
321: }
322:
323: /*
324: * If we started out as a single line operation and are now
325: * turning into a multi-line change, then we had better yank
326: * out dot before it changes so that undo will work
327: * correctly later.
328: */
329: if (vundkind == VCHNG) {
330: vremote(1, yank, 0);
331: undap1--;
332: }
333:
334: /*
335: * Now do the append of the new line in the buffer,
336: * and update the display. If slowopen
337: * we don't do very much.
338: */
339: vdoappend(genbuf);
340: vundkind = VMANYINS;
341: vcline++;
342: if (state != VISUAL)
343: vshow(dot, NOLINE);
344: else {
345: i += LINE(vcline - 1);
346: vopen(dot, i);
347: if (value(SLOWOPEN))
348: vscrap();
349: else
350: vsync1(LINE(vcline));
351: }
352: strcLIN(gcursor);
353: *gcursor = 0;
354: cursor = linebuf;
355: vgotoCL(qcolumn(cursor - 1, genbuf));
356: }
357:
358: /*
359: * All done with insertion, position the cursor
360: * and sync the screen.
361: */
362: hold = oldhold;
363: if (cursor > linebuf)
364: cursor--;
365: if (state != HARDOPEN)
366: vsyncCL();
367: else if (cursor > linebuf)
368: back1();
369: doomed = 0;
370: wcursor = cursor;
371: vmove();
372: }
373:
374: /*
375: * Subroutine for vgetline to back up a single character position,
376: * backwards around end of lines (vgoto can't hack columns which are
377: * less than 0 in general).
378: */
379: back1()
380: {
381:
382: vgoto(destline - 1, WCOLS + destcol - 1);
383: }
384:
385: /*
386: * Get a line into genbuf after gcursor.
387: * Cnt limits the number of input characters
388: * accepted and is used for handling the replace
389: * single character command. Aescaped is the location
390: * where we stick a termination indicator (whether we
391: * ended with an ESCAPE or a newline/return.
392: *
393: * We do erase-kill type processing here and also
394: * are careful about the way we do this so that it is
395: * repeatable. (I.e. so that your kill doesn't happen,
396: * when you repeat an insert if it was escaped with \ the
397: * first time you did it.
398: */
399: char *
400: vgetline(cnt, gcursor, aescaped)
401: int cnt;
402: register char *gcursor;
403: bool *aescaped;
404: {
405: register int c, ch;
406: register char *cp;
407: int x, y, iwhite;
408: char *iglobp;
409: int (*OO)() = Outchar;
410:
411: /*
412: * Clear the output state and counters
413: * for autoindent backwards motion (counts of ^D, etc.)
414: * Remember how much white space at beginning of line so
415: * as not to allow backspace over autoindent.
416: */
417: *aescaped = 0;
418: ogcursor = gcursor;
419: flusho();
420: CDCNT = 0;
421: HADUP = 0;
422: HADZERO = 0;
423: gobbled = 0;
424: iwhite = whitecnt(genbuf);
425: iglobp = vglobp;
426:
427: /*
428: * Carefully avoid using vinschar in the echo area.
429: */
430: if (splitw)
431: Outchar = vputchar;
432: else {
433: Outchar = vinschar;
434: vprepins();
435: }
436: for (;;) {
437: if (gobblebl)
438: gobblebl--;
439: if (cnt != 0) {
440: cnt--;
441: if (cnt == 0)
442: goto vadone;
443: }
444: ch = c = getkey() & (QUOTE|TRIM);
445: if (value(MAPINPUT))
446: while ((ch = map(c, arrows)) != c)
447: c = ch;
448: if (!iglobp) {
449:
450: /*
451: * Erase-kill type processing.
452: * Only happens if we were not reading
453: * from untyped input when we started.
454: * Map users erase to ^H, kill to -1 for switch.
455: */
456: if (c == tty.sg_erase)
457: c = CTRL(h);
458: else if (c == tty.sg_kill)
459: c = -1;
460: switch (c) {
461:
462: /*
463: * ^? Interrupt drops you back to visual
464: * command mode with an unread interrupt
465: * still in the input buffer.
466: *
467: * ^\ Quit does the same as interrupt.
468: * If you are a ex command rather than
469: * a vi command this will drop you
470: * back to command mode for sure.
471: */
472: case ATTN:
473: case QUIT:
474: ungetkey(c);
475: goto vadone;
476:
477: /*
478: * ^H Backs up a character in the input.
479: *
480: * BUG: Can't back around line boundaries.
481: * This is hard because stuff has
482: * already been saved for repeat.
483: */
484: case CTRL(h):
485: bakchar:
486: cp = gcursor - 1;
487: if (cp < ogcursor) {
488: if (splitw) {
489: /*
490: * Backspacing over readecho
491: * prompt. Pretend delete but
492: * don't beep.
493: */
494: ungetkey(c);
495: goto vadone;
496: }
497: beep();
498: continue;
499: }
500: goto vbackup;
501:
502: /*
503: * ^W Back up a white/non-white word.
504: */
505: case CTRL(w):
506: wdkind = 1;
507: for (cp = gcursor; cp > ogcursor && isspace(cp[-1]); cp--)
508: continue;
509: for (c = wordch(cp - 1);
510: cp > ogcursor && wordof(c, cp - 1); cp--)
511: continue;
512: goto vbackup;
513:
514: /*
515: * users kill Kill input on this line, back to
516: * the autoindent.
517: */
518: case -1:
519: cp = ogcursor;
520: vbackup:
521: if (cp == gcursor) {
522: beep();
523: continue;
524: }
525: endim();
526: *cp = 0;
527: c = cindent();
528: vgotoCL(qcolumn(cursor - 1, genbuf));
529: if (doomed >= 0)
530: doomed += c - cindent();
531: gcursor = cp;
532: continue;
533:
534: /*
535: * \ Followed by erase or kill
536: * maps to just the erase or kill.
537: */
538: case '\\':
539: x = destcol, y = destline;
540: putchar('\\');
541: vcsync();
542: c = getkey();
543: if (c == tty.sg_erase || c == tty.sg_kill) {
544: vgoto(y, x);
545: if (doomed >= 0)
546: doomed++;
547: goto def;
548: }
549: ungetkey(c), c = '\\';
550: goto noput;
551:
552: /*
553: * ^Q Super quote following character
554: * Only ^@ is verboten (trapped at
555: * a lower level) and \n forces a line
556: * split so doesn't really go in.
557: *
558: * ^V Synonym for ^Q
559: */
560: case CTRL(q):
561: case CTRL(v):
562: x = destcol, y = destline;
563: putchar('^');
564: vgoto(y, x);
565: c = getkey();
566: #ifdef TIOCSETC
567: if (c == ATTN)
568: c = nttyc.t_intrc;
569: #endif
570: if (c != NL) {
571: if (doomed >= 0)
572: doomed++;
573: goto def;
574: }
575: break;
576: }
577: }
578:
579: /*
580: * If we get a blank not in the echo area
581: * consider splitting the window in the wrapmargin.
582: */
583: if (c == ' ' && !splitw) {
584: if (gobblebl) {
585: gobbled = 1;
586: continue;
587: }
588: if (value(WRAPMARGIN) && outcol >= OCOLUMNS - value(WRAPMARGIN)) {
589: c = NL;
590: gobblebl = 2;
591: }
592: }
593: switch (c) {
594:
595: /*
596: * ^M Except in repeat maps to \n.
597: */
598: case CR:
599: if (vglobp)
600: goto def;
601: c = '\n';
602: /* presto chango ... */
603:
604: /*
605: * \n Start new line.
606: */
607: case NL:
608: *aescaped = c;
609: goto vadone;
610:
611: /*
612: * escape End insert unless repeat and more to repeat.
613: */
614: case ESCAPE:
615: if (lastvgk)
616: goto def;
617: goto vadone;
618:
619: /*
620: * ^D Backtab.
621: * ^T Software forward tab.
622: *
623: * Unless in repeat where this means these
624: * were superquoted in.
625: */
626: case CTRL(d):
627: case CTRL(t):
628: if (vglobp)
629: goto def;
630: /* fall into ... */
631:
632: /*
633: * ^D|QUOTE Is a backtab (in a repeated command).
634: */
635: case CTRL(d) | QUOTE:
636: *gcursor = 0;
637: cp = vpastwh(genbuf);
638: c = whitecnt(genbuf);
639: if (ch == CTRL(t)) {
640: /*
641: * ^t just generates new indent replacing
642: * current white space rounded up to soft
643: * tab stop increment.
644: */
645: if (cp != gcursor)
646: /*
647: * BUG: Don't hack ^T except
648: * right after initial
649: * white space.
650: */
651: continue;
652: cp = genindent(iwhite = backtab(c + value(SHIFTWIDTH) + 1));
653: ogcursor = cp;
654: goto vbackup;
655: }
656: /*
657: * ^D works only if we are at the (end of) the
658: * generated autoindent. We count the ^D for repeat
659: * purposes.
660: */
661: if (c == iwhite && c != 0)
662: if (cp == gcursor) {
663: iwhite = backtab(c);
664: CDCNT++;
665: ogcursor = cp = genindent(iwhite);
666: goto vbackup;
667: } else if (&cp[1] == gcursor &&
668: (*cp == '^' || *cp == '0')) {
669: /*
670: * ^^D moves to margin, then back
671: * to current indent on next line.
672: *
673: * 0^D moves to margin and then
674: * stays there.
675: */
676: HADZERO = *cp == '0';
677: ogcursor = cp = genbuf;
678: HADUP = 1 - HADZERO;
679: CDCNT = 1;
680: endim();
681: back1();
682: vputc(' ');
683: goto vbackup;
684: }
685: if (vglobp && vglobp - iglobp >= 2 &&
686: (vglobp[-2] == '^' || vglobp[-2] == '0')
687: && gcursor == ogcursor + 1)
688: goto bakchar;
689: continue;
690:
691: default:
692: /*
693: * Possibly discard control inputs.
694: */
695: if (!vglobp && junk(c)) {
696: beep();
697: continue;
698: }
699: def:
700: putchar(c);
701: noput:
702: if (gcursor > &genbuf[LBSIZE - 2])
703: error("Line too long");
704: *gcursor++ = c & TRIM;
705: vcsync();
706: #ifdef LISPCODE
707: if (value(SHOWMATCH) && !iglobp)
708: if (c == ')' || c == '}')
709: lsmatch(gcursor);
710: #endif
711: continue;
712: }
713: }
714: vadone:
715: *gcursor = 0;
716: Outchar = OO;
717: endim();
718: return (gcursor);
719: }
720:
721: int vgetsplit();
722: char *vsplitpt;
723:
724: /*
725: * Append the line in buffer at lp
726: * to the buffer after dot.
727: */
728: vdoappend(lp)
729: char *lp;
730: {
731: register int oing = inglobal;
732:
733: vsplitpt = lp;
734: inglobal = 1;
735: ignore(append(vgetsplit, dot));
736: inglobal = oing;
737: }
738:
739: /*
740: * Subroutine for vdoappend to pass to append.
741: */
742: vgetsplit()
743: {
744:
745: if (vsplitpt == 0)
746: return (EOF);
747: strcLIN(vsplitpt);
748: vsplitpt = 0;
749: return (0);
750: }
751:
752: /*
753: * Vmaxrep determines the maximum repetitition factor
754: * allowed that will yield total line length less than
755: * LBSIZE characters and also does hacks for the R command.
756: */
757: vmaxrep(ch, cnt)
758: char ch;
759: register int cnt;
760: {
761: register int len, replen;
762:
763: if (cnt > LBSIZE - 2)
764: cnt = LBSIZE - 2;
765: replen = strlen(genbuf);
766: if (ch == 'R') {
767: len = strlen(cursor);
768: if (replen < len)
769: len = replen;
770: CP(cursor, cursor + len);
771: vUD2 += len;
772: }
773: len = strlen(linebuf);
774: if (len + cnt * replen <= LBSIZE - 2)
775: return (cnt);
776: cnt = (LBSIZE - 2 - len) / replen;
777: if (cnt == 0) {
778: vsave();
779: error("Line too long");
780: }
781: return (cnt);
782: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.