![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to que2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / B / src / bed|
Return to que2.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / B / src / bed |
1.1 root 1: /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1984. */
2: static char rcsid[] = "$Header: que2.c,v 2.3 84/07/23 13:02:38 guido Exp $";
3:
4: /*
5: * B editor -- Manipulate queues of nodes, higher levels.
6: */
7:
8: #include <ctype.h>
9:
10: #include "b.h"
11: #include "feat.h"
12: #include "bobj.h"
13: #include "node.h"
14: #include "supr.h"
15: #include "queu.h"
16: #include "gram.h"
17: #include "tabl.h"
18:
19:
20: extern bool lefttorite;
21: /* Set by edit() to signal we parse purely left-to-right */
22: extern bool dflag; /* Debug mode even if NDEBUG on */
23:
24:
25: /*
26: * Insert a queue of nodes at the focus
27: * (which had better be some kind of a hole).
28: * The nodes may also be a text, in which case the individual characters
29: * are inserted.
30: * Extensive changes to the parse tree may occur, and the node may be
31: * broken up in its constituent parts (texts and other nodes) which
32: * are then inserted individually.
33: */
34:
35: Visible bool
36: ins_queue(ep, pq, pq2)
37: register environ *ep;
38: register queue *pq;
39: register queue *pq2;
40: {
41: register bool ok = Yes;
42: register node n;
43: register queue oldq2;
44: environ saveenv;
45: int oldindentation = focindent(ep);
46: int indentation = oldindentation;
47:
48: leftvhole(ep);
49: while (ok && !emptyqueue(*pq)) {
50: n = queuebehead(pq);
51: if (Type(n) == Tex) {
52: ok = ins_string(ep, Str((value) n), pq2, 0);
53: switch (Str((value) n)[Length((value) n) - 1]) { /* Last char */
54: case '\t':
55: ++indentation;
56: break;
57: case '\b':
58: --indentation;
59: break;
60: case '\n':
61: while (focindent(ep) > indentation) {
62: if (!ins_newline(ep))
63: break;
64: }
65: break;
66: }
67: }
68: else {
69: Ecopy(*ep, saveenv);
70: oldq2 = qcopy(*pq2);
71: if (!ins_node(&saveenv, n, pq2)) {
72: Erelease(saveenv);
73: qrelease(*pq2);
74: *pq2 = oldq2;
75: if (symbol(n) == Hole)
76: ok = ins_string(ep, "?", pq2, 0);
77: else
78: splitnode(n, pq);
79: }
80: else {
81: Erelease(*ep);
82: Emove(saveenv, *ep);
83: qrelease(oldq2);
84: }
85: }
86: noderelease(n);
87: }
88: if (!ok)
89: qshow(*pq, "ins_queue");
90: qrelease(*pq);
91: for (indentation = focindent(ep);
92: indentation > oldindentation; --indentation)
93: stringtoqueue("\b", pq2); /* Pass on indentation to outer level */
94: return ok;
95: }
96:
97:
98: /*
99: * Subroutine to insert a queue to the right of the focus
100: * without affecting the focus position.
101: */
102:
103: Visible bool
104: app_queue(ep, pq)
105: environ *ep;
106: queue *pq;
107: {
108: int where;
109: static int markbit = 1; /* To properly handle recursive calls */
110:
111: if (emptyqueue(*pq))
112: return Yes;
113: where = focoffset(ep);
114: markbit <<= 1;
115: markpath(&ep->focus, markbit);
116: if (!ins_queue(ep, pq, pq)) {
117: markbit >>= 1;
118: return No;
119: }
120: firstmarked(&ep->focus, markbit) || Abort();
121: unmkpath(&ep->focus, markbit);
122: markbit >>= 1;
123: ep->spflag = No;
124: fixfocus(ep, where);
125: return Yes;
126: }
127:
128:
129: /*
130: * Advance to next thing after current position.
131: */
132:
133: Visible bool
134: move_on(ep)
135: register environ *ep;
136: {
137: register node n;
138: register string *rp;
139: register int sym;
140: register int ich = ichild(ep->focus);
141:
142: if (!up(&ep->focus))
143: return No;
144: higher(ep);
145: n = tree(ep->focus);
146: rp = noderepr(n);
147: if (Fw_positive(rp[ich])) {
148: ep->mode = FHOLE;
149: ep->s1 = 2*ich + 1;
150: ep->s2 = 0;
151: if (ep->spflag) {
152: ep->spflag = No;
153: if (rp[ich][0] == ' ') {
154: ++ep->s2;
155: if (fwidth(rp[ich]) > 1)
156: return Yes;
157: }
158: else
159: return Yes;
160: }
161: else
162: return Yes;
163: }
164: if (ich < nchildren(n)) {
165: s_downi(ep, ich+1);
166: sym = symbol(tree(ep->focus));
167: if (sym == Hole || sym == Optional)
168: ep->mode = WHOLE;
169: else
170: ep->mode = ATBEGIN;
171: return Yes;
172: }
173: ep->mode = ATEND;
174: return Yes;
175: }
176:
177:
178: /*
179: * Like move_on but moves through fixed texts, skipping only spaces
180: * and empty strings.
181: * <<<<< This code is a dinosaur and should be revised. >>>>>
182: */
183:
184: Visible bool
185: fix_move(ep)
186: register environ *ep;
187: {
188: register int ich;
189: register int i;
190: register string *rp;
191: register string cp;
192:
193: Assert(ep->mode == FHOLE);
194:
195: ich = ep->s1/2;
196: rp = noderepr(tree(ep->focus));
197: cp = rp[ich];
198: if (cp) {
199: i = ep->s2;
200: Assert(i <= Fwidth(cp));
201: if (cp[i] == ' ') {
202: do {
203: ++i;
204: } while (cp[i] == ' ');
205: }
206: if (cp[i] == '\b' || cp[i] == '\t') {
207: ++i;
208: Assert(!cp[i]);
209: }
210: else if (cp[i]) {
211: if (i == ep->s2)
212: return No;
213: ep->s2 = i;
214: return Yes;
215: }
216: }
217:
218: if (ich >= nchildren(tree(ep->focus)))
219: ep->mode = ATEND;
220: else {
221: s_downi(ep, ich+1);
222: if (symbol(tree(ep->focus)) == Hole
223: || symbol(tree(ep->focus)) == Optional)
224: ep->mode = WHOLE;
225: else
226: ep->mode = ATBEGIN;
227: }
228: return Yes;
229: }
230:
231:
232: /*
233: * Insert a node in the parse tree.
234: */
235:
236: Hidden bool
237: ins_node(ep, n, pq)
238: register environ *ep;
239: register node n;
240: register queue *pq;
241: {
242: register int sym;
243: register node nn;
244: register markbits x;
245: string *rp;
246:
247: if (symbol(n) == Optional)
248: return Yes;
249:
250: for (;;) {
251: switch (ep->mode) {
252:
253: case FHOLE:
254: if (ep->s2 < lenitem(ep) || !fix_move(ep))
255: return No;
256: continue;
257:
258: case VHOLE:
259: if (ep->s2 < lenitem(ep) || !move_on(ep))
260: return No;
261: continue;
262:
263: case ATBEGIN:
264: sym = symbol(tree(ep->focus));
265: if (sym == Optional || sym == Hole) {
266: ep->mode = WHOLE;
267: continue;
268: }
269: x = marks(tree(ep->focus));
270: if (joinnodes(&ep->focus, n, tree(ep->focus), No)) {
271: if (x) {
272: s_downi(ep, 2);
273: markpath(&ep->focus, x);
274: s_up(ep);
275: }
276: s_down(ep);
277: ep->mode = ATEND;
278: leftvhole(ep);
279: return Yes;
280: }
281: nn = tree(ep->focus);
282: rp = noderepr(nn);
283: if (nchildren(nn) >= 1 && Fw_zero(rp[0])) {
284: sym = symbol(firstchild(nn));
285: if (sym == Hole || sym == Optional) {
286: s_down(ep);
287: if (fitnode(&ep->focus, n)) {
288: ep->mode = ATEND;
289: leftvhole(ep);
290: return Yes;
291: }
292: s_up(ep);
293: }
294: }
295: nn = nodecopy(nn);
296: if (!fitnode(&ep->focus, n)) {
297: addtoqueue(pq, nn);
298: noderelease(nn);
299: delfocus(&ep->focus);
300: ep->mode = WHOLE;
301: continue;
302: }
303: if (downrite(&ep->focus)) {
304: if (Type(tree(ep->focus)) != Tex) {
305: sym = symbol(tree(ep->focus));
306: if (sym == Hole || sym == Optional) {
307: if (fitnode(&ep->focus, nn)) {
308: noderelease(nn);
309: nn = Nnil;
310: }
311: }
312: }
313: else
314: up(&ep->focus);
315: }
316: if (nn) {
317: addtoqueue(pq, nn);
318: noderelease(nn);
319: }
320: ep->mode = ATEND;
321: leftvhole(ep);
322: return Yes;
323:
324: case WHOLE:
325: sym = symbol(tree(ep->focus));
326: Assert(sym == Optional || sym == Hole);
327: do {
328: higher(ep); /* Only for second time around */
329: if (fitnode(&ep->focus, n)) {
330: ep->mode = ATEND;
331: leftvhole(ep);
332: return Yes;
333: }
334: } while (resttoqueue(&ep->focus, pq));
335: ep->mode = ATEND;
336: /* Fall through */
337: case ATEND:
338: do {
339: higher(ep); /* Only for second time around */
340: if (joinnodes(&ep->focus, tree(ep->focus), n, ep->spflag)) {
341: ep->spflag = No;
342: leftvhole(ep);
343: return Yes;
344: }
345: } while (resttoqueue(&ep->focus, pq)
346: || move_on(ep) && ep->mode == ATEND);
347: return No;
348:
349: default:
350: return No;
351:
352: }
353: }
354: }
355:
356:
357: /*
358: * Insert a string in the parse tree.
359: */
360:
361: #define NEXT (++str, alt_c = 0)
362:
363: Visible bool
364: ins_string(ep, str, pq, alt_c)
365: register environ *ep;
366: /*auto*/ string str;
367: register queue *pq;
368: int alt_c;
369: {
370: register node nn;
371: auto value v;
372: char buf[1024];
373: register string repr;
374: string oldstr;
375: register int sym;
376: register int len;
377: bool interactive = alt_c != 0;
378:
379: if (alt_c < 0)
380: alt_c = 0;
381: while (*str) {
382: switch (*str) {
383:
384: case '\n':
385: if (!ins_newline(ep))
386: return No;
387: /* Fall through */
388: case '\t':
389: case '\b':
390: NEXT;
391: continue;
392:
393: }
394: switch (ep->mode) {
395:
396: case ATBEGIN:
397: nn = tree(ep->focus);
398: if (Type(nn) == Tex) {
399: ep->s1 = 2*ichild(ep->focus);
400: ep->s2 = 0;
401: ep->mode = VHOLE;
402: s_up(ep);
403: continue;
404: }
405: sym = symbol(nn);
406: if (sym != Optional && sym != Hole) {
407: if (fwidth(noderepr(nn)[0]) == 0) {
408: if (down(&ep->focus))
409: break;
410: }
411: addtoqueue(pq, nn);
412: delfocus(&ep->focus);
413: }
414: ep->mode = WHOLE;
415: /* Fall through */
416: case WHOLE:
417: nn = tree(ep->focus);
418: sym = symbol(nn);
419: Assert(sym == Hole || sym == Optional);
420: while ((len = fitstring(&ep->focus, str, alt_c)) == 0) {
421: if (sym == Optional) {
422: if (!move_on(ep)) {
423: if (*str == ' ')
424: NEXT;
425: else
426: return No;
427: }
428: break;
429: }
430: if (!interactive && *str == '?') {
431: NEXT;
432: ep->mode = ATEND;
433: break;
434: }
435: if (resttoqueue(&ep->focus, pq))
436: higher(ep);
437: else if (spacefix(ep))
438: break;
439: else if (*str == ' ') {
440: NEXT;
441: break;
442: }
443: else if (interactive)
444: return No;
445: else {
446: ep->mode = ATEND;
447: break;
448: }
449: }
450: if (len > 0) {
451: str += len;
452: alt_c = 0;
453: fixfocus(ep, len);
454: }
455: break;
456:
457: case ATEND:
458: if (add_string(ep, &str, alt_c)) {
459: alt_c = 0;
460: break;
461: }
462: len = joinstring(&ep->focus, str, ep->spflag,
463: alt_c ? alt_c : interactive ? -1 : 0, Yes);
464: if (len > 0) {
465: s_downi(ep, 2);
466: ep->spflag = No;
467: fixfocus(ep, len);
468: }
469: else {
470: if (resttoqueue(&ep->focus, pq)) {
471: higher(ep);
472: break;
473: }
474: if (move_on(ep))
475: break;
476: if (*str == ' ') {
477: NEXT;
478: break;
479: }
480: return No;
481: }
482: str += len;
483: alt_c = 0;
484: break;
485:
486: case FHOLE:
487: nn = tree(ep->focus);
488: repr = noderepr(nn)[ep->s1/2];
489: if (ep->s2 >= fwidth(repr)
490: && (ep->s2 <= 0 || ep->spflag || !isalpha(repr[0])
491: || repr[ep->s2-1] == ' ')) { /* At end */
492: if (ep->s1/2 < nchildren(nn)) {
493: s_downi(ep, ep->s1/2 + 1);
494: ep->mode = ATBEGIN; /* Of next child */
495: }
496: else
497: ep->mode = ATEND;
498: break;
499: }
500: if ((*str == ':' || *str == ' ') && *str == repr[ep->s2]) {
501: /*****
502: * Quick hack for insertion of test-suites and refinements:
503: *****/
504: ++ep->s2;
505: NEXT;
506: continue;
507: }
508: if (!lefttorite)
509: nosuggtoqueue(ep, pq);
510: oldstr = str;
511: if (resuggest(ep, &str, alt_c) || soften(ep, &str, alt_c)) {
512: if (str > oldstr)
513: alt_c = 0;
514: continue;
515: }
516: if (fix_move(ep))
517: continue;
518: return No;
519:
520: case VHOLE:
521: Assert(!(ep->s1&1));
522: nn = tree(ep->focus);
523: #ifdef USERSUGG
524: if (symbol(nn) == Suggestion) {
525: if (newsugg(ep, &str, alt_c))
526: alt_c = 0;
527: else
528: killsugg(ep);
529: continue;
530: }
531: #endif USERSUGG
532: s_downi(ep, ep->s1/2);
533: v = copy((value) tree(ep->focus));
534: len = 0;
535: if (!ep->spflag) {
536: for (; len < sizeof buf - 1 && str[len]
537: && mayinsert(nn, ep->s1/2, !!(ep->s2 + len),
538: str[len]);
539: ++len) {
540: buf[len] = str[len];
541: }
542: if (len <= 0 && alt_c
543: && mayinsert(nn, ep->s1/2, !!(ep->s2 + len), alt_c)) {
544: buf[0] = alt_c;
545: len = 1;
546: }
547: }
548: if (len > 0) { /* Effectuate change */
549: str += len;
550: alt_c = 0;
551: Assert(Type(v) == Tex);
552: buf[len] = 0;
553: putintrim(&v, ep->s2, Length(v) - ep->s2, buf);
554: replace(&ep->focus, (node) v);
555: s_up(ep);
556: ep->spflag = No;
557: ep->s2 += len;
558: }
559: else { /* Nothing inserted */
560: if (ep->s2 == 0) { /* Whole string rejected */
561: addtoqueue(pq, (node)v);
562: release(v);
563: s_up(ep);
564: delfocus(&ep->focus);
565: ep->mode = WHOLE;
566: break;
567: }
568: if (ep->s2 < Length(v)) {
569: addstringtoqueue(pq, Str(v) + ep->s2);
570: putintrim(&v, ep->s2, 0, "");
571: replace(&ep->focus, (node) v);
572: }
573: else
574: release(v);
575: move_on(ep) || Abort(); /* ==> up, cancelling s_downi! */
576: }
577: break;
578:
579: default:
580: Abort();
581:
582: }
583: }
584:
585: return Yes;
586: }
587:
588:
589: /*
590: * See if two nodes can be joined in a hole.
591: * 'Spflag' indicates whether a space must be present between the nodes
592: * (required or forbidden).
593: * Either of n1, n2 may actually be the current contents of the hole.
594: */
595:
596: Hidden bool
597: joinnodes(pp, n1, n2, spflag)
598: path *pp;
599: node n1;
600: node n2;
601: bool spflag;
602: {
603: path pa = parent(*pp);
604: int sympa = pa ? symbol(tree(pa)) : Rootsymbol;
605: struct table *tp = &table[sympa];
606: struct classinfo *ci = tp->r_class[ichild(*pp) - 1];
607: classptr cp = ci->c_join;
608: int sym1 = symbol(n1);
609: int sym2 = symbol(n2);
610: int symcp;
611: int symfound = -1;
612:
613: if (!cp)
614: return No;
615: for (; *cp; cp += 2) {
616: if (cp[0] != spflag + 1)
617: continue;
618: symcp = cp[1];
619: tp = &table[symcp];
620: if (isinclass(sym1, tp->r_class[0])
621: && isinclass(sym2, tp->r_class[1])) {
622: symfound = symcp;
623: break;
624: }
625: }
626:
627: if (symfound < 0)
628: return No;
629: n1 = nodecopy(n1);
630: n2 = nodecopy(n2); /* 'Cause one of them may overlap tree(*pp) */
631: replace(pp, table[symfound].r_node);
632: down(pp) || Abort();
633: replace(pp, n1);
634: rite(pp) || Abort();
635: replace(pp, n2);
636: up(pp) || Abort();
637: return Yes;
638: }
639:
640:
641: /*
642: * Try to join a node (implicit as tree(*pp)) with some text.
643: * That is, try to replace the node by one with it as first child,
644: * (some of) the text as second child, and nothing or a space in between.
645: *
646: * 'Spflag' indicates whether a space is desirable between the nodes
647: * (but if No it is only used as advice).
648: *
649: * Returns the number of characters consumed from str.
650: */
651:
652: Visible int
653: joinstring(pp, str, spflag, alt_c, mayindent)
654: path *pp;
655: register string str;
656: register bool spflag;
657: int alt_c;
658: bool mayindent;
659: {
660: register struct table *tp;
661: path pa = parent(*pp);
662: node n1;
663: struct classinfo *ci;
664: register classptr cp;
665: int sympa = pa ? symbol(tree(pa)) : Rootsymbol;
666: register int sym1;
667: register int symcp;
668: int symfound;
669: int len;
670: char buf[2];
671: bool interactive = alt_c != 0;
672:
673: if (alt_c < 0)
674: alt_c = 0;
675: ci = table[sympa].r_class[ichild(*pp) - 1];
676: Assert(ci);
677: cp = ci->c_join;
678: if (!cp)
679: return 0;
680:
681: n1 = tree(*pp);
682: sym1 = symbol(n1);
683: symfound = -1;
684: for (; *cp; cp += 2) {
685: if (cp[0] < spflag + 1)
686: continue;
687: symcp = cp[1];
688: tp = &table[symcp];
689: if (!mayindent && tp->r_repr[1] && index(tp->r_repr[1], '\t'))
690: continue;
691: if (isinclass(sym1, tp->r_class[0])
692: && ((canfitchar(str[0], tp->r_class[1]))
693: || str[0] == '?' && !interactive)) {
694: if (cp[0] == spflag + 1) {
695: symfound = symcp;
696: break;
697: }
698: if (symfound < 0)
699: symfound = symcp;
700: }
701: }
702:
703: if (symfound < 0) { /* 1-level recursion */
704: if (!alt_c)
705: return 0;
706: buf[0] = alt_c;
707: buf[1] = 0;
708: return joinstring(pp, buf, spflag, 0, mayindent);
709: }
710: n1 = nodecopy(n1); /* 'Cause it overlaps tree(*pp) */
711: replace(pp, table[symfound].r_node);
712: down(pp) || Abort();
713: replace(pp, n1);
714: rite(pp) || Abort();
715: len = fitstring(pp, str, 0);
716: if (len == 0 && str[0] == '?')
717: len = 1;
718: Assert(len > 0); /* Disagreement between canfitchar and fitstring */
719: up(pp) || Abort();
720: return len;
721: }
722:
723:
724: /*
725: * Similar to joinstring, but now the string must match the delimiter
726: * rather than being acceptable as second child.
727: * (Interface has changed to resemble resuggest/soften.)
728: */
729:
730: Hidden bool
731: add_string(ep, pstr, alt_c)
732: environ *ep;
733: string *pstr;
734: int alt_c; /* Yet unused */
735: {
736: register struct table *tp;
737: path pa = parent(ep->focus);
738: node n1;
739: struct classinfo *ci;
740: register classptr cp;
741: int sympa = pa ? symbol(tree(pa)) : Rootsymbol;
742: register int sym1;
743: register int symcp;
744: register int c;
745:
746: ci = table[sympa].r_class[ichild(ep->focus) - 1];
747: Assert(ci);
748: cp = ci->c_append;
749: if (!cp)
750: return No;
751: n1 = tree(ep->focus);
752: sym1 = symbol(n1);
753: c = **pstr;
754: for (; *cp; cp += 2) {
755: if ((*cp&0177) != c)
756: continue;
757: symcp = cp[1];
758: tp = &table[symcp];
759: if (isinclass(sym1, tp->r_class[0]))
760: break;
761: }
762: if (!*cp)
763: return No;
764: ++*pstr;
765: if (c == ' ') {
766: ep->spflag = Yes;
767: return Yes;
768: }
769: n1 = nodecopy(n1); /* 'Cause it overlaps tree(ep->focus) */
770: replace(&ep->focus, table[symcp].r_node);
771: s_down(ep);
772: replace(&ep->focus, n1);
773: s_up(ep);
774: ep->mode = FHOLE;
775: ep->s1 = 3;
776: ep->s2 = (*cp&0200) ? 2 : 1;
777: ep->spflag = No;
778: return Yes;
779: }
780:
781:
782: /*
783: * See whether a character may start a new node in a hole with given class.
784: */
785:
786: Visible bool
787: canfitchar(c, ci)
788: int c;
789: struct classinfo *ci;
790: {
791: register classptr cp;
792: register int code = Code(c);
793:
794: Assert(ci);
795: cp = ci->c_insert;
796: Assert(cp);
797: for (; *cp; cp += 2) {
798: if (cp[0] == code)
799: return Yes;
800: }
801: return No;
802: }
803:
804:
805: /*
806: * Debug routine to print a queue.
807: */
808:
809: Visible Procedure
810: qshow(q, where)
811: queue q;
812: string where;
813: {
814: #ifndef NDEBUG
815: node n;
816: char buf[256];
817: string cp;
818: string sp;
819:
820: sprintf(buf, "%s:", where);
821: cp = buf + strlen(buf);
822: for (;q; q = q->q_link) {
823: n = q->q_data;
824: *cp++ = ' ';
825: if (Type(n) == Tex) {
826: *cp++ = '"';
827: for (sp = Str((value) n); *sp; ++sp) {
828: if (isprint(*sp) || *sp == ' ') {
829: *cp++ = *sp;
830: if (*sp == '"')
831: *cp++ = *sp;
832: }
833: else {
834: sprintf(cp, "\\%03o", *sp&0377);
835: cp += 4;
836: }
837: }
838: *cp++ = '"';
839: }
840: else {
841: strncpy(cp, table[symbol(n)].r_name, 80);
842: cp += strlen(cp);
843: }
844: if (cp >= buf+80) {
845: strcpy(buf+76, "...");
846: break;
847: }
848: }
849: *cp = 0;
850: debug(buf);
851: #endif NDEBUG
852: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.