![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ex_cmdsub.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / ucb / ex|
Return to ex_cmdsub.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / 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_cmdsub.c 7.9 (Berkeley) 1/2/88";
9: #endif not lint
10:
11: #include "ex.h"
12: #include "ex_argv.h"
13: #include "ex_temp.h"
14: #include "ex_tty.h"
15: #include "ex_vis.h"
16:
17: /*
18: * Command mode subroutines implementing
19: * append, args, copy, delete, join, move, put,
20: * shift, tag, yank, z and undo
21: */
22:
23: bool endline = 1;
24: line *tad1;
25: static jnoop();
26:
27: /*
28: * Append after line a lines returned by function f.
29: * Be careful about intermediate states to avoid scramble
30: * if an interrupt comes in.
31: */
32: append(f, a)
33: int (*f)();
34: line *a;
35: {
36: register line *a1, *a2, *rdot;
37: int nline;
38:
39: nline = 0;
40: dot = a;
41: if(FIXUNDO && !inopen && f!=getsub) {
42: undap1 = undap2 = dot + 1;
43: undkind = UNDCHANGE;
44: }
45: while ((*f)() == 0) {
46: if (truedol >= endcore) {
47: if (morelines() < 0) {
48: if (FIXUNDO && f == getsub) {
49: undap1 = addr1;
50: undap2 = addr2 + 1;
51: }
52: error("Out of memory@- too many lines in file");
53: }
54: }
55: nline++;
56: a1 = truedol + 1;
57: a2 = a1 + 1;
58: dot++;
59: undap2++;
60: dol++;
61: unddol++;
62: truedol++;
63: for (rdot = dot; a1 > rdot;)
64: *--a2 = *--a1;
65: *rdot = 0;
66: putmark(rdot);
67: if (f == gettty) {
68: dirtcnt++;
69: TSYNC();
70: }
71: }
72: return (nline);
73: }
74:
75: appendnone()
76: {
77:
78: if(FIXUNDO) {
79: undkind = UNDCHANGE;
80: undap1 = undap2 = addr1;
81: }
82: }
83:
84: /*
85: * Print out the argument list, with []'s around the current name.
86: */
87: pargs()
88: {
89: register char **av = argv0, *as = args0;
90: register int ac;
91:
92: for (ac = 0; ac < argc0; ac++) {
93: if (ac != 0)
94: ex_putchar(' ' | QUOTE);
95: if (ac + argc == argc0 - 1)
96: ex_printf("[");
97: lprintf("%s", as);
98: if (ac + argc == argc0 - 1)
99: ex_printf("]");
100: as = av ? *++av : strend(as) + 1;
101: }
102: noonl();
103: }
104:
105: /*
106: * Delete lines; two cases are if we are really deleting,
107: * more commonly we are just moving lines to the undo save area.
108: */
109: ex_delete(hush)
110: bool hush;
111: {
112: register line *a1, *a2;
113:
114: nonzero();
115: if(FIXUNDO) {
116: register int (*dsavint)();
117:
118: #ifdef TRACE
119: if (trace)
120: vudump("before delete");
121: #endif
122: change();
123: dsavint = signal(SIGINT, SIG_IGN);
124: undkind = UNDCHANGE;
125: a1 = addr1;
126: squish();
127: a2 = addr2;
128: if (a2++ != dol) {
129: reverse(a1, a2);
130: reverse(a2, dol + 1);
131: reverse(a1, dol + 1);
132: }
133: dol -= a2 - a1;
134: unddel = a1 - 1;
135: if (a1 > dol)
136: a1 = dol;
137: dot = a1;
138: pkill[0] = pkill[1] = 0;
139: signal(SIGINT, dsavint);
140: #ifdef TRACE
141: if (trace)
142: vudump("after delete");
143: #endif
144: } else {
145: register line *a3;
146: register int i;
147:
148: change();
149: a1 = addr1;
150: a2 = addr2 + 1;
151: a3 = truedol;
152: i = a2 - a1;
153: unddol -= i;
154: undap2 -= i;
155: dol -= i;
156: truedol -= i;
157: do
158: *a1++ = *a2++;
159: while (a2 <= a3);
160: a1 = addr1;
161: if (a1 > dol)
162: a1 = dol;
163: dot = a1;
164: }
165: if (!hush)
166: killed();
167: }
168:
169: deletenone()
170: {
171:
172: if(FIXUNDO) {
173: undkind = UNDCHANGE;
174: squish();
175: unddel = addr1;
176: }
177: }
178:
179: /*
180: * Crush out the undo save area, moving the open/visual
181: * save area down in its place.
182: */
183: squish()
184: {
185: register line *a1 = dol + 1, *a2 = unddol + 1, *a3 = truedol + 1;
186:
187: if(FIXUNDO) {
188: if (inopen == -1)
189: return;
190: if (a1 < a2 && a2 < a3)
191: do
192: *a1++ = *a2++;
193: while (a2 < a3);
194: truedol -= unddol - dol;
195: unddol = dol;
196: }
197: }
198:
199: /*
200: * Join lines. Special hacks put in spaces, two spaces if
201: * preceding line ends with '.', or no spaces if next line starts with ).
202: */
203: static int jcount, jnoop();
204:
205: join(c)
206: int c;
207: {
208: register line *a1;
209: register char *cp, *cp1;
210:
211: cp = genbuf;
212: *cp = 0;
213: for (a1 = addr1; a1 <= addr2; a1++) {
214: getline(*a1);
215: cp1 = linebuf;
216: if (a1 != addr1 && c == 0) {
217: while (*cp1 == ' ' || *cp1 == '\t')
218: cp1++;
219: if (*cp1 && cp > genbuf && cp[-1] != ' ' && cp[-1] != '\t') {
220: if (*cp1 != ')') {
221: *cp++ = ' ';
222: if (cp[-2] == '.')
223: *cp++ = ' ';
224: }
225: }
226: }
227: while (*cp++ = *cp1++)
228: if (cp > &genbuf[LBSIZE-2])
229: error("Line overflow|Result line of join would be too long");
230: cp--;
231: }
232: strcLIN(genbuf);
233: ex_delete(0);
234: jcount = 1;
235: if (FIXUNDO)
236: undap1 = undap2 = addr1;
237: ignore(append(jnoop, --addr1));
238: if (FIXUNDO)
239: vundkind = VMANY;
240: }
241:
242: static
243: jnoop()
244: {
245:
246: return(--jcount);
247: }
248:
249: /*
250: * Move and copy lines. Hard work is done by move1 which
251: * is also called by undo.
252: */
253: int getcopy();
254:
255: move()
256: {
257: register line *adt;
258: bool iscopy = 0;
259:
260: if (Command[0] == 'm') {
261: setdot1();
262: markpr(addr2 == dot ? addr1 - 1 : addr2 + 1);
263: } else {
264: iscopy++;
265: setdot();
266: }
267: nonzero();
268: adt = address((char*)0);
269: if (adt == 0)
270: serror("%s where?|%s requires a trailing address", Command);
271: newline();
272: move1(iscopy, adt);
273: killed();
274: }
275:
276: move1(cflag, addrt)
277: int cflag;
278: line *addrt;
279: {
280: register line *adt, *ad1, *ad2;
281: int lines;
282:
283: adt = addrt;
284: lines = (addr2 - addr1) + 1;
285: if (cflag) {
286: tad1 = addr1;
287: ad1 = dol;
288: ignore(append(getcopy, ad1++));
289: ad2 = dol;
290: } else {
291: ad2 = addr2;
292: for (ad1 = addr1; ad1 <= ad2;)
293: *ad1++ &= ~01;
294: ad1 = addr1;
295: }
296: ad2++;
297: if (adt < ad1) {
298: if (adt + 1 == ad1 && !cflag && !inglobal)
299: error("That move would do nothing!");
300: dot = adt + (ad2 - ad1);
301: if (++adt != ad1) {
302: reverse(adt, ad1);
303: reverse(ad1, ad2);
304: reverse(adt, ad2);
305: }
306: } else if (adt >= ad2) {
307: dot = adt++;
308: reverse(ad1, ad2);
309: reverse(ad2, adt);
310: reverse(ad1, adt);
311: } else
312: error("Move to a moved line");
313: change();
314: if (!inglobal)
315: if(FIXUNDO) {
316: if (cflag) {
317: undap1 = addrt + 1;
318: undap2 = undap1 + lines;
319: deletenone();
320: } else {
321: undkind = UNDMOVE;
322: undap1 = addr1;
323: undap2 = addr2;
324: unddel = addrt;
325: squish();
326: }
327: }
328: }
329:
330: getcopy()
331: {
332:
333: if (tad1 > addr2)
334: return (EOF);
335: getline(*tad1++);
336: return (0);
337: }
338:
339: /*
340: * Put lines in the buffer from the undo save area.
341: */
342: getput()
343: {
344:
345: if (tad1 > unddol)
346: return (EOF);
347: getline(*tad1++);
348: tad1++;
349: return (0);
350: }
351:
352: put()
353: {
354: register int cnt;
355:
356: if (!FIXUNDO)
357: error("Cannot put inside global/macro");
358: cnt = unddol - dol;
359: if (cnt && inopen && pkill[0] && pkill[1]) {
360: pragged(1);
361: return;
362: }
363: tad1 = dol + 1;
364: ignore(append(getput, addr2));
365: undkind = UNDPUT;
366: notecnt = cnt;
367: netchange(cnt);
368: }
369:
370: /*
371: * A tricky put, of a group of lines in the middle
372: * of an existing line. Only from open/visual.
373: * Argument says pkills have meaning, e.g. called from
374: * put; it is 0 on calls from putreg.
375: */
376: pragged(kill)
377: bool kill;
378: {
379: extern char *cursor;
380: register char *gp = &genbuf[cursor - linebuf];
381:
382: /*
383: * This kind of stuff is TECO's forte.
384: * We just grunge along, since it cuts
385: * across our line-oriented model of the world
386: * almost scrambling our addled brain.
387: */
388: if (!kill)
389: getDOT();
390: strcpy(genbuf, linebuf);
391: getline(*unddol);
392: if (kill)
393: *pkill[1] = 0;
394: strcat(linebuf, gp);
395: putmark(unddol);
396: getline(dol[1]);
397: if (kill)
398: strcLIN(pkill[0]);
399: strcpy(gp, linebuf);
400: strcLIN(genbuf);
401: putmark(dol+1);
402: undkind = UNDCHANGE;
403: undap1 = dot;
404: undap2 = dot + 1;
405: unddel = dot - 1;
406: undo(1);
407: }
408:
409: /*
410: * Shift lines, based on c.
411: * If c is neither < nor >, then this is a lisp aligning =.
412: */
413: shift(c, cnt)
414: int c;
415: int cnt;
416: {
417: register line *addr;
418: register char *cp;
419: char *dp;
420: register int i;
421:
422: if(FIXUNDO)
423: save12(), undkind = UNDCHANGE;
424: cnt *= value(SHIFTWIDTH);
425: for (addr = addr1; addr <= addr2; addr++) {
426: dot = addr;
427: #ifdef LISPCODE
428: if (c == '=' && addr == addr1 && addr != addr2)
429: continue;
430: #endif
431: getDOT();
432: i = whitecnt(linebuf);
433: switch (c) {
434:
435: case '>':
436: if (linebuf[0] == 0)
437: continue;
438: cp = genindent(i + cnt);
439: break;
440:
441: case '<':
442: if (i == 0)
443: continue;
444: i -= cnt;
445: cp = i > 0 ? genindent(i) : genbuf;
446: break;
447:
448: #ifdef LISPCODE
449: default:
450: i = lindent(addr);
451: getDOT();
452: cp = genindent(i);
453: break;
454: #endif
455: }
456: if (cp + strlen(dp = vpastwh(linebuf)) >= &genbuf[LBSIZE - 2])
457: error("Line too long|Result line after shift would be too long");
458: CP(cp, dp);
459: strcLIN(genbuf);
460: putmark(addr);
461: }
462: killed();
463: }
464:
465: /*
466: * Find a tag in the tags file.
467: * Most work here is in parsing the tags file itself.
468: */
469: tagfind(quick)
470: bool quick;
471: {
472: char cmdbuf[BUFSIZ];
473: char filebuf[FNSIZE];
474: char tagfbuf[128];
475: register int c, d;
476: bool samef = 1;
477: int tfcount = 0;
478: int omagic;
479: char *fn, *fne;
480: struct stat sbuf;
481: #ifdef FASTTAG
482: int iof;
483: char iofbuf[MAXBSIZE];
484: long mid; /* assumed byte offset */
485: long top, bot; /* length of tag file */
486: #endif
487:
488: omagic = value(MAGIC);
489: if (!skipend()) {
490: register char *lp = lasttag;
491:
492: while (!iswhite(peekchar()) && !endcmd(peekchar()))
493: if (lp < &lasttag[sizeof lasttag - 2])
494: *lp++ = ex_getchar();
495: else
496: ignchar();
497: *lp++ = 0;
498: if (!endcmd(peekchar()))
499: badtag:
500: error("Bad tag|Give one tag per line");
501: } else if (lasttag[0] == 0)
502: error("No previous tag");
503: c = ex_getchar();
504: if (!endcmd(c))
505: goto badtag;
506: if (c == EOF)
507: ungetchar(c);
508: clrstats();
509:
510: /*
511: * Loop once for each file in tags "path".
512: */
513: CP(tagfbuf, svalue(TAGS));
514: fne = tagfbuf - 1;
515: while (fne) {
516: fn = ++fne;
517: while (*fne && *fne != ' ')
518: fne++;
519: if (*fne == 0)
520: fne = 0; /* done, quit after this time */
521: else
522: *fne = 0; /* null terminate filename */
523: #ifdef FASTTAG
524: iof = topen(fn, iofbuf);
525: if (iof == -1)
526: continue;
527: tfcount++;
528: fstat(iof, &sbuf);
529: top = sbuf.st_size;
530: if (top == 0L )
531: top = -1L;
532: bot = 0L;
533: while (top >= bot) {
534: #else
535: /*
536: * Avoid stdio and scan tag file linearly.
537: */
538: io = open(fn, 0);
539: if (io<0)
540: continue;
541: tfcount++;
542: if (fstat(io, &sbuf) < 0)
543: bsize = LBSIZE;
544: else {
545: bsize = sbuf.st_blksize;
546: if (bsize <= 0)
547: bsize = LBSIZE;
548: }
549: while (getfile() == 0) {
550: #endif
551: /* loop for each tags file entry */
552: register char *cp = linebuf;
553: register char *lp = lasttag;
554: char *oglobp;
555:
556: #ifdef FASTTAG
557: mid = (top + bot) / 2;
558: tseek(iof, mid);
559: if (mid > 0) /* to get first tag in file to work */
560: /* scan to next \n */
561: if(tgets(linebuf, sizeof linebuf, iof)==NULL)
562: goto goleft;
563: /* get the line itself */
564: if(tgets(linebuf, sizeof linebuf, iof)==NULL)
565: goto goleft;
566: #ifdef TDEBUG
567: ex_printf("tag: %o %o %o %s\n", bot, mid, top, linebuf);
568: #endif
569: #endif
570: while (*cp && *lp == *cp)
571: cp++, lp++;
572: if ((*lp || !iswhite(*cp)) && (value(TAGLENGTH)==0 ||
573: lp-lasttag < value(TAGLENGTH))) {
574: #ifdef FASTTAG
575: if (*lp > *cp)
576: bot = mid + 1;
577: else
578: goleft:
579: top = mid - 1;
580: #endif
581: /* Not this tag. Try the next */
582: continue;
583: }
584:
585: /*
586: * We found the tag. Decode the line in the file.
587: */
588: #ifdef FASTTAG
589: tclose(iof);
590: #else
591: close(io);
592: #endif
593: /* Rest of tag if abbreviated */
594: while (!iswhite(*cp))
595: cp++;
596:
597: /* name of file */
598: while (*cp && iswhite(*cp))
599: cp++;
600: if (!*cp)
601: badtags:
602: serror("%s: Bad tags file entry", lasttag);
603: lp = filebuf;
604: while (*cp && *cp != ' ' && *cp != '\t') {
605: if (lp < &filebuf[sizeof filebuf - 2])
606: *lp++ = *cp;
607: cp++;
608: }
609: *lp++ = 0;
610:
611: if (*cp == 0)
612: goto badtags;
613: if (dol != zero) {
614: /*
615: * Save current position in 't for ^^ in visual.
616: */
617: names['t'-'a'] = *dot &~ 01;
618: if (inopen) {
619: extern char *ncols['z'-'a'+2];
620: extern char *cursor;
621:
622: ncols['t'-'a'] = cursor;
623: }
624: }
625: strcpy(cmdbuf, cp);
626: if (strcmp(filebuf, savedfile) || !edited) {
627: char cmdbuf2[sizeof filebuf + 10];
628:
629: /* Different file. Do autowrite & get it. */
630: if (!quick) {
631: ckaw();
632: if (chng && dol > zero)
633: error("No write@since last change (:tag! overrides)");
634: }
635: oglobp = globp;
636: strcpy(cmdbuf2, "e! ");
637: strcat(cmdbuf2, filebuf);
638: globp = cmdbuf2;
639: d = peekc; ungetchar(0);
640: commands(1, 1);
641: peekc = d;
642: globp = oglobp;
643: value(MAGIC) = omagic;
644: samef = 0;
645: }
646:
647: /*
648: * Look for pattern in the current file.
649: */
650: oglobp = globp;
651: globp = cmdbuf;
652: d = peekc; ungetchar(0);
653: if (samef)
654: markpr(dot);
655: /*
656: * BUG: if it isn't found (user edited header
657: * line) we get left in nomagic mode.
658: */
659: value(MAGIC) = 0;
660: commands(1, 1);
661: peekc = d;
662: globp = oglobp;
663: value(MAGIC) = omagic;
664: return;
665: } /* end of "for each tag in file" */
666:
667: /*
668: * No such tag in this file. Close it and try the next.
669: */
670: #ifdef FASTTAG
671: tclose(iof);
672: #else
673: close(io);
674: #endif
675: } /* end of "for each file in path" */
676: if (tfcount <= 0)
677: error("No tags file");
678: else
679: serror("%s: No such tag@in tags file", lasttag);
680: }
681:
682: /*
683: * Save lines from addr1 thru addr2 as though
684: * they had been deleted.
685: */
686: yank()
687: {
688:
689: if (!FIXUNDO)
690: error("Can't yank inside global/macro");
691: save12();
692: undkind = UNDNONE;
693: killcnt(addr2 - addr1 + 1);
694: }
695:
696: /*
697: * z command; print windows of text in the file.
698: *
699: * If this seems unreasonably arcane, the reasons
700: * are historical. This is one of the first commands
701: * added to the first ex (then called en) and the
702: * number of facilities here were the major advantage
703: * of en over ed since they allowed more use to be
704: * made of fast terminals w/o typing .,.22p all the time.
705: */
706: bool zhadpr;
707: bool znoclear;
708: short zweight;
709:
710: zop(hadpr)
711: int hadpr;
712: {
713: register int c, lines, op;
714: bool excl;
715:
716: zhadpr = hadpr;
717: notempty();
718: znoclear = 0;
719: zweight = 0;
720: excl = exclam();
721: switch (c = op = ex_getchar()) {
722:
723: case '^':
724: zweight = 1;
725: case '-':
726: case '+':
727: while (peekchar() == op) {
728: ignchar();
729: zweight++;
730: }
731: case '=':
732: case '.':
733: c = ex_getchar();
734: break;
735:
736: case EOF:
737: znoclear++;
738: break;
739:
740: default:
741: op = 0;
742: break;
743: }
744: if (isdigit(c)) {
745: lines = c - '0';
746: for(;;) {
747: c = ex_getchar();
748: if (!isdigit(c))
749: break;
750: lines *= 10;
751: lines += c - '0';
752: }
753: if (lines < LINES)
754: znoclear++;
755: value(WINDOW) = lines;
756: if (op == '=')
757: lines += 2;
758: } else
759: lines = op == EOF ? value(SCROLL) : excl ? LINES - 1 : 2*value(SCROLL);
760: if (inopen || c != EOF) {
761: ungetchar(c);
762: newline();
763: }
764: addr1 = addr2;
765: if (addr2 == 0 && dot < dol && op == 0)
766: addr1 = addr2 = dot+1;
767: setdot();
768: zop2(lines, op);
769: }
770:
771: zop2(lines, op)
772: register int lines;
773: register int op;
774: {
775: register line *split;
776:
777: split = NULL;
778: switch (op) {
779:
780: case EOF:
781: if (addr2 == dol)
782: error("\nAt EOF");
783: case '+':
784: if (addr2 == dol)
785: error("At EOF");
786: addr2 += lines * zweight;
787: if (addr2 > dol)
788: error("Hit BOTTOM");
789: addr2++;
790: default:
791: addr1 = addr2;
792: addr2 += lines-1;
793: dot = addr2;
794: break;
795:
796: case '=':
797: case '.':
798: znoclear = 0;
799: lines--;
800: lines >>= 1;
801: if (op == '=')
802: lines--;
803: addr1 = addr2 - lines;
804: if (op == '=')
805: dot = split = addr2;
806: addr2 += lines;
807: if (op == '.') {
808: markDOT();
809: dot = addr2;
810: }
811: break;
812:
813: case '^':
814: case '-':
815: addr2 -= lines * zweight;
816: if (addr2 < one)
817: error("Hit TOP");
818: lines--;
819: addr1 = addr2 - lines;
820: dot = addr2;
821: break;
822: }
823: if (addr1 <= zero)
824: addr1 = one;
825: if (addr2 > dol)
826: addr2 = dol;
827: if (dot > dol)
828: dot = dol;
829: if (addr1 > addr2)
830: return;
831: if (op == EOF && zhadpr) {
832: getline(*addr1);
833: ex_putchar('\r' | QUOTE);
834: shudclob = 1;
835: } else if (znoclear == 0 && CL != NOSTR && !inopen) {
836: flush1();
837: vclear();
838: }
839: if (addr2 - addr1 > 1)
840: pstart();
841: if (split) {
842: plines(addr1, split - 1, 0);
843: splitit();
844: plines(split, split, 0);
845: splitit();
846: addr1 = split + 1;
847: }
848: plines(addr1, addr2, 0);
849: }
850:
851: static
852: splitit()
853: {
854: register int l;
855:
856: for (l = COLUMNS > 80 ? 40 : COLUMNS / 2; l > 0; l--)
857: ex_putchar('-');
858: putnl();
859: }
860:
861: plines(adr1, adr2, movedot)
862: line *adr1;
863: register line *adr2;
864: bool movedot;
865: {
866: register line *addr;
867:
868: pofix();
869: for (addr = adr1; addr <= adr2; addr++) {
870: getline(*addr);
871: pline(lineno(addr));
872: if (inopen)
873: ex_putchar('\n' | QUOTE);
874: if (movedot)
875: dot = addr;
876: }
877: }
878:
879: pofix()
880: {
881:
882: if (inopen && Outchar != termchar) {
883: vnfl();
884: setoutt();
885: }
886: }
887:
888: /*
889: * Dudley doright to the rescue.
890: * Undo saves the day again.
891: * A tip of the hatlo hat to Warren Teitleman
892: * who made undo as useful as do.
893: *
894: * Command level undo works easily because
895: * the editor has a unique temporary file
896: * index for every line which ever existed.
897: * We don't have to save large blocks of text,
898: * only the indices which are small. We do this
899: * by moving them to after the last line in the
900: * line buffer array, and marking down info
901: * about whence they came.
902: *
903: * Undo is its own inverse.
904: */
905: undo(c)
906: bool c;
907: {
908: register int i;
909: register line *jp, *kp;
910: line *dolp1, *newdol, *newadot;
911:
912: #ifdef TRACE
913: if (trace)
914: vudump("before undo");
915: #endif
916: if (inglobal && inopen <= 0)
917: error("Can't undo in global@commands");
918: if (!c)
919: somechange();
920: pkill[0] = pkill[1] = 0;
921: change();
922: if (undkind == UNDMOVE) {
923: /*
924: * Command to be undone is a move command.
925: * This is handled as a special case by noting that
926: * a move "a,b m c" can be inverted by another move.
927: */
928: if ((i = (jp = unddel) - undap2) > 0) {
929: /*
930: * when c > b inverse is a+(c-b),c m a-1
931: */
932: addr2 = jp;
933: addr1 = (jp = undap1) + i;
934: unddel = jp-1;
935: } else {
936: /*
937: * when b > c inverse is c+1,c+1+(b-a) m b
938: */
939: addr1 = ++jp;
940: addr2 = jp + ((unddel = undap2) - undap1);
941: }
942: kp = undap1;
943: move1(0, unddel);
944: dot = kp;
945: Command = "move";
946: killed();
947: } else {
948: int cnt;
949:
950: newadot = dot;
951: cnt = lineDOL();
952: newdol = dol;
953: dolp1 = dol + 1;
954: /*
955: * Command to be undone is a non-move.
956: * All such commands are treated as a combination of
957: * a delete command and a append command.
958: * We first move the lines appended by the last command
959: * from undap1 to undap2-1 so that they are just before the
960: * saved deleted lines.
961: */
962: if ((i = (kp = undap2) - (jp = undap1)) > 0) {
963: if (kp != dolp1) {
964: reverse(jp, kp);
965: reverse(kp, dolp1);
966: reverse(jp, dolp1);
967: }
968: /*
969: * Account for possible backward motion of target
970: * for restoration of saved deleted lines.
971: */
972: if (unddel >= jp)
973: unddel -= i;
974: newdol -= i;
975: /*
976: * For the case where no lines are restored, dot
977: * is the line before the first line deleted.
978: */
979: dot = jp-1;
980: }
981: /*
982: * Now put the deleted lines, if any, back where they were.
983: * Basic operation is: dol+1,unddol m unddel
984: */
985: if (undkind == UNDPUT) {
986: unddel = undap1 - 1;
987: squish();
988: }
989: jp = unddel + 1;
990: if ((i = (kp = unddol) - dol) > 0) {
991: if (jp != dolp1) {
992: reverse(jp, dolp1);
993: reverse(dolp1, ++kp);
994: reverse(jp, kp);
995: }
996: /*
997: * Account for possible forward motion of the target
998: * for restoration of the deleted lines.
999: */
1000: if (undap1 >= jp)
1001: undap1 += i;
1002: /*
1003: * Dot is the first resurrected line.
1004: */
1005: dot = jp;
1006: newdol += i;
1007: }
1008: /*
1009: * Clean up so we are invertible
1010: */
1011: unddel = undap1 - 1;
1012: undap1 = jp;
1013: undap2 = jp + i;
1014: dol = newdol;
1015: netchHAD(cnt);
1016: if (undkind == UNDALL) {
1017: dot = undadot;
1018: undadot = newadot;
1019: } else
1020: undkind = UNDCHANGE;
1021: }
1022: /*
1023: * Defensive programming - after a munged undadot.
1024: * Also handle empty buffer case.
1025: */
1026: if ((dot <= zero || dot > dol) && dot != dol)
1027: dot = one;
1028: #ifdef TRACE
1029: if (trace)
1030: vudump("after undo");
1031: #endif
1032: }
1033:
1034: /*
1035: * Be (almost completely) sure there really
1036: * was a change, before claiming to undo.
1037: */
1038: somechange()
1039: {
1040: register line *ip, *jp;
1041:
1042: switch (undkind) {
1043:
1044: case UNDMOVE:
1045: return;
1046:
1047: case UNDCHANGE:
1048: if (undap1 == undap2 && dol == unddol)
1049: break;
1050: return;
1051:
1052: case UNDPUT:
1053: if (undap1 != undap2)
1054: return;
1055: break;
1056:
1057: case UNDALL:
1058: if (unddol - dol != lineDOL())
1059: return;
1060: for (ip = one, jp = dol + 1; ip <= dol; ip++, jp++)
1061: if ((*ip &~ 01) != (*jp &~ 01))
1062: return;
1063: break;
1064:
1065: case UNDNONE:
1066: error("Nothing to undo");
1067: }
1068: error("Nothing changed|Last undoable command didn't change anything");
1069: }
1070:
1071: /*
1072: * Map command:
1073: * map src dest
1074: */
1075: mapcmd(un, ab)
1076: int un; /* true if this is unmap command */
1077: int ab; /* true if this is abbr command */
1078: {
1079: char lhs[100], rhs[100]; /* max sizes resp. */
1080: register char *p;
1081: register int c; /* mjm: char --> int */
1082: char *dname;
1083: struct maps *mp; /* the map structure we are working on */
1084:
1085: mp = ab ? abbrevs : exclam() ? immacs : arrows;
1086: if (skipend()) {
1087: int i;
1088:
1089: /* print current mapping values */
1090: if (peekchar() != EOF)
1091: ignchar();
1092: if (un)
1093: error("Missing lhs");
1094: if (inopen)
1095: pofix();
1096: for (i=0; mp[i].mapto; i++)
1097: if (mp[i].cap) {
1098: lprintf("%s", mp[i].descr);
1099: ex_putchar('\t');
1100: lprintf("%s", mp[i].cap);
1101: ex_putchar('\t');
1102: lprintf("%s", mp[i].mapto);
1103: putNFL();
1104: }
1105: return;
1106: }
1107:
1108: ignore(skipwh());
1109: for (p=lhs; ; ) {
1110: c = ex_getchar();
1111: if (c == CTRL('v')) {
1112: c = ex_getchar();
1113: } else if (!un && any(c, " \t")) {
1114: /* End of lhs */
1115: break;
1116: } else if (endcmd(c) && c!='"') {
1117: ungetchar(c);
1118: if (un) {
1119: newline();
1120: *p = 0;
1121: addmac(lhs, NOSTR, NOSTR, mp);
1122: return;
1123: } else
1124: error("Missing rhs");
1125: }
1126: *p++ = c;
1127: }
1128: *p = 0;
1129:
1130: if (skipend())
1131: error("Missing rhs");
1132: for (p=rhs; ; ) {
1133: c = ex_getchar();
1134: if (c == CTRL('v')) {
1135: c = ex_getchar();
1136: } else if (endcmd(c) && c!='"') {
1137: ungetchar(c);
1138: break;
1139: }
1140: *p++ = c;
1141: }
1142: *p = 0;
1143: newline();
1144: /*
1145: * Special hack for function keys: #1 means key f1, etc.
1146: * If the terminal doesn't have function keys, we just use #1.
1147: */
1148: if (lhs[0] == '#') {
1149: char *fnkey;
1150: char *fkey();
1151: char funkey[3];
1152:
1153: fnkey = fkey(lhs[1] - '0');
1154: funkey[0] = 'f'; funkey[1] = lhs[1]; funkey[2] = 0;
1155: if (fnkey)
1156: strcpy(lhs, fnkey);
1157: dname = funkey;
1158: } else {
1159: dname = lhs;
1160: }
1161: addmac(lhs,rhs,dname,mp);
1162: }
1163:
1164: /*
1165: * Add a macro definition to those that already exist. The sequence of
1166: * chars "src" is mapped into "dest". If src is already mapped into something
1167: * this overrides the mapping. There is no recursion. Unmap is done by
1168: * using NOSTR for dest. Dname is what to show in listings. mp is
1169: * the structure to affect (arrows, etc).
1170: */
1171: addmac(src,dest,dname,mp)
1172: register char *src, *dest, *dname;
1173: register struct maps *mp;
1174: {
1175: register int slot, zer;
1176:
1177: #ifdef TRACE
1178: if (trace)
1179: fprintf(trace, "addmac(src='%s', dest='%s', dname='%s', mp=%x\n", src, dest, dname, mp);
1180: #endif
1181: if (dest && mp==arrows) {
1182: /* Make sure user doesn't screw himself */
1183: /*
1184: * Prevent tail recursion. We really should be
1185: * checking to see if src is a suffix of dest
1186: * but this makes mapping involving escapes that
1187: * is reasonable mess up.
1188: */
1189: if (src[1] == 0 && src[0] == dest[strlen(dest)-1])
1190: error("No tail recursion");
1191: /*
1192: * We don't let the user rob himself of ":", and making
1193: * multi char words is a bad idea so we don't allow it.
1194: * Note that if user sets mapinput and maps all of return,
1195: * linefeed, and escape, he can screw himself. This is
1196: * so weird I don't bother to check for it.
1197: */
1198: if (isalpha(src[0]) && src[1] || any(src[0],":"))
1199: error("Too dangerous to map that");
1200: }
1201: else if (dest) {
1202: /* check for tail recursion in input mode: fussier */
1203: if (eq(src, dest+strlen(dest)-strlen(src)))
1204: error("No tail recursion");
1205: }
1206: /*
1207: * If the src were null it would cause the dest to
1208: * be mapped always forever. This is not good.
1209: */
1210: if (src == NOSTR || src[0] == 0)
1211: error("Missing lhs");
1212:
1213: /* see if we already have a def for src */
1214: zer = -1;
1215: for (slot=0; mp[slot].mapto; slot++) {
1216: if (mp[slot].cap) {
1217: if (eq(src, mp[slot].cap) || eq(src, mp[slot].mapto))
1218: break; /* if so, reuse slot */
1219: } else {
1220: zer = slot; /* remember an empty slot */
1221: }
1222: }
1223:
1224: if (dest == NOSTR) {
1225: /* unmap */
1226: if (mp[slot].cap) {
1227: mp[slot].cap = NOSTR;
1228: mp[slot].descr = NOSTR;
1229: } else {
1230: error("Not mapped|That macro wasn't mapped");
1231: }
1232: return;
1233: }
1234:
1235: /* reuse empty slot, if we found one and src isn't already defined */
1236: if (zer >= 0 && mp[slot].mapto == 0)
1237: slot = zer;
1238:
1239: /* if not, append to end */
1240: if (slot >= MAXNOMACS)
1241: error("Too many macros");
1242: if (msnext == 0) /* first time */
1243: msnext = mapspace;
1244: /* Check is a bit conservative, we charge for dname even if reusing src */
1245: if (msnext - mapspace + strlen(dest) + strlen(src) + strlen(dname) + 3 > MAXCHARMACS)
1246: error("Too much macro text");
1247: CP(msnext, src);
1248: mp[slot].cap = msnext;
1249: msnext += strlen(src) + 1; /* plus 1 for null on the end */
1250: CP(msnext, dest);
1251: mp[slot].mapto = msnext;
1252: msnext += strlen(dest) + 1;
1253: if (dname) {
1254: CP(msnext, dname);
1255: mp[slot].descr = msnext;
1256: msnext += strlen(dname) + 1;
1257: } else {
1258: /* default descr to string user enters */
1259: mp[slot].descr = src;
1260: }
1261: }
1262:
1263: /*
1264: * Implements macros from command mode. c is the buffer to
1265: * get the macro from.
1266: */
1267: cmdmac(c)
1268: char c;
1269: {
1270: char macbuf[BUFSIZ];
1271: line *ad, *a1, *a2;
1272: char *oglobp;
1273: short pk;
1274: bool oinglobal;
1275:
1276: lastmac = c;
1277: oglobp = globp;
1278: oinglobal = inglobal;
1279: pk = peekc; peekc = 0;
1280: if (inglobal < 2)
1281: inglobal = 1;
1282: regbuf(c, macbuf, sizeof(macbuf));
1283: a1 = addr1; a2 = addr2;
1284: for (ad=a1; ad<=a2; ad++) {
1285: globp = macbuf;
1286: dot = ad;
1287: commands(1,1);
1288: }
1289: globp = oglobp;
1290: inglobal = oinglobal;
1291: peekc = pk;
1292: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.