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