![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to code.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / icon / tran|
Return to code.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / icon / tran |
1.1 root 1: /*
2: * Routines for constructing and traversing parse trees and generating code.
3: */
4:
5: #include "itran.h"
6: #include "token.h"
7: #include "tree.h"
8: #include "code.h"
9: #include "sym.h"
10:
11: static int nextlab; /* next label allocated by alclab() */
12:
13: /*
14: * tree[1-7] construct parse tree nodes with specified values. tfree
15: * points at the next free word in the parse tree space. Nodes are
16: * built by copying argument values into successive locations starting
17: * at tfree. Parameters a and b are line and column information,
18: * while parameters c through f are values to be assigned to n_field[0-3].
19: * Note that this could be done with a single routine; a separate routine
20: * for each node size is used for speed and simplicity.
21: */
22:
23: nodeptr tree1(type)
24: int type;
25: {
26: register nodeptr t;
27:
28: t = tfree;
29: tfree = (nodeptr) ((int *)tfree + 1);
30: if (tfree > tend)
31: syserr("out of tree space");
32: t->n_type = type;
33: return (t);
34: }
35:
36: nodeptr tree3(type, a, b)
37: int type, a, b;
38: {
39: register nodeptr t;
40:
41: t = tfree;
42: tfree = (nodeptr) ((int *)tfree + 3);
43: if (tfree > tend)
44: syserr("out of tree space");
45: t->n_type = type;
46: t->n_line = a;
47: t->n_col = b;
48: return (t);
49: }
50:
51: nodeptr tree4(type, a, b, c)
52: int type, a, b, c;
53: {
54: register nodeptr t;
55:
56: t = tfree;
57: tfree = (nodeptr) ((int *)tfree + 4);
58: if (tfree > tend)
59: syserr("out of tree space");
60: t->n_type = type;
61: t->n_line = a;
62: t->n_col = b;
63: t->n_field[0].n_val = c;
64: return (t);
65: }
66:
67: nodeptr tree5(type, a, b, c, d)
68: int type, a, b, c, d;
69: {
70: register nodeptr t;
71:
72: t = tfree;
73: tfree = (nodeptr) ((int *)tfree + 5);
74: if (tfree > tend)
75: syserr("out of tree space");
76: t->n_type = type;
77: t->n_line = a;
78: t->n_col = b;
79: t->n_field[0].n_val = c;
80: t->n_field[1].n_val = d;
81: return (t);
82: }
83:
84: nodeptr tree6(type, a, b, c, d, e)
85: int type, a, b, c, d, e;
86: {
87: register nodeptr t;
88:
89: t = tfree;
90: tfree = (nodeptr) ((int *)tfree + 6);
91: if (tfree > tend)
92: syserr("out of tree space");
93: t->n_type = type;
94: t->n_line = a;
95: t->n_col = b;
96: t->n_field[0].n_val = c;
97: t->n_field[1].n_val = d;
98: t->n_field[2].n_val = e;
99: return (t);
100: }
101:
102: nodeptr tree7(type, a, b, c, d, e, f)
103: int type, a, b, c, d, e, f;
104: {
105: register nodeptr t;
106:
107: t = tfree;
108: tfree = (nodeptr) ((int *)tfree + 7);
109: if (tfree > tend)
110: syserr("out of tree space");
111: t->n_type = type;
112: t->n_line = a;
113: t->n_col = b;
114: t->n_field[0].n_val = c;
115: t->n_field[1].n_val = d;
116: t->n_field[2].n_val = e;
117: t->n_field[3].n_val = f;
118: return (t);
119: }
120:
121: /*
122: * Clear the tree space by setting the free pointer back to the first word
123: * of the tree space.
124: */
125:
126: treeinit()
127: {
128: tfree = tree;
129: }
130:
131: /*
132: * codegen - traverse tree t, generating code.
133: */
134:
135: codegen(t)
136: nodeptr t;
137: {
138: nextlab = 1;
139: traverse(t);
140: }
141:
142: /*
143: * traverse - traverse tree rooted at t and generate code. This is just
144: * plug and chug code for each of the node types. The tour goes into
145: * some detail about the code generation process, in particular, Appendix
146: * A describes the parse tree nodes.
147: */
148:
149: traverse(t)
150: register nodeptr t;
151: {
152: register int lab, n;
153: struct loopstk loopsave;
154: static struct loopstk loopstk[LOOPDEPTH]; /* loop stack */
155: static struct loopstk *loopsp;
156: static struct casestk casestk[CASEDEPTH]; /* case stack */
157: static struct casestk *casesp;
158: static struct creatstk creatstk[CREATDEPTH]; /* create stack */
159: static struct creatstk *creatsp;
160:
161: n = 1;
162: switch (TYPE(t)) {
163:
164: case N_ACTIVAT: /* co-expression activation */
165: if (VAL0(TREE0(t)) == AUGACT)
166: emit("pnull");
167: traverse(TREE2(t)); /* evaluate result expression */
168: if (VAL0(TREE0(t)) == AUGACT)
169: emit("sdup");
170: traverse(TREE1(t)); /* evaluate activate expression */
171: setline(LINE(t));
172: emit("coact");
173: if (VAL0(TREE0(t)) == AUGACT)
174: emit("asgn");
175: break;
176:
177: case N_ALT: /* alternation */
178: lab = alclab(2);
179: emitl("mark", lab);
180: loopsp->markcount++;
181: traverse(TREE0(t)); /* evaluate first alternative */
182: loopsp->markcount--;
183: emit("esusp"); /* and suspend with its result */
184: emitl("goto", lab+1);
185: emitlab(lab);
186: traverse(TREE1(t)); /* evaluate second alternative */
187: emitlab(lab+1);
188: break;
189:
190: case N_AUGOP: /* augmented assignment */
191: case N_BINOP: /* or a binary operator */
192: emit("pnull");
193: traverse(TREE1(t));
194: if (TYPE(t) == N_AUGOP)
195: emit("dup");
196: traverse(TREE2(t));
197: setline(LINE(t));
198: binop(VAL0(TREE0(t)));
199: break;
200:
201: case N_BAR: /* repeated alternation */
202: lab = alclab(1);
203: emitlab(lab);
204: emitl("mark", 0); /* fail if expr fails first time */
205: loopsp->markcount++;
206: traverse(TREE0(t)); /* evaluate first alternative */
207: loopsp->markcount--;
208: emitl("chfail", lab); /* change to loop on failure */
209: emit("esusp"); /* suspend result */
210: break;
211:
212: case N_BREAK: /* break expression */
213: if (loopsp->breaklab <= 0)
214: lerr(LINE(t), "invalid context for break");
215: else {
216: emitn("unmark", loopsp->markcount);
217: loopsave = *loopsp--;
218: traverse(TREE0(t));
219: *++loopsp = loopsave;
220: emitl("goto", loopsp->breaklab);
221: }
222: break;
223:
224: case N_CASE: /* case expression */
225: lab = alclab(1);
226: casesp++;
227: casesp->endlab = lab;
228: casesp->deftree = NULL;
229: emitl("mark", 0);
230: loopsp->markcount++;
231: traverse(TREE0(t)); /* evaluate control expression */
232: loopsp->markcount--;
233: emit("eret");
234: traverse(TREE1(t)); /* do rest of case (CLIST) */
235: if (casesp->deftree != NULL) { /* evaluate default clause */
236: emit("pop");
237: traverse(casesp->deftree);
238: }
239: else
240: emit("efail");
241: emitlab(lab); /* end label */
242: casesp--;
243: break;
244:
245: case N_CCLS: /* case expression clause */
246: if (TYPE(TREE0(t)) == N_RES && /* default clause */
247: VAL0(TREE0(t)) == DEFAULT) {
248: if (casesp->deftree != NULL)
249: lerr(LINE(t), "more than one default clause");
250: else
251: casesp->deftree = TREE1(t);
252: }
253: else { /* case clause */
254: lab = alclab(1);
255: emitl("mark", lab);
256: loopsp->markcount++;
257: emit("ccase");
258: traverse(TREE0(t)); /* evaluate selector */
259: setline(LINE(t));
260: emit("eqv");
261: loopsp->markcount--;
262: emitn("unmark", 1);
263: emit("pop");
264: traverse(TREE1(t)); /* evaluate expression */
265: emitl("goto", casesp->endlab); /* goto end label */
266: emitlab(lab); /* label for next clause */
267: }
268: break;
269:
270: case N_CLIST: /* list of case clauses */
271: traverse(TREE0(t));
272: traverse(TREE1(t));
273: break;
274:
275: case N_CONJ: /* conjunction */
276: if (VAL0(TREE0(t)) == AUGAND)
277: emit("pnull");
278: traverse(TREE1(t));
279: if (VAL0(TREE0(t)) != AUGAND)
280: emit("pop");
281: traverse(TREE2(t));
282: if (VAL0(TREE0(t)) == AUGAND)
283: emit("asgn");
284: break;
285:
286: case N_CREATE: /* create expression */
287: creatsp++;
288: creatsp->nextlab = loopsp->nextlab;
289: creatsp->breaklab = loopsp->breaklab;
290: loopsp->nextlab = 0; /* make break and next illegal */
291: loopsp->breaklab = 0;
292: lab = alclab(3);
293: emitl("goto", lab+2); /* skip over code for coexpression */
294: emitlab(lab); /* entry point */
295: emit("pop"); /* pop the result from activation */
296: emitl("mark", lab+1);
297: loopsp->markcount++;
298: traverse(TREE0(t)); /* traverse code for coexpression */
299: loopsp->markcount--;
300: emit("incres"); /* increment number of results */
301: setline(LINE(t));
302: emit("coret"); /* return to activator */
303: emit("efail"); /* drive coexpression */
304: emitlab(lab+1); /* loop on exhaustion */
305: setline(0);
306: setline(LINE(t));
307: emit("cofail"); /* and fail each time */
308: emitl("goto", lab+1);
309: emitlab(lab+2);
310: setline(0);
311: setline(LINE(t));
312: emitl("create", lab); /* create entry block */
313: loopsp->nextlab = creatsp->nextlab; /* legalize break and next */
314: loopsp->breaklab = creatsp->breaklab;
315: creatsp--;
316: break;
317:
318: case N_CSET: /* cset literal */
319: emitn("cset", VAL0(t));
320: break;
321:
322: case N_ELIST: /* expression list */
323: n = traverse(TREE0(t));
324: n += traverse(TREE1(t));
325: break;
326:
327: case N_EMPTY: /* a missing expression */
328: emit("pnull");
329: break;
330:
331: case N_FIELD: /* field reference */
332: emit("pnull");
333: traverse(TREE0(t));
334: setline(LINE(t));
335: emits("field", STR0(TREE1(t)));
336: break;
337:
338: case N_ID: /* identifier */
339: emitn("var", VAL0(t));
340: break;
341:
342: case N_IF: /* if expression */
343: if (TYPE(TREE2(t)) == N_EMPTY)
344: lab = 0;
345: else
346: lab = alclab(2);
347: emitl("mark", lab);
348: loopsp->markcount++;
349: traverse(TREE0(t));
350: loopsp->markcount--;
351: emitn("unmark", 1);
352: traverse(TREE1(t));
353: if (lab > 0) {
354: emitl("goto", lab+1);
355: emitlab(lab);
356: traverse(TREE2(t));
357: emitlab(lab+1);
358: }
359: break;
360:
361: case N_INT: /* integer literal */
362: emitn("int", VAL0(t));
363: break;
364:
365: case N_INVOK: /* procedure call, possibly MGDE */
366: if (TYPE(TREE0(t)) != N_EMPTY)
367: traverse(TREE0(t));
368: else
369: emit("pushn1"); /* assume -1(e1,...,en) */
370: n = traverse(TREE1(t));
371: setline(LINE(t));
372: emitn("invoke", n);
373: n = 1;
374: break;
375:
376: case N_KEY: /* keyword reference */
377: setline(LINE(t));
378: emitn("keywd", VAL0(t));
379: break;
380:
381: case N_LIMIT: /* limitation */
382: traverse(TREE1(t));
383: setline(LINE(t));
384: emit("limit");
385: emitl("mark", 0);
386: loopsp->markcount++;
387: traverse(TREE0(t));
388: loopsp->markcount--;
389: emit("lsusp");
390: break;
391:
392: case N_LIST: /* list construction */
393: emit("pnull");
394: if (TYPE(TREE0(t)) == N_EMPTY)
395: n = 0;
396: else
397: n = traverse(TREE0(t));
398: setline(LINE(t));
399: emitn("llist", n);
400: n = 1;
401: break;
402:
403: case N_LOOP: /* loop */
404: switch (VAL0(TREE0(t))) {
405: case EVERY:
406: lab = alclab(2);
407: loopsp++;
408: loopsp->ltype = EVERY;
409: loopsp->nextlab = lab;
410: loopsp->breaklab = lab + 1;
411: loopsp->markcount = 1;
412: emitl("mark", 0);
413: traverse(TREE1(t));
414: emit("pop");
415: if (TYPE(TREE2(t)) != N_EMPTY) { /* every e1 do e2 */
416: emitl("mark", 0);
417: loopsp->ltype = N_LOOP;
418: loopsp->markcount++;
419: traverse(TREE2(t));
420: loopsp->markcount--;
421: emitn("unmark", 1);
422: }
423: emitlab(loopsp->nextlab);
424: emit("efail");
425: emitlab(loopsp->breaklab);
426: loopsp--;
427: break;
428:
429: case REPEAT:
430: lab = alclab(3);
431: loopsp++;
432: loopsp->ltype = N_LOOP;
433: loopsp->nextlab = lab + 1;
434: loopsp->breaklab = lab + 2;
435: loopsp->markcount = 1;
436: emitlab(lab);
437: setline(0);
438: setline(LINE(t));
439: emitl("mark", lab);
440: traverse(TREE1(t));
441: emitlab(loopsp->nextlab);
442: emitn("unmark", 1);
443: emitl("goto", lab);
444: emitlab(loopsp->breaklab);
445: loopsp--;
446: break;
447:
448: case WHILE:
449: lab = alclab(3);
450: loopsp++;
451: loopsp->ltype = N_LOOP;
452: loopsp->nextlab = lab + 1;
453: loopsp->breaklab = lab + 2;
454: loopsp->markcount = 1;
455: emitlab(lab);
456: setline(0);
457: setline(LINE(t));
458: emitl("mark", 0);
459: traverse(TREE1(t));
460: if (TYPE(TREE2(t)) != N_EMPTY) {
461: emitn("unmark", 1);
462: emitl("mark", lab);
463: traverse(TREE2(t));
464: }
465: emitlab(loopsp->nextlab);
466: emitn("unmark", 1);
467: emitl("goto", lab);
468: emitlab(loopsp->breaklab);
469: loopsp--;
470: break;
471:
472: case UNTIL:
473: lab = alclab(4);
474: loopsp++;
475: loopsp->ltype = N_LOOP;
476: loopsp->nextlab = lab + 2;
477: loopsp->breaklab = lab + 3;
478: loopsp->markcount = 1;
479: emitlab(lab);
480: setline(0);
481: setline(LINE(t));
482: emitl("mark", lab+1);
483: traverse(TREE1(t));
484: emitn("unmark", 1);
485: emit("efail");
486: emitlab(lab+1);
487: emitl("mark", lab);
488: traverse(TREE2(t));
489: emitlab(loopsp->nextlab);
490: emitn("unmark", 1);
491: emitl("goto", lab);
492: emitlab(loopsp->breaklab);
493: loopsp--;
494: break;
495: }
496: break;
497:
498: case N_NEXT: /* next expression */
499: if (loopsp < loopstk || loopsp->nextlab <= 0)
500: lerr(LINE(t), "invalid context for next");
501: else {
502: if (loopsp->ltype != EVERY && loopsp->markcount > 1)
503: emitn("unmark", loopsp->markcount - 1);
504: emitl("goto", loopsp->nextlab);
505: }
506: break;
507:
508: case N_NOT: /* not expression */
509: lab = alclab(1);
510: emitl("mark", lab);
511: loopsp->markcount++;
512: traverse(TREE0(t));
513: loopsp->markcount--;
514: emitn("unmark", 1);
515: emit("efail");
516: emitlab(lab);
517: emit("pnull");
518: break;
519:
520: case N_PROC: /* procedure */
521: loopsp = loopstk;
522: loopsp->nextlab = 0;
523: loopsp->breaklab = 0;
524: loopsp->markcount = 0;
525: casesp = casestk;
526: creatsp = creatstk;
527: fprintf(codefile, "proc %s\n", STR0(TREE0(t)));
528: lout(codefile);
529: cout(codefile);
530: emit("declend");
531: emits("file", *filep);
532: setline(0);
533: setline(LINE(t));
534: if (TYPE(TREE1(t)) != N_EMPTY) {
535: lab = alclab(1);
536: emitl("init?", lab);
537: emitl("mark", lab);
538: traverse(TREE1(t));
539: emitn("unmark", 1);
540: emitlab(lab);
541: }
542: if (TYPE(TREE2(t)) != N_EMPTY)
543: traverse(TREE2(t));
544: setline(LINE(TREE3(t)));
545: emit("pfail");
546: emit("end");
547: if (!silence)
548: fprintf(stderr, " %s (%d/%d)\n", STR0(TREE0(t)),
549: (int *)tfree - (int *)tree, tsize);
550: break;
551:
552: case N_REAL: /* real literal */
553: emitn("real", VAL0(t));
554: break;
555:
556: case N_RET: /* return expression */
557: if (creatsp > creatstk)
558: lerr(LINE(t), "invalid context for return or fail");
559: if (VAL0(TREE0(t)) != FAIL) {
560: lab = alclab(1);
561: emitl("mark", lab);
562: loopsp->markcount++;
563: traverse(TREE1(t));
564: loopsp->markcount--;
565: setline(LINE(t));
566: emit("pret");
567: emitlab(lab);
568: }
569: setline(0);
570: setline(LINE(t));
571: emit("pfail");
572: break;
573:
574: case N_SCAN: /* scanning expression */
575: if (VAL0(TREE0(t)) == SCANASGN)
576: emit("pnull");
577: traverse(TREE1(t));
578: if (VAL0(TREE0(t)) == SCANASGN)
579: emit("sdup");
580: setline(LINE(t));
581: emit("bscan");
582: traverse(TREE2(t));
583: setline(LINE(t));
584: emit("escan");
585: if (VAL0(TREE0(t)) == SCANASGN)
586: emit("asgn");
587: break;
588:
589: case N_SECT: /* section operation */
590: emit("pnull");
591: traverse(TREE1(t));
592: traverse(TREE2(t));
593: if (VAL0(TREE0(t)) == PCOLON || VAL0(TREE0(t)) == MCOLON)
594: emit("dup");
595: traverse(TREE3(t));
596: setline(LINE(TREE0(t)));
597: if (VAL0(TREE0(t)) == PCOLON)
598: emit("plus");
599: else if (VAL0(TREE0(t)) == MCOLON)
600: emit("minus");
601: setline(LINE(t));
602: emit("sect");
603: break;
604:
605: case N_SLIST: /* semicolon separated list of expressions */
606: lab = alclab(1);
607: emitl("mark", lab);
608: loopsp->markcount++;
609: traverse(TREE0(t));
610: loopsp->markcount--;
611: emitn("unmark", 1);
612: emitlab(lab);
613: traverse(TREE1(t));
614: break;
615:
616: case N_STR: /* string literal */
617: emitn("str", VAL0(t));
618: break;
619:
620: case N_SUSP: /* suspension expression */
621: if (creatsp > creatstk)
622: lerr(LINE(t), "invalid context for suspend");
623: emitl("mark", 0);
624: loopsp->markcount++;
625: traverse(TREE0(t));
626: loopsp->markcount--;
627: setline(LINE(t));
628: emit("psusp");
629: emit("efail");
630: break;
631:
632: case N_TO: /* to expression */
633: emit("pnull");
634: traverse(TREE0(t));
635: traverse(TREE1(t));
636: emit("push1");
637: setline(LINE(t));
638: emit("toby");
639: break;
640:
641: case N_TOBY: /* to-by expression */
642: emit("pnull");
643: traverse(TREE0(t));
644: traverse(TREE1(t));
645: traverse(TREE2(t));
646: setline(LINE(t));
647: emit("toby");
648: break;
649:
650: case N_UNOP: /* unary operator */
651: unopa(VAL0(TREE0(t)));
652: traverse(TREE1(t));
653: setline(LINE(t));
654: unopb(VAL0(TREE0(t)));
655: break;
656:
657: default:
658: emitn("?????", TYPE(t));
659: syserr("traverse: undefined node type");
660: }
661: return (n);
662: }
663: /*
664: * binop emits code for binary operators. For non-augmented operators,
665: * the name of operator is emitted. For augmented operators, an "asgn"
666: * is emitted after the name of the operator.
667: */
668: binop(op)
669: int op;
670: {
671: register int asgn;
672: register char *name;
673:
674: asgn = 0;
675: switch (op) {
676:
677: case ASSIGN:
678: name = "asgn";
679: break;
680:
681: case CARETASGN:
682: asgn++;
683: case CARET:
684: name = "power";
685: break;
686:
687: case CONCATASGN:
688: asgn++;
689: case CONCAT:
690: name = "cat";
691: break;
692:
693: case DIFFASGN:
694: asgn++;
695: case DIFF:
696: name = "diff";
697: break;
698:
699: case AUGEQV:
700: asgn++;
701: case EQUIV:
702: name = "eqv";
703: break;
704:
705: case INTERASGN:
706: asgn++;
707: case INTER:
708: name = "inter";
709: break;
710:
711: case LBRACK:
712: name = "subsc";
713: break;
714:
715: case LCONCATASGN:
716: asgn++;
717: case LCONCAT:
718: name = "lconcat";
719: break;
720:
721: case AUGSEQ:
722: asgn++;
723: case LEXEQ:
724: name = "lexeq";
725: break;
726:
727: case AUGSGE:
728: asgn++;
729: case LEXGE:
730: name = "lexge";
731: break;
732:
733: case AUGSGT:
734: asgn++;
735: case LEXGT:
736: name = "lexgt";
737: break;
738:
739: case AUGSLE:
740: asgn++;
741: case LEXLE:
742: name = "lexle";
743: break;
744:
745: case AUGSLT:
746: asgn++;
747: case LEXLT:
748: name = "lexlt";
749: break;
750:
751: case AUGSNE:
752: asgn++;
753: case LEXNE:
754: name = "lexne";
755: break;
756:
757: case MINUSASGN:
758: asgn++;
759: case MINUS:
760: name = "minus";
761: break;
762:
763: case MODASGN:
764: asgn++;
765: case MOD:
766: name = "mod";
767: break;
768:
769: case AUGNEQV:
770: asgn++;
771: case NOTEQUIV:
772: name = "neqv";
773: break;
774:
775: case AUGEQ:
776: asgn++;
777: case NUMEQ:
778: name = "numeq";
779: break;
780:
781: case AUGGE:
782: asgn++;
783: case NUMGE:
784: name = "numge";
785: break;
786:
787: case AUGGT:
788: asgn++;
789: case NUMGT:
790: name = "numgt";
791: break;
792:
793: case AUGLE:
794: asgn++;
795: case NUMLE:
796: name = "numle";
797: break;
798:
799: case AUGLT:
800: asgn++;
801: case NUMLT:
802: name = "numlt";
803: break;
804:
805: case AUGNE:
806: asgn++;
807: case NUMNE:
808: name = "numne";
809: break;
810:
811: case PLUSASGN:
812: asgn++;
813: case PLUS:
814: name = "plus";
815: break;
816:
817: case REVASSIGN:
818: name = "rasgn";
819: break;
820:
821: case REVSWAP:
822: name = "rswap";
823: break;
824:
825: case SLASHASGN:
826: asgn++;
827: case SLASH:
828: name = "div";
829: break;
830:
831: case STARASGN:
832: asgn++;
833: case STAR:
834: name = "mult";
835: break;
836:
837: case SWAP:
838: name = "swap";
839: break;
840:
841: case UNIONASGN:
842: asgn++;
843: case UNION:
844: name = "unioncs";
845: break;
846:
847: default:
848: emitn("?binop", op);
849: syserr("binop: undefined binary operator");
850: }
851: emit(name);
852: if (asgn)
853: emit("asgn");
854: return;
855: }
856: /*
857: * unopa and unopb handle code emission for unary operators. unary operator
858: * sequences that are the same as binary operator sequences are recognized
859: * by the lexical analyzer as binary operators. For example, ~===x means to
860: * do three tab(match(...)) operations and then a cset complement, but the
861: * lexical analyzer sees the operator sequence as the "neqv" binary
862: * operation. unopa and unopb unravel tokens of this form.
863: *
864: * When a N_UNOP node is encountered, unopa is called to emit the necessary
865: * number of "pnull" operations to receive the intermediate results. This
866: * amounts to a pnull for each operation.
867: */
868: unopa(op)
869: int op;
870: {
871: switch (op) {
872: case NOTEQUIV: /* unary ~ and three = operators */
873: emit("pnull");
874: case LEXNE: /* unary ~ and two = operators */
875: case EQUIV: /* three unary = operators */
876: emit("pnull");
877: case NUMNE: /* unary ~ and = operators */
878: case UNION: /* two unary + operators */
879: case DIFF: /* two unary - operators */
880: case LEXEQ: /* two unary = operators */
881: case INTER: /* two unary * operators */
882: emit("pnull");
883: case DOT: /* unary . operator */
884: case BACKSLASH: /* unary \ operator */
885: case BANG: /* unary ! operator */
886: case CARET: /* unary ^ operator */
887: case PLUS: /* unary + operator */
888: case TILDE: /* unary ~ operator */
889: case MINUS: /* unary - operator */
890: case NUMEQ: /* unary = operator */
891: case STAR: /* unary * operator */
892: case QMARK: /* unary ? operator */
893: case SLASH: /* unary / operator */
894: emit("pnull");
895: break;
896: default:
897: syserr("unopa: undefined unary operator");
898: }
899: return;
900: }
901: /*
902: * unopb is the back-end code emitter for unary operators. It emits
903: * the operations represented by the token op. For tokens representing
904: * a single operator, the name of the operator is emitted. For tokens
905: * representing a sequence of operators, recursive calls are used. In
906: * such a case, the operator sequence is "scanned" from right to left
907: * and unopb is called with the token for the appropriate operation.
908: *
909: * For example, consider the sequence of calls and code emission for "~===":
910: * unopb(NOTEQUIV) ~===
911: * unopb(NUMEQ) =
912: * emits "tabmat"
913: * unopb(NUMEQ) =
914: * emits "tabmat"
915: * unopb(NUMEQ) =
916: * emits "tabmat"
917: * emits "compl"
918: */
919: unopb(op)
920: int op;
921: {
922: register char *name;
923:
924: switch (op) {
925:
926: case DOT: /* unary . operator */
927: name = "value";
928: break;
929:
930: case BACKSLASH: /* unary \ operator */
931: name = "nonnull";
932: break;
933:
934: case BANG: /* unary ! operator */
935: name = "bang";
936: break;
937:
938: case CARET: /* unary ^ operator */
939: name = "refresh";
940: break;
941:
942: case UNION: /* two unary + operators */
943: unopb(PLUS);
944: case PLUS: /* unary + operator */
945: name = "number";
946: break;
947:
948: case NOTEQUIV: /* unary ~ and three = operators */
949: unopb(NUMEQ);
950: case LEXNE: /* unary ~ and two = operators */
951: unopb(NUMEQ);
952: case NUMNE: /* unary ~ and = operators */
953: unopb(NUMEQ);
954: case TILDE: /* unary ~ operator (cset compl) */
955: name = "compl";
956: break;
957:
958: case DIFF: /* two unary - operators */
959: unopb(MINUS);
960: case MINUS: /* unary - operator */
961: name = "neg";
962: break;
963:
964: case EQUIV: /* three unary = operators */
965: unopb(NUMEQ);
966: case LEXEQ: /* two unary = operators */
967: unopb(NUMEQ);
968: case NUMEQ: /* unary = operator */
969: name = "tabmat";
970: break;
971:
972: case INTER: /* two unary * operators */
973: unopb(STAR);
974: case STAR: /* unary * operator */
975: name = "size";
976: break;
977:
978: case QMARK: /* unary ? operator */
979: name = "random";
980: break;
981:
982: case SLASH: /* unary / operator */
983: name = "null";
984: break;
985:
986: default:
987: emitn("?unop", op);
988: syserr("unopb: undefined unary operator");
989: }
990: emit(name);
991: return;
992: }
993:
994: /*
995: * setline emits a "line" instruction for line n. A "line" instruction is not
996: * emitted if the last "line" instruction was also for line n.
997: */
998: setline(n)
999: int n;
1000: {
1001: static lastline = 0;
1002:
1003: if (n != lastline) {
1004: lastline = n;
1005: if (n > 0)
1006: emitn("line", n);
1007: }
1008: }
1009: /*
1010: * The emit* routines output ucode to codefile. The various routines are:
1011: *
1012: * emitlab(l) - emit "lab" instruction for label l.
1013: * emit(s) - emit instruction s.
1014: * emitl(s,a) - emit instruction s with reference to label a.
1015: * emitn(s,n) - emit instruction s with numeric operand a.
1016: * emitnl(s,a,b) - emit instruction s with numeric operand a and label b.
1017: * emits(s,a) - emit instruction s with string operand a.
1018: */
1019: emitlab(l)
1020: int l;
1021: {
1022: fprintf(codefile, "lab L%d\n", l);
1023: }
1024:
1025: emit(s)
1026: char *s;
1027: {
1028: fprintf(codefile, "\t%s\n", s);
1029: }
1030:
1031: emitl(s, a)
1032: char *s;
1033: int a;
1034: {
1035: fprintf(codefile, "\t%s\tL%d\n", s, a);
1036: }
1037:
1038: emitn(s, a)
1039: char *s;
1040: int a;
1041: {
1042: fprintf(codefile, "\t%s\t%d\n", s, a);
1043: }
1044:
1045: emitnl(s, a, b)
1046: char *s;
1047: int a, b;
1048: {
1049: fprintf(codefile, "\t%s\t%d,L%d\n", s, a, b);
1050: }
1051:
1052: emits(s, a)
1053: char *s, *a;
1054: {
1055: fprintf(codefile, "\t%s\t%s\n", s, a);
1056: }
1057: /*
1058: * alclab allocates n labels and returns the first. For the interpreter,
1059: * labels are restarted at 1 for each procedure, while in the compiler,
1060: * they start at 1 and increase throughout the entire compilation.
1061: */
1062: alclab(n)
1063: int n;
1064: {
1065: register int lab;
1066:
1067: lab = nextlab;
1068: nextlab += n;
1069: return (lab);
1070: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.