![[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 [Research Unix] / researchv10dc / cmd / icon / src / tran|
Return to code.c CVS log | Up to [Research Unix] / researchv10dc / cmd / icon / src / 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 "sym.h"
9: #include "tstats.h"
10:
11: #ifdef TranStats
12: int TokCount[TokSize];
13: #endif TranStats
14:
15: /*
16: * Code generator parameters.
17: */
18:
19: #define LoopDepth 20 /* max. depth of nested loops */
20: #define CaseDepth 10 /* max. depth of nested case statements */
21: #define CreatDepth 10 /* max. depth of nested create statements */
22:
23: /*
24: * loopstk structures hold information about nested loops.
25: */
26: struct loopstk {
27: int nextlab; /* label for next exit */
28: int breaklab; /* label for break exit */
29: int markcount; /* number of marks */
30: int ltype; /* loop type */
31: };
32:
33: /*
34: * casestk structure hold information about case statements.
35: */
36: struct casestk {
37: int endlab; /* label for exit from case statement */
38: nodeptr deftree; /* pointer to tree for default clause */
39: };
40:
41: /*
42: * creatstk structures hold information about create statements.
43: */
44: struct creatstk {
45: int nextlab; /* previous value of nextlab */
46: int breaklab; /* previous value of breaklab */
47: };
48: static int nextlab; /* next label allocated by alclab() */
49:
50: /*
51: * tree[1-7] construct parse tree nodes with specified values. tfree
52: * points at the next free word in the parse tree space. Nodes are
53: * built by copying argument values into successive locations starting
54: * at tfree. Parameters a and b are line and column information,
55: * while parameters c through f are values to be assigned to n_field[0-3].
56: * Note that this could be done with a single routine; a separate routine
57: * for each node size is used for speed and simplicity.
58: */
59:
60: nodeptr tree1(type)
61: int type;
62: {
63: register nodeptr t;
64:
65: t = tfree;
66: tfree = (nodeptr) ((int *)tfree + 1);
67: if (tfree > tend)
68: syserr("out of tree space");
69: t->n_type = type;
70: return t;
71: }
72:
73: nodeptr tree3(type, a, b)
74: int type, a, b;
75: {
76: register nodeptr t;
77:
78: t = tfree;
79: tfree = (nodeptr) ((int *)tfree + 3);
80: if (tfree > tend)
81: syserr("out of tree space");
82: t->n_type = type;
83: t->n_line = a;
84: t->n_col = b;
85: return t;
86: }
87:
88: nodeptr tree4(type, a, b, c)
89: int type, a, b, c;
90: {
91: register nodeptr t;
92:
93: t = tfree;
94: tfree = (nodeptr) ((int *)tfree + 4);
95: if (tfree > tend)
96: syserr("out of tree space");
97: t->n_type = type;
98: t->n_line = a;
99: t->n_col = b;
100: t->n_field[0].n_val = c;
101: return t;
102: }
103:
104: nodeptr tree5(type, a, b, c, d)
105: int type, a, b, c, d;
106: {
107: register nodeptr t;
108:
109: t = tfree;
110: tfree = (nodeptr) ((int *)tfree + 5);
111: if (tfree > tend)
112: syserr("out of tree space");
113: t->n_type = type;
114: t->n_line = a;
115: t->n_col = b;
116: t->n_field[0].n_val = c;
117: t->n_field[1].n_val = d;
118: return t;
119: }
120:
121: nodeptr tree6(type, a, b, c, d, e)
122: int type, a, b, c, d, e;
123: {
124: register nodeptr t;
125:
126: t = tfree;
127: tfree = (nodeptr) ((int *)tfree + 6);
128: if (tfree > tend)
129: syserr("out of tree space");
130: t->n_type = type;
131: t->n_line = a;
132: t->n_col = b;
133: t->n_field[0].n_val = c;
134: t->n_field[1].n_val = d;
135: t->n_field[2].n_val = e;
136: return t;
137: }
138:
139: nodeptr tree7(type, a, b, c, d, e, f)
140: int type, a, b, c, d, e, f;
141: {
142: register nodeptr t;
143:
144: t = tfree;
145: tfree = (nodeptr) ((int *)tfree + 7);
146: if (tfree > tend)
147: syserr("out of tree space");
148: t->n_type = type;
149: t->n_line = a;
150: t->n_col = b;
151: t->n_field[0].n_val = c;
152: t->n_field[1].n_val = d;
153: t->n_field[2].n_val = e;
154: t->n_field[3].n_val = f;
155: return t;
156: }
157:
158: /*
159: * Clear the tree space by setting the free pointer back to the first word
160: * of the tree space.
161: */
162:
163: treeinit()
164: {
165: tfree = tree;
166: }
167:
168: /*
169: * codegen - traverse tree t, generating code.
170: */
171:
172: codegen(t)
173: nodeptr t;
174: {
175: nextlab = 1;
176: traverse(t);
177: }
178:
179: /*
180: * traverse - traverse tree rooted at t and generate code. This is just
181: * plug and chug code for each of the node types. The tour goes into
182: * some detail about the code generation process, in particular, Appendix
183: * A describes the parse tree nodes.
184: */
185:
186: traverse(t)
187: register nodeptr t;
188: {
189: register int lab, n, i;
190: struct loopstk loopsave;
191: static struct loopstk loopstk[LoopDepth]; /* loop stack */
192: static struct loopstk *loopsp;
193: static struct casestk casestk[CaseDepth]; /* case stack */
194: static struct casestk *casesp;
195: static struct creatstk creatstk[CreatDepth]; /* create stack */
196: static struct creatstk *creatsp;
197:
198: n = 1;
199: switch (Type(t)) {
200:
201: case N_Activat: /* co-expression activation */
202: TokInc(AT);
203: if (Val0(Tree0(t)) == AUGACT) {
204: TokInc(AUGACT);
205: TokDec(AT);
206: emit("pnull");
207: }
208: traverse(Tree2(t)); /* evaluate result expression */
209: if (Val0(Tree0(t)) == AUGACT)
210: emit("sdup");
211: traverse(Tree1(t)); /* evaluate activate expression */
212: setline(Line(t));
213: emit("coact");
214: if (Val0(Tree0(t)) == AUGACT)
215: emit("asgn");
216: break;
217:
218: case N_Alt: /* alternation */
219: TokInc(BAR);
220: lab = alclab(2);
221: emitl("mark", lab);
222: loopsp->markcount++;
223: traverse(Tree0(t)); /* evaluate first alternative */
224: loopsp->markcount--;
225: emit("esusp"); /* and suspend with its result */
226: emitl("goto", lab+1);
227: emitlab(lab);
228: traverse(Tree1(t)); /* evaluate second alternative */
229: emitlab(lab+1);
230: break;
231:
232: case N_Augop: /* augmented assignment */
233: case N_Binop: /* or a binary operator */
234: emit("pnull");
235: traverse(Tree1(t));
236: if (Type(t) == N_Augop)
237: emit("dup");
238: traverse(Tree2(t));
239: setline(Line(t));
240: binop(Val0(Tree0(t)));
241: break;
242:
243: case N_Bar: /* repeated alternation */
244: TokInc(REPALT);
245: lab = alclab(1);
246: emitlab(lab);
247: emit("mark0"); /* fail if expr fails first time */
248: loopsp->markcount++;
249: traverse(Tree0(t)); /* evaluate first alternative */
250: loopsp->markcount--;
251: emitl("chfail", lab); /* change to loop on failure */
252: emit("esusp"); /* suspend result */
253: break;
254:
255: case N_Break: /* break expression */
256: TokInc(BREAK);
257: if (loopsp->breaklab <= 0)
258: lerr(Line(t), "invalid context for break");
259: else {
260: for (i = 0; i < loopsp->markcount; i++)
261: emit("unmark");
262: loopsave = *loopsp--;
263: traverse(Tree0(t));
264: *++loopsp = loopsave;
265: emitl("goto", loopsp->breaklab);
266: }
267: break;
268:
269: case N_Case: /* case expression */
270: TokInc(CASE);
271: lab = alclab(1);
272: casesp++;
273: casesp->endlab = lab;
274: casesp->deftree = NULL;
275: emit("mark0");
276: loopsp->markcount++;
277: traverse(Tree0(t)); /* evaluate control expression */
278: loopsp->markcount--;
279: emit("eret");
280: traverse(Tree1(t)); /* do rest of case (CLIST) */
281: if (casesp->deftree != NULL) { /* evaluate default clause */
282: emit("pop");
283: traverse(casesp->deftree);
284: }
285: else
286: emit("efail");
287: emitlab(lab); /* end label */
288: casesp--;
289: break;
290:
291: case N_Ccls: /* case expression clause */
292: TokInc(CCLS);
293: if (Type(Tree0(t)) == N_Res && /* default clause */
294: Val0(Tree0(t)) == DEFAULT) {
295: if (casesp->deftree != NULL)
296: lerr(Line(t), "more than one default clause");
297: else
298: casesp->deftree = Tree1(t);
299: }
300: else { /* case clause */
301: lab = alclab(1);
302: emitl("mark", lab);
303: loopsp->markcount++;
304: emit("ccase");
305: traverse(Tree0(t)); /* evaluate selector */
306: setline(Line(t));
307: emit("eqv");
308: loopsp->markcount--;
309: emit("unmark");
310: emit("pop");
311: traverse(Tree1(t)); /* evaluate expression */
312: emitl("goto", casesp->endlab); /* goto end label */
313: emitlab(lab); /* label for next clause */
314: }
315: break;
316:
317: case N_Clist: /* list of case clauses */
318: traverse(Tree0(t));
319: traverse(Tree1(t));
320: break;
321:
322: case N_Conj: /* conjunction */
323: TokInc(CONJUNC);
324: if (Val0(Tree0(t)) == AUGAND) {
325: TokInc(AUGAND);
326: TokDec(CONJUNC);
327: emit("pnull");
328: }
329: traverse(Tree1(t));
330: if (Val0(Tree0(t)) != AUGAND)
331: emit("pop");
332: traverse(Tree2(t));
333: if (Val0(Tree0(t)) == AUGAND)
334: emit("asgn");
335: break;
336:
337: case N_Create: /* create expression */
338: TokInc(CREATE);
339: creatsp++;
340: creatsp->nextlab = loopsp->nextlab;
341: creatsp->breaklab = loopsp->breaklab;
342: loopsp->nextlab = 0; /* make break and next illegal */
343: loopsp->breaklab = 0;
344: lab = alclab(3);
345: emitl("goto", lab+2); /* skip over code for co-expression */
346: emitlab(lab); /* entry point */
347: emit("pop"); /* pop the result from activation */
348: emitl("mark", lab+1);
349: loopsp->markcount++;
350: traverse(Tree0(t)); /* traverse code for co-expression */
351: loopsp->markcount--;
352: setline(Line(t));
353: emit("coret"); /* return to activator */
354: emit("efail"); /* drive co-expression */
355: emitlab(lab+1); /* loop on exhaustion */
356: setline(0);
357: setline(Line(t));
358: emit("cofail"); /* and fail each time */
359: emitl("goto", lab+1);
360: emitlab(lab+2);
361: setline(0);
362: setline(Line(t));
363: emitl("create", lab); /* create entry block */
364: loopsp->nextlab = creatsp->nextlab; /* legalize break and next */
365: loopsp->breaklab = creatsp->breaklab;
366: creatsp--;
367: break;
368:
369: case N_Cset: /* cset literal */
370: TokInc(CSETLIT);
371: emitn("cset", Val0(t));
372: break;
373:
374: case N_Elist: /* expression list */
375: n = traverse(Tree0(t));
376: n += traverse(Tree1(t));
377: break;
378:
379: case N_Empty: /* a missing expression */
380: TokInc(EMPTY);
381: emit("pnull");
382: break;
383:
384: case N_Field: /* field reference */
385: TokInc(DOT);
386: emit("pnull");
387: traverse(Tree0(t));
388: setline(Line(t));
389: emits("field", Str0(Tree1(t)));
390: break;
391:
392: case N_Id: /* identifier */
393: TokInc(IDENT);
394: emitn("var", Val0(t));
395: break;
396:
397: case N_If: /* if expression */
398: if (Type(Tree2(t)) == N_Empty) {
399: TokInc(IF);
400: lab = 0;
401: emit("mark0");
402: }
403: else {
404: TokInc(ELSE);
405: lab = alclab(2);
406: emitl("mark", lab);
407: }
408: loopsp->markcount++;
409: traverse(Tree0(t));
410: loopsp->markcount--;
411: emit("unmark");
412: traverse(Tree1(t));
413: if (lab > 0) {
414: emitl("goto", lab+1);
415: emitlab(lab);
416: traverse(Tree2(t));
417: emitlab(lab+1);
418: }
419: break;
420:
421: case N_Int: /* integer literal */
422: TokInc(INTLIT);
423: emitn("int", Val0(t));
424: break;
425:
426: case N_Invok: /* invocation */
427: if (Type(Tree0(t)) != N_Empty) {
428: TokInc(INVOKE);
429: traverse(Tree0(t));
430: }
431: else {
432: TokInc(LPAREN);
433: emit("pushn1"); /* assume -1(e1,...,en) */
434: }
435: n = traverse(Tree1(t));
436: setline(Line(t));
437: emitn("invoke", n);
438: n = 1;
439: break;
440:
441: case N_Key: /* keyword reference */
442: TokInc(KEYWORD);
443: setline(Line(t));
444: emitn("keywd", Val0(t));
445: break;
446:
447: case N_Limit: /* limitation */
448: TokInc(BACKSLASH);
449: traverse(Tree1(t));
450: setline(Line(t));
451: emit("limit");
452: loopsp->markcount++;
453: traverse(Tree0(t));
454: loopsp->markcount--;
455: emit("lsusp");
456: break;
457:
458: case N_List: /* list construction */
459: TokInc(LIST);
460: emit("pnull");
461: if (Type(Tree0(t)) == N_Empty)
462: n = 0;
463: else
464: n = traverse(Tree0(t));
465: setline(Line(t));
466: emitn("llist", n);
467: n = 1;
468: break;
469:
470: case N_Loop: /* loop */
471: switch (Val0(Tree0(t))) {
472: case EVERY:
473: TokInc(EVERY);
474: lab = alclab(2);
475: loopsp++;
476: loopsp->ltype = EVERY;
477: loopsp->nextlab = lab;
478: loopsp->breaklab = lab + 1;
479: loopsp->markcount = 1;
480: emit("mark0");
481: traverse(Tree1(t));
482: emit("pop");
483: if (Type(Tree2(t)) != N_Empty) { /* every e1 do e2 */
484: emit("mark0");
485: loopsp->ltype = N_Loop;
486: loopsp->markcount++;
487: traverse(Tree2(t));
488: loopsp->markcount--;
489: emit("unmark");
490: }
491: emitlab(loopsp->nextlab);
492: emit("efail");
493: emitlab(loopsp->breaklab);
494: loopsp--;
495: break;
496:
497: case REPEAT:
498: TokInc(REPEAT);
499: lab = alclab(3);
500: loopsp++;
501: loopsp->ltype = N_Loop;
502: loopsp->nextlab = lab + 1;
503: loopsp->breaklab = lab + 2;
504: loopsp->markcount = 1;
505: emitlab(lab);
506: setline(0);
507: setline(Line(t));
508: emitl("mark", lab);
509: traverse(Tree1(t));
510: emitlab(loopsp->nextlab);
511: emit("unmark");
512: emitl("goto", lab);
513: emitlab(loopsp->breaklab);
514: loopsp--;
515: break;
516:
517: case WHILE:
518: TokInc(WHILE);
519: lab = alclab(3);
520: loopsp++;
521: loopsp->ltype = N_Loop;
522: loopsp->nextlab = lab + 1;
523: loopsp->breaklab = lab + 2;
524: loopsp->markcount = 1;
525: emitlab(lab);
526: setline(0);
527: setline(Line(t));
528: emit("mark0");
529: traverse(Tree1(t));
530: if (Type(Tree2(t)) != N_Empty) {
531: emit("unmark");
532: emitl("mark", lab);
533: traverse(Tree2(t));
534: }
535: emitlab(loopsp->nextlab);
536: emit("unmark");
537: emitl("goto", lab);
538: emitlab(loopsp->breaklab);
539: loopsp--;
540: break;
541:
542: case UNTIL:
543: TokInc(UNTIL);
544: lab = alclab(4);
545: loopsp++;
546: loopsp->ltype = N_Loop;
547: loopsp->nextlab = lab + 2;
548: loopsp->breaklab = lab + 3;
549: loopsp->markcount = 1;
550: emitlab(lab);
551: setline(0);
552: setline(Line(t));
553: emitl("mark", lab+1);
554: traverse(Tree1(t));
555: emit("unmark");
556: emit("efail");
557: emitlab(lab+1);
558: emitl("mark", lab);
559: traverse(Tree2(t));
560: emitlab(loopsp->nextlab);
561: emit("unmark");
562: emitl("goto", lab);
563: emitlab(loopsp->breaklab);
564: loopsp--;
565: break;
566: }
567: break;
568:
569: case N_Next: /* next expression */
570: TokInc(NEXT);
571: if (loopsp < loopstk || loopsp->nextlab <= 0)
572: lerr(Line(t), "invalid context for next");
573: else {
574: if (loopsp->ltype != EVERY && loopsp->markcount > 1)
575: for (i = 0; i < loopsp->markcount - 1; i++)
576: emit("unmark");
577: emitl("goto", loopsp->nextlab);
578: }
579: break;
580:
581: case N_Not: /* not expression */
582: TokInc(NOT);
583: lab = alclab(1);
584: emitl("mark", lab);
585: loopsp->markcount++;
586: traverse(Tree0(t));
587: loopsp->markcount--;
588: emit("unmark");
589: emit("efail");
590: emitlab(lab);
591: emit("pnull");
592: break;
593:
594: case N_Proc: /* procedure */
595: TokInc(PROCEDURE);
596: loopsp = loopstk;
597: loopsp->nextlab = 0;
598: loopsp->breaklab = 0;
599: loopsp->markcount = 0;
600: casesp = casestk;
601: creatsp = creatstk;
602: fprintf(codefile, "proc %s\n", Str0(Tree0(t)));
603: lout(codefile);
604: cout(codefile);
605: emits("filen", *filep);
606: emit("declend");
607: setline(0);
608: setline(Line(t));
609: if (Type(Tree1(t)) != N_Empty) {
610: lab = alclab(1);
611: emitl("init", lab);
612: emitl("mark", lab);
613: traverse(Tree1(t));
614: emit("unmark");
615: emitlab(lab);
616: }
617: if (Type(Tree2(t)) != N_Empty)
618: traverse(Tree2(t));
619: setline(Line(Tree3(t)));
620: emit("pfail");
621: emit("end");
622: if (!silence)
623: fprintf(stderr, " %s (%d/%d)\n", Str0(Tree0(t)),
624: (int *)tfree - (int *)tree, tsize);
625: break;
626:
627: case N_Real: /* real literal */
628: TokInc(REALLIT);
629: emitn("real", Val0(t));
630: break;
631:
632: case N_Ret: /* return expression */
633: TokInc(RETURN);
634: if (creatsp > creatstk)
635: lerr(Line(t), "invalid context for return or fail");
636: if (Val0(Tree0(t)) != FAIL) {
637: lab = alclab(1);
638: emitl("mark", lab);
639: loopsp->markcount++;
640: traverse(Tree1(t));
641: loopsp->markcount--;
642: setline(Line(t));
643: emit("pret");
644: emitlab(lab);
645: }
646: setline(0);
647: setline(Line(t));
648: emit("pfail");
649: break;
650:
651: case N_Scan: /* scanning expression */
652: TokInc(QMARK);
653: if (Val0(Tree0(t)) == SCANASGN)
654: emit("pnull");
655: traverse(Tree1(t));
656: if (Val0(Tree0(t)) == SCANASGN)
657: emit("sdup");
658: setline(Line(t));
659: emit("bscan");
660: traverse(Tree2(t));
661: setline(Line(t));
662: emit("escan");
663: if (Val0(Tree0(t)) == SCANASGN)
664: emit("asgn");
665: break;
666:
667: case N_Sect: /* section operation */
668: TokInc(SECTION);
669: emit("pnull");
670: traverse(Tree1(t));
671: traverse(Tree2(t));
672: if (Val0(Tree0(t)) == PCOLON || Val0(Tree0(t)) == MCOLON)
673: emit("dup");
674: traverse(Tree3(t));
675: setline(Line(Tree0(t)));
676: if (Val0(Tree0(t)) == PCOLON)
677: emit("plus");
678: else if (Val0(Tree0(t)) == MCOLON)
679: emit("minus");
680: setline(Line(t));
681: emit("sect");
682: break;
683:
684: case N_Slist: /* semicolon separated list of expressions */
685: TokInc(COMPOUND);
686: lab = alclab(1);
687: emitl("mark", lab);
688: loopsp->markcount++;
689: traverse(Tree0(t));
690: loopsp->markcount--;
691: emit("unmark");
692: emitlab(lab);
693: traverse(Tree1(t));
694: break;
695:
696: case N_Str: /* string literal */
697: TokInc(STRINGLIT);
698: emitn("str", Val0(t));
699: break;
700:
701: case N_Susp: /* suspension expression */
702: TokInc(SUSPEND);
703: if (creatsp > creatstk)
704: lerr(Line(t), "invalid context for suspend");
705: emit("mark0");
706: loopsp->markcount++;
707: traverse(Tree0(t));
708: loopsp->markcount--;
709: setline(Line(t));
710: emit("psusp");
711: emit("efail");
712: break;
713:
714: case N_To: /* to expression */
715: TokInc(TO);
716: emit("pnull");
717: traverse(Tree0(t));
718: traverse(Tree1(t));
719: emit("push1");
720: setline(Line(t));
721: emit("toby");
722: break;
723:
724: case N_ToBy: /* to-by expression */
725: TokInc(BY);
726: emit("pnull");
727: traverse(Tree0(t));
728: traverse(Tree1(t));
729: traverse(Tree2(t));
730: setline(Line(t));
731: emit("toby");
732: break;
733:
734: case N_Unop: /* unary operator */
735: unopa(Val0(Tree0(t)));
736: traverse(Tree1(t));
737: setline(Line(t));
738: unopb(Val0(Tree0(t)));
739: break;
740:
741: default:
742: emitn("?????", Type(t));
743: syserr("traverse: undefined node type");
744: }
745: return n;
746: }
747: /*
748: * binop emits code for binary operators. For non-augmented operators,
749: * the name of operator is emitted. For augmented operators, an "asgn"
750: * is emitted after the name of the operator.
751: */
752: binop(op)
753: int op;
754: {
755: register int asgn;
756: register char *name;
757:
758: asgn = 0;
759: switch (op) {
760:
761: case ASSIGN:
762: TokInc(ASSIGN);
763: name = "asgn";
764: break;
765:
766: case CARETASGN:
767: TokInc(CARETASGN);
768: TokDec(CARET);
769: asgn++;
770: case CARET:
771: TokInc(CARET);
772: name = "power";
773: break;
774:
775: case CONCATASGN:
776: TokInc(CONCATASGN);
777: TokDec(CONCAT);
778: asgn++;
779: case CONCAT:
780: TokInc(CONCAT);
781: name = "cat";
782: break;
783:
784: case DIFFASGN:
785: TokInc(DIFFASGN);
786: TokDec(DIFF);
787: asgn++;
788: case DIFF:
789: TokInc(DIFF);
790: name = "diff";
791: break;
792:
793: case AUGEQV:
794: TokInc(AUGEQV);
795: TokDec(EQUIV);
796: asgn++;
797: case EQUIV:
798: TokInc(EQUIV);
799: name = "eqv";
800: break;
801:
802: case INTERASGN:
803: TokInc(INTERASGN);
804: TokDec(INTER);
805: asgn++;
806: case INTER:
807: TokInc(INTER);
808: name = "inter";
809: break;
810:
811: case LBRACK:
812: TokInc(LBRACK);
813: name = "subsc";
814: break;
815:
816: case LCONCATASGN:
817: TokInc(LCONCATASGN);
818: TokDec(LCONCAT);
819: asgn++;
820: case LCONCAT:
821: TokInc(LCONCAT);
822: name = "lconcat";
823: break;
824:
825: case AUGSEQ:
826: TokInc(AUGSEQ);
827: TokDec(LEXEQ);
828: asgn++;
829: case LEXEQ:
830: TokInc(LEXEQ);
831: name = "lexeq";
832: break;
833:
834: case AUGSGE:
835: TokInc(AUGSGE);
836: TokDec(LEXGE);
837: asgn++;
838: case LEXGE:
839: TokInc(LEXGE);
840: name = "lexge";
841: break;
842:
843: case AUGSGT:
844: TokInc(AUGSGT);
845: TokDec(LEXGT);
846: asgn++;
847: case LEXGT:
848: TokInc(LEXGT);
849: name = "lexgt";
850: break;
851:
852: case AUGSLE:
853: TokInc(AUGSLE);
854: TokDec(LEXLE);
855: asgn++;
856: case LEXLE:
857: TokInc(LEXLE);
858: name = "lexle";
859: break;
860:
861: case AUGSLT:
862: TokInc(AUGSLT);
863: TokDec(LEXLT);
864: asgn++;
865: case LEXLT:
866: TokInc(LEXLT);
867: name = "lexlt";
868: break;
869:
870: case AUGSNE:
871: TokInc(AUGSNE);
872: TokDec(LEXNE);
873: asgn++;
874: case LEXNE:
875: TokInc(LEXNE);
876: name = "lexne";
877: break;
878:
879: case MINUSASGN:
880: TokInc(MINUSASGN);
881: TokDec(MINUS);
882: asgn++;
883: case MINUS:
884: TokInc(MINUS);
885: name = "minus";
886: break;
887:
888: case MODASGN:
889: TokInc(MODASGN);
890: TokDec(MOD);
891: asgn++;
892: case MOD:
893: TokInc(MOD);
894: name = "mod";
895: break;
896:
897: case AUGNEQV:
898: TokInc(AUGNEQV);
899: TokDec(NOTEQUIV);
900: asgn++;
901: case NOTEQUIV:
902: TokInc(NOTEQUIV);
903: name = "neqv";
904: break;
905:
906: case AUGEQ:
907: TokInc(AUGEQ);
908: TokDec(NUMEQ);
909: asgn++;
910: case NUMEQ:
911: TokInc(NUMEQ);
912: name = "numeq";
913: break;
914:
915: case AUGGE:
916: TokInc(AUGGE);
917: TokDec(NUMGE);
918: asgn++;
919: case NUMGE:
920: TokInc(NUMGE);
921: name = "numge";
922: break;
923:
924: case AUGGT:
925: TokInc(AUGGT);
926: TokDec(NUMGT);
927: asgn++;
928: case NUMGT:
929: TokInc(NUMGT);
930: name = "numgt";
931: break;
932:
933: case AUGLE:
934: TokInc(AUGLE);
935: TokDec(NUMLE);
936: asgn++;
937: case NUMLE:
938: TokInc(NUMLE);
939: name = "numle";
940: break;
941:
942: case AUGLT:
943: TokInc(AUGLT);
944: TokDec(NUMLT);
945: asgn++;
946: case NUMLT:
947: TokInc(NUMLT);
948: name = "numlt";
949: break;
950:
951: case AUGNE:
952: TokInc(AUGNE);
953: TokDec(NUMNE);
954: asgn++;
955: case NUMNE:
956: TokInc(NUMNE);
957: name = "numne";
958: break;
959:
960: case PLUSASGN:
961: TokInc(PLUSASGN);
962: TokDec(PLUS);
963: asgn++;
964: case PLUS:
965: TokInc(PLUS);
966: name = "plus";
967: break;
968:
969: case REVASSIGN:
970: TokInc(REVASSIGN);
971: name = "rasgn";
972: break;
973:
974: case REVSWAP:
975: TokInc(REVSWAP);
976: name = "rswap";
977: break;
978:
979: case SLASHASGN:
980: TokInc(SLASHASGN);
981: TokDec(SLASH);
982: asgn++;
983: case SLASH:
984: TokInc(SLASH);
985: name = "div";
986: break;
987:
988: case STARASGN:
989: TokInc(STARASGN);
990: TokDec(STAR);
991: asgn++;
992: case STAR:
993: TokInc(STAR);
994: name = "mult";
995: break;
996:
997: case SWAP:
998: TokInc(SWAP);
999: name = "swap";
1000: break;
1001:
1002: case UNIONASGN:
1003: TokInc(UNIONASGN);
1004: TokDec(UNION);
1005: asgn++;
1006: case UNION:
1007: TokInc(UNION);
1008: name = "unions";
1009: break;
1010:
1011: default:
1012: emitn("?binop", op);
1013: syserr("binop: undefined binary operator");
1014: }
1015: emit(name);
1016: if (asgn)
1017: emit("asgn");
1018: return;
1019: }
1020: /*
1021: * unopa and unopb handle code emission for unary operators. unary operator
1022: * sequences that are the same as binary operator sequences are recognized
1023: * by the lexical analyzer as binary operators. For example, ~===x means to
1024: * do three tab(match(...)) operations and then a cset complement, but the
1025: * lexical analyzer sees the operator sequence as the "neqv" binary
1026: * operation. unopa and unopb unravel tokens of this form.
1027: *
1028: * When a N_Unop node is encountered, unopa is called to emit the necessary
1029: * number of "pnull" operations to receive the intermediate results. This
1030: * amounts to a pnull for each operation.
1031: */
1032: unopa(op)
1033: int op;
1034: {
1035: switch (op) {
1036: case NOTEQUIV: /* unary ~ and three = operators */
1037: emit("pnull");
1038: case LEXNE: /* unary ~ and two = operators */
1039: case EQUIV: /* three unary = operators */
1040: emit("pnull");
1041: case NUMNE: /* unary ~ and = operators */
1042: case UNION: /* two unary + operators */
1043: case DIFF: /* two unary - operators */
1044: case LEXEQ: /* two unary = operators */
1045: case INTER: /* two unary * operators */
1046: emit("pnull");
1047: case DOT: /* unary . operator */
1048: case BACKSLASH: /* unary \ operator */
1049: case BANG: /* unary ! operator */
1050: case CARET: /* unary ^ operator */
1051: case PLUS: /* unary + operator */
1052: case TILDE: /* unary ~ operator */
1053: case MINUS: /* unary - operator */
1054: case NUMEQ: /* unary = operator */
1055: case STAR: /* unary * operator */
1056: case QMARK: /* unary ? operator */
1057: case SLASH: /* unary / operator */
1058: emit("pnull");
1059: break;
1060: default:
1061: syserr("unopa: undefined unary operator");
1062: }
1063: return;
1064: }
1065: /*
1066: * unopb is the back-end code emitter for unary operators. It emits
1067: * the operations represented by the token op. For tokens representing
1068: * a single operator, the name of the operator is emitted. For tokens
1069: * representing a sequence of operators, recursive calls are used. In
1070: * such a case, the operator sequence is "scanned" from right to left
1071: * and unopb is called with the token for the appropriate operation.
1072: *
1073: * For example, consider the sequence of calls and code emission for "~===":
1074: * unopb(NOTEQUIV) ~===
1075: * unopb(NUMEQ) =
1076: * emits "tabmat"
1077: * unopb(NUMEQ) =
1078: * emits "tabmat"
1079: * unopb(NUMEQ) =
1080: * emits "tabmat"
1081: * emits "compl"
1082: */
1083: unopb(op)
1084: int op;
1085: {
1086: register char *name;
1087:
1088: switch (op) {
1089:
1090: case DOT: /* unary . operator */
1091: TokInc(UDOT);
1092: name = "value";
1093: break;
1094:
1095: case BACKSLASH: /* unary \ operator */
1096: TokInc(UBACK);
1097: name = "nonnull";
1098: break;
1099:
1100: case BANG: /* unary ! operator */
1101: TokInc(BANG);
1102: name = "bang";
1103: break;
1104:
1105: case CARET: /* unary ^ operator */
1106: TokInc(UCARET);
1107: name = "refresh";
1108: break;
1109:
1110: case UNION: /* two unary + operators */
1111: TokInc(UPLUS);
1112: unopb(PLUS);
1113: case PLUS: /* unary + operator */
1114: TokInc(UPLUS);
1115: name = "number";
1116: break;
1117:
1118: case NOTEQUIV: /* unary ~ and three = operators */
1119: TokInc(UEQUAL);
1120: unopb(NUMEQ);
1121: TokInc(UEQUAL);
1122: case LEXNE: /* unary ~ and two = operators */
1123: TokInc(UEQUAL);
1124: unopb(NUMEQ);
1125: case NUMNE: /* unary ~ and = operators */
1126: TokInc(UEQUAL);
1127: unopb(NUMEQ);
1128: case TILDE: /* unary ~ operator (cset compl) */
1129: TokInc(TILDE);
1130: name = "compl";
1131: break;
1132:
1133: case DIFF: /* two unary - operators */
1134: TokInc(UMINUS);
1135: unopb(MINUS);
1136: case MINUS: /* unary - operator */
1137: TokInc(UMINUS);
1138: name = "neg";
1139: break;
1140:
1141: case EQUIV: /* three unary = operators */
1142: TokInc(UEQUAL);
1143: unopb(NUMEQ);
1144: case LEXEQ: /* two unary = operators */
1145: TokInc(UEQUAL);
1146: unopb(NUMEQ);
1147: case NUMEQ: /* unary = operator */
1148: TokInc(UEQUAL);
1149: name = "tabmat";
1150: break;
1151:
1152: case INTER: /* two unary * operators */
1153: TokInc(USTAR);
1154: unopb(STAR);
1155: case STAR: /* unary * operator */
1156: TokInc(USTAR);
1157: name = "size";
1158: break;
1159:
1160: case QMARK: /* unary ? operator */
1161: TokInc(UQUES);
1162: name = "random";
1163: break;
1164:
1165: case SLASH: /* unary / operator */
1166: TokInc(USLASH);
1167: name = "null";
1168: break;
1169:
1170: default:
1171: emitn("?unop", op);
1172: syserr("unopb: undefined unary operator");
1173: }
1174: emit(name);
1175: return;
1176: }
1177:
1178: /*
1179: * setline emits a "line" instruction for line n. A "line" instruction is not
1180: * emitted if the last "line" instruction was also for line n.
1181: */
1182: setline(n)
1183: int n;
1184: {
1185: static lastline = 0;
1186:
1187: if (n != lastline) {
1188: lastline = n;
1189: if (n > 0)
1190: emitn("line", n);
1191: }
1192: }
1193: /*
1194: * The emit* routines output ucode to codefile. The various routines are:
1195: *
1196: * emitlab(l) - emit "lab" instruction for label l.
1197: * emit(s) - emit instruction s.
1198: * emitl(s,a) - emit instruction s with reference to label a.
1199: * emitn(s,n) - emit instruction s with numeric operand a.
1200: * emitnl(s,a,b) - emit instruction s with numeric operand a and label b.
1201: * emits(s,a) - emit instruction s with string operand a.
1202: */
1203: emitlab(l)
1204: int l;
1205: {
1206: fprintf(codefile, "lab L%d\n", l);
1207: }
1208:
1209: emit(s)
1210: char *s;
1211: {
1212: fprintf(codefile, "\t%s\n", s);
1213: }
1214:
1215: emitl(s, a)
1216: char *s;
1217: int a;
1218: {
1219: fprintf(codefile, "\t%s\tL%d\n", s, a);
1220: }
1221:
1222: emitn(s, a)
1223: char *s;
1224: int a;
1225: {
1226: fprintf(codefile, "\t%s\t%d\n", s, a);
1227: }
1228:
1229: emitnl(s, a, b)
1230: char *s;
1231: int a, b;
1232: {
1233: fprintf(codefile, "\t%s\t%d,L%d\n", s, a, b);
1234: }
1235:
1236: emits(s, a)
1237: char *s, *a;
1238: {
1239: fprintf(codefile, "\t%s\t%s\n", s, a);
1240: }
1241: /*
1242: * alclab allocates n labels and returns the first. For the interpreter,
1243: * labels are restarted at 1 for each procedure, while in the compiler,
1244: * they start at 1 and increase throughout the entire compilation.
1245: */
1246: alclab(n)
1247: int n;
1248: {
1249: register int lab;
1250:
1251: lab = nextlab;
1252: nextlab += n;
1253: return lab;
1254: }
1255:
1256: #ifdef TranStats
1257: tokdump()
1258: {
1259: int i;
1260:
1261: fprintf(stderr,"begin tokdump\n");
1262: for (i = 0; i < TokSize; i++)
1263: fprintf(stderr,"%d\n",TokCount[i]);
1264: fprintf(stderr,"end tokdump\n");
1265: fflush(stderr);
1266: }
1267: #endif TranStats
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.