![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cgram.y CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 3BSD / cmd / mip|
Return to cgram.y CVS log | Up to [CSRG BSD Unix] / 3BSD / cmd / mip |
1.1 root 1: %term NAME 2
2: %term STRING 3
3: %term ICON 4
4: %term FCON 5
5: %term PLUS 6
6: %term MINUS 8
7: %term MUL 11
8: %term AND 14
9: %term OR 17
10: %term ER 19
11: %term QUEST 21
12: %term COLON 22
13: %term ANDAND 23
14: %term OROR 24
15:
16: /* special interfaces for yacc alone */
17: /* These serve as abbreviations of 2 or more ops:
18: ASOP =, = ops
19: RELOP LE,LT,GE,GT
20: EQUOP EQ,NE
21: DIVOP DIV,MOD
22: SHIFTOP LS,RS
23: ICOP ICR,DECR
24: UNOP NOT,COMPL
25: STROP DOT,STREF
26:
27: */
28: %term ASOP 25
29: %term RELOP 26
30: %term EQUOP 27
31: %term DIVOP 28
32: %term SHIFTOP 29
33: %term INCOP 30
34: %term UNOP 31
35: %term STROP 32
36:
37: /* reserved words, etc */
38: %term TYPE 33
39: %term CLASS 34
40: %term STRUCT 35
41: %term RETURN 36
42: %term GOTO 37
43: %term IF 38
44: %term ELSE 39
45: %term SWITCH 40
46: %term BREAK 41
47: %term CONTINUE 42
48: %term WHILE 43
49: %term DO 44
50: %term FOR 45
51: %term DEFAULT 46
52: %term CASE 47
53: %term SIZEOF 48
54: %term ENUM 49
55:
56:
57: /* little symbols, etc. */
58: /* namely,
59:
60: LP (
61: RP )
62:
63: LC {
64: RC }
65:
66: LB [
67: RB ]
68:
69: CM ,
70: SM ;
71:
72: */
73:
74: %term LP 50
75: %term RP 51
76: %term LC 52
77: %term RC 53
78: %term LB 54
79: %term RB 55
80: %term CM 56
81: %term SM 57
82: %term ASSIGN 58
83:
84: /* at last count, there were 7 shift/reduce, 1 reduce/reduce conflicts
85: /* these involved:
86: if/else
87: recognizing functions in various contexts, including declarations
88: error recovery
89: */
90:
91: %left CM
92: %right ASOP ASSIGN
93: %right QUEST COLON
94: %left OROR
95: %left ANDAND
96: %left OR
97: %left ER
98: %left AND
99: %left EQUOP
100: %left RELOP
101: %left SHIFTOP
102: %left PLUS MINUS
103: %left MUL DIVOP
104: %right UNOP
105: %right INCOP SIZEOF
106: %left LB LP STROP
107: %{
108: # include "mfile1"
109: %}
110:
111: /* define types */
112: %start ext_def_list
113:
114: %type <intval> con_e ifelprefix ifprefix whprefix forprefix doprefix switchpart
115: enum_head str_head name_lp
116: %type <nodep> e .e term attributes oattributes type enum_dcl struct_dcl
117: cast_type null_decl funct_idn declarator fdeclarator nfdeclarator
118: elist
119:
120: %token <intval> CLASS NAME STRUCT RELOP CM DIVOP PLUS MINUS SHIFTOP MUL AND OR ER ANDAND OROR
121: ASSIGN STROP INCOP UNOP ICON
122: %token <nodep> TYPE
123:
124: %%
125:
126: %{
127: static int fake = 0;
128: static char fakename[NCHNAM+1];
129: %}
130:
131: ext_def_list: ext_def_list external_def
132: |
133: =ftnend();
134: ;
135: external_def: data_def
136: ={ curclass = SNULL; blevel = 0; }
137: | error
138: ={ curclass = SNULL; blevel = 0; }
139: ;
140: data_def:
141: oattributes SM
142: ={ $1->op = FREE; }
143: | oattributes init_dcl_list SM
144: ={ $1->op = FREE; }
145: | oattributes fdeclarator {
146: defid( tymerge($1,$2), curclass==STATIC?STATIC:EXTDEF );
147: #ifndef LINT
148: pfstab(stab[$2->rval].sname);
149: #endif
150: } function_body
151: ={
152: if( blevel ) cerror( "function level error" );
153: if( reached ) retstat |= NRETVAL;
154: $1->op = FREE;
155: ftnend();
156: }
157: ;
158:
159: function_body: arg_dcl_list compoundstmt
160: ;
161: arg_dcl_list: arg_dcl_list declaration
162: | ={ blevel = 1; }
163: ;
164:
165: stmt_list: stmt_list statement
166: | /* empty */
167: ={ bccode();
168: locctr(PROG);
169: }
170: ;
171:
172: r_dcl_stat_list : dcl_stat_list attributes SM
173: ={ $2->op = FREE;
174: #ifndef LINT
175: plcstab(blevel);
176: #endif
177: }
178: | dcl_stat_list attributes init_dcl_list SM
179: ={ $2->op = FREE;
180: #ifndef LINT
181: plcstab(blevel);
182: #endif
183: }
184: ;
185:
186: dcl_stat_list : dcl_stat_list attributes SM
187: ={ $2->op = FREE; }
188: | dcl_stat_list attributes init_dcl_list SM
189: ={ $2->op = FREE; }
190: | /* empty */
191: ;
192: declaration: attributes declarator_list SM
193: ={ curclass = SNULL; $1->op = FREE; }
194: | attributes SM
195: ={ curclass = SNULL; $1->op = FREE; }
196: | error SM
197: ={ curclass = SNULL; }
198: ;
199: oattributes: attributes
200: | /* VOID */
201: ={ $$ = mkty(INT,0,INT); curclass = SNULL; }
202: ;
203: attributes: class type
204: ={ $$ = $2; }
205: | type class
206: | class
207: ={ $$ = mkty(INT,0,INT); }
208: | type
209: ={ curclass = SNULL ; }
210: ;
211:
212:
213: class: CLASS
214: ={ curclass = $1; }
215: ;
216:
217: type: TYPE
218: | TYPE TYPE
219: ={ $1->type = types( $1->type, $2->type, UNDEF );
220: $2->op = FREE;
221: }
222: | TYPE TYPE TYPE
223: ={ $1->type = types( $1->type, $2->type, $3->type );
224: $2->op = $3->op = FREE;
225: }
226: | struct_dcl
227: | enum_dcl
228: ;
229:
230: enum_dcl: enum_head LC moe_list optcomma RC
231: ={ $$ = dclstruct($1); }
232: | ENUM NAME
233: ={ $$ = rstruct($2,0); stwart = instruct; }
234: ;
235:
236: enum_head: ENUM
237: ={ $$ = bstruct(-1,0); }
238: | ENUM NAME
239: ={ $$ = bstruct($2,0); }
240: ;
241:
242: moe_list: moe
243: | moe_list CM moe
244: ;
245:
246: moe: NAME
247: ={ moedef( $1 ); }
248: | NAME ASSIGN con_e
249: ={ strucoff = $3; moedef( $1 ); }
250: ;
251:
252: struct_dcl: str_head LC type_dcl_list optsemi RC
253: ={ $$ = dclstruct($1); }
254: | STRUCT NAME
255: ={ $$ = rstruct($2,$1); }
256: ;
257:
258: str_head: STRUCT
259: ={ $$ = bstruct(-1,$1); stwart=0; }
260: | STRUCT NAME
261: ={ $$ = bstruct($2,$1); stwart=0; }
262: ;
263:
264: type_dcl_list: type_declaration
265: | type_dcl_list SM type_declaration
266: ;
267:
268: type_declaration: type declarator_list
269: ={ curclass = SNULL; stwart=0; $1->op = FREE; }
270: | type
271: ={ if( curclass != MOU ){
272: curclass = SNULL;
273: }
274: else {
275: sprintf( fakename, "$%dFAKE", fake++ );
276: defid( tymerge($1, bdty(NAME,NIL,lookup( fakename, SMOS ))), curclass );
277: }
278: stwart = 0;
279: $1->op = FREE;
280: }
281: ;
282:
283:
284: declarator_list: declarator
285: ={ defid( tymerge($<nodep>0,$1), curclass); stwart = instruct; }
286: | declarator_list CM {$<nodep>$=$<nodep>0;} declarator
287: ={ defid( tymerge($<nodep>0,$4), curclass); stwart = instruct; }
288: ;
289: declarator: fdeclarator
290: | nfdeclarator
291: | nfdeclarator COLON con_e
292: %prec CM
293: ={ if( !(instruct&INSTRUCT) ) uerror( "field outside of structure" );
294: if( $3<0 || $3 >= FIELD ){
295: uerror( "illegal field size" );
296: $3 = 1;
297: }
298: defid( tymerge($<nodep>0,$1), FIELD|$3 );
299: $$ = NIL;
300: }
301: | COLON con_e
302: %prec CM
303: ={ if( !(instruct&INSTRUCT) ) uerror( "field outside of structure" );
304: falloc( stab, $2, -1, $<nodep>0 ); /* alignment or hole */
305: $$ = NIL;
306: }
307: | error
308: ={ $$ = NIL; }
309: ;
310:
311: /* int (a)(); is not a function --- sorry! */
312: nfdeclarator: MUL nfdeclarator
313: ={ umul:
314: $$ = bdty( UNARY MUL, $2, 0 ); }
315: | nfdeclarator LP RP
316: ={ uftn:
317: $$ = bdty( UNARY CALL, $1, 0 ); }
318: | nfdeclarator LB RB
319: ={ uary:
320: $$ = bdty( LB, $1, 0 ); }
321: | nfdeclarator LB con_e RB
322: ={ bary:
323: if( (int)$3 <= 0 ) werror( "zero or negative subscript" );
324: $$ = bdty( LB, $1, $3 ); }
325: | NAME
326: ={ $$ = bdty( NAME, NIL, $1 ); }
327: | LP nfdeclarator RP
328: ={ $$=$2; }
329: ;
330: fdeclarator: MUL fdeclarator
331: ={ goto umul; }
332: | fdeclarator LP RP
333: ={ goto uftn; }
334: | fdeclarator LB RB
335: ={ goto uary; }
336: | fdeclarator LB con_e RB
337: ={ goto bary; }
338: | LP fdeclarator RP
339: ={ $$ = $2; }
340: | name_lp name_list RP
341: ={
342: if( blevel!=0 ) uerror("function declaration in bad context");
343: $$ = bdty( UNARY CALL, bdty(NAME,NIL,$1), 0 );
344: stwart = 0;
345: }
346: | name_lp RP
347: ={
348: $$ = bdty( UNARY CALL, bdty(NAME,NIL,$1), 0 );
349: stwart = 0;
350: }
351: ;
352:
353: name_lp: NAME LP
354: ={
355: /* turn off typedefs for argument names */
356: stwart = SEENAME;
357: }
358: ;
359:
360: name_list: NAME
361: ={ ftnarg( $1 ); stwart = SEENAME; }
362: | name_list CM NAME
363: ={ ftnarg( $3 ); stwart = SEENAME; }
364: ;
365: /* always preceeded by attributes: thus the $<nodep>0's */
366: init_dcl_list: init_declarator
367: %prec CM
368: | init_dcl_list CM {$<nodep>$=$<nodep>0;} init_declarator
369: ;
370: /* always preceeded by attributes */
371: xnfdeclarator: nfdeclarator
372: ={ defid( $1 = tymerge($<nodep>0,$1), curclass);
373: beginit($1->rval);
374: }
375: | error
376: ;
377: /* always preceeded by attributes */
378: init_declarator: nfdeclarator
379: ={ nidcl( tymerge($<nodep>0,$1) ); }
380: | fdeclarator
381: ={ defid( tymerge($<nodep>0,$1), uclass(curclass) );
382: }
383: | xnfdeclarator optasgn e
384: %prec CM
385: ={ doinit( $3 );
386: endinit(); }
387: | xnfdeclarator optasgn LC init_list optcomma RC
388: ={ endinit(); }
389: ;
390:
391: init_list: initializer
392: %prec CM
393: | init_list CM initializer
394: ;
395: initializer: e
396: %prec CM
397: ={ doinit( $1 ); }
398: | ibrace init_list optcomma RC
399: ={ irbrace(); }
400: ;
401:
402: optcomma : /* VOID */
403: | CM
404: ;
405:
406: optsemi : /* VOID */
407: | SM
408: ;
409:
410: optasgn : /* VOID */
411: ={ werror( "old-fashioned initialization: use =" ); }
412: | ASSIGN
413: ;
414:
415: ibrace : LC
416: ={ ilbrace(); }
417: ;
418:
419: /* STATEMENTS */
420:
421: compoundstmt: dcmpstmt
422: | cmpstmt
423: ;
424:
425: dcmpstmt: begin r_dcl_stat_list stmt_list RC
426: ={
427: #ifndef LINT
428: prcstab(blevel);
429: #endif
430: --blevel;
431: if( blevel == 1 ) blevel = 0;
432: clearst( blevel );
433: checkst( blevel );
434: autooff = *--psavbc;
435: regvar = *--psavbc;
436: }
437: ;
438:
439: cmpstmt: begin stmt_list RC
440: ={ --blevel;
441: if( blevel == 1 ) blevel = 0;
442: clearst( blevel );
443: checkst( blevel );
444: autooff = *--psavbc;
445: regvar = *--psavbc;
446: }
447: ;
448:
449: begin: LC
450: ={ if( blevel == 1 ) dclargs();
451: ++blevel;
452: if( psavbc > &asavbc[BCSZ-2] ) cerror( "nesting too deep" );
453: *psavbc++ = regvar;
454: *psavbc++ = autooff;
455: }
456: ;
457:
458: statement: e SM
459: ={ ecomp( $1 ); }
460: | compoundstmt
461: | ifprefix statement
462: ={ deflab($1);
463: reached = 1;
464: }
465: | ifelprefix statement
466: ={ if( $1 != NOLAB ){
467: deflab( $1 );
468: reached = 1;
469: }
470: }
471: | whprefix statement
472: ={ branch( contlab );
473: deflab( brklab );
474: if( (flostat&FBRK) || !(flostat&FLOOP)) reached = 1;
475: else reached = 0;
476: resetbc(0);
477: }
478: | doprefix statement WHILE LP e RP SM
479: ={ deflab( contlab );
480: if( flostat & FCONT ) reached = 1;
481: ecomp( buildtree( CBRANCH, buildtree( NOT, $5, NIL ), bcon( $1 ) ) );
482: deflab( brklab );
483: reached = 1;
484: resetbc(0);
485: }
486: | forprefix .e RP statement
487: ={ deflab( contlab );
488: if( flostat&FCONT ) reached = 1;
489: if( $2 ) ecomp( $2 );
490: branch( $1 );
491: deflab( brklab );
492: if( (flostat&FBRK) || !(flostat&FLOOP) ) reached = 1;
493: else reached = 0;
494: resetbc(0);
495: }
496: | switchpart statement
497: ={ if( reached ) branch( brklab );
498: deflab( $1 );
499: swend();
500: deflab(brklab);
501: if( (flostat&FBRK) || !(flostat&FDEF) ) reached = 1;
502: resetbc(FCONT);
503: }
504: | BREAK SM
505: ={ if( brklab == NOLAB ) uerror( "illegal break");
506: else if(reached) branch( brklab );
507: flostat |= FBRK;
508: if( brkflag ) goto rch;
509: reached = 0;
510: }
511: | CONTINUE SM
512: ={ if( contlab == NOLAB ) uerror( "illegal continue");
513: else branch( contlab );
514: flostat |= FCONT;
515: goto rch;
516: }
517: | RETURN SM
518: ={ retstat |= NRETVAL;
519: branch( retlab );
520: rch:
521: if( !reached ) werror( "statement not reached");
522: reached = 0;
523: }
524: | RETURN e SM
525: ={ register NODE *temp;
526: idname = curftn;
527: temp = buildtree( NAME, NIL, NIL );
528: temp->type = DECREF( temp->type );
529: temp = buildtree( RETURN, temp, $2 );
530: /* now, we have the type of the RHS correct */
531: temp->left->op = FREE;
532: temp->op = FREE;
533: ecomp( buildtree( FORCE, temp->right, NIL ) );
534: retstat |= RETVAL;
535: branch( retlab );
536: reached = 0;
537: }
538: | GOTO NAME SM
539: ={ register NODE *q;
540: q = block( FREE, NIL, NIL, INT|ARY, 0, INT );
541: q->rval = idname = $2;
542: defid( q, ULABEL );
543: stab[idname].suse = -lineno;
544: branch( stab[idname].offset );
545: goto rch;
546: }
547: | SM
548: | error SM
549: | error RC
550: | label statement
551: ;
552: label: NAME COLON
553: ={ register NODE *q;
554: q = block( FREE, NIL, NIL, INT|ARY, 0, LABEL );
555: q->rval = $1;
556: defid( q, LABEL );
557: reached = 1;
558: }
559: | CASE e COLON
560: ={ addcase($2);
561: reached = 1;
562: }
563: | DEFAULT COLON
564: ={ reached = 1;
565: adddef();
566: flostat |= FDEF;
567: }
568: ;
569: doprefix: DO
570: ={ savebc();
571: if( !reached ) werror( "loop not entered at top");
572: brklab = getlab();
573: contlab = getlab();
574: deflab( $$ = getlab() );
575: reached = 1;
576: }
577: ;
578: ifprefix: IF LP e RP
579: ={ ecomp( buildtree( CBRANCH, $3, bcon( $$=getlab()) ) ) ;
580: reached = 1;
581: }
582: ;
583: ifelprefix: ifprefix statement ELSE
584: ={ if( reached ) branch( $$ = getlab() );
585: else $$ = NOLAB;
586: deflab( $1 );
587: reached = 1;
588: }
589: ;
590:
591: whprefix: WHILE LP e RP
592: ={ savebc();
593: if( !reached ) werror( "loop not entered at top");
594: if( $3->op == ICON && $3->lval != 0 ) flostat = FLOOP;
595: deflab( contlab = getlab() );
596: reached = 1;
597: brklab = getlab();
598: if( flostat == FLOOP ) tfree( $3 );
599: else ecomp( buildtree( CBRANCH, $3, bcon( brklab) ) );
600: }
601: ;
602: forprefix: FOR LP .e SM .e SM
603: ={ if( $3 ) ecomp( $3 );
604: else if( !reached ) werror( "loop not entered at top");
605: savebc();
606: contlab = getlab();
607: brklab = getlab();
608: deflab( $$ = getlab() );
609: reached = 1;
610: if( $5 ) ecomp( buildtree( CBRANCH, $5, bcon( brklab) ) );
611: else flostat |= FLOOP;
612: }
613: ;
614: switchpart: SWITCH LP e RP
615: ={ savebc();
616: brklab = getlab();
617: ecomp( buildtree( FORCE, $3, NIL ) );
618: branch( $$ = getlab() );
619: swstart();
620: reached = 0;
621: }
622: ;
623: /* EXPRESSIONS */
624: con_e: { $<intval>$=instruct; stwart=instruct=0; } e
625: %prec CM
626: ={ $$ = icons( $2 ); instruct=$<intval>1; }
627: ;
628: .e: e
629: |
630: ={ $$=0; }
631: ;
632: elist: e
633: %prec CM
634: | elist CM e
635: ={ goto bop; }
636: ;
637:
638: e: e RELOP e
639: ={
640: preconf:
641: if( yychar==RELOP||yychar==EQUOP||yychar==AND||yychar==OR||yychar==ER ){
642: precplaint:
643: if( hflag ) werror( "precedence confusion possible: parenthesize!" );
644: }
645: bop:
646: $$ = buildtree( $2, $1, $3 );
647: }
648: | e CM e
649: ={ $2 = COMOP;
650: goto bop;
651: }
652: | e DIVOP e
653: ={ goto bop; }
654: | e PLUS e
655: ={ if(yychar==SHIFTOP) goto precplaint; else goto bop; }
656: | e MINUS e
657: ={ if(yychar==SHIFTOP ) goto precplaint; else goto bop; }
658: | e SHIFTOP e
659: ={ if(yychar==PLUS||yychar==MINUS) goto precplaint; else goto bop; }
660: | e MUL e
661: ={ goto bop; }
662: | e EQUOP e
663: ={ goto preconf; }
664: | e AND e
665: ={ if( yychar==RELOP||yychar==EQUOP ) goto preconf; else goto bop; }
666: | e OR e
667: ={ if(yychar==RELOP||yychar==EQUOP) goto preconf; else goto bop; }
668: | e ER e
669: ={ if(yychar==RELOP||yychar==EQUOP) goto preconf; else goto bop; }
670: | e ANDAND e
671: ={ goto bop; }
672: | e OROR e
673: ={ goto bop; }
674: | e MUL ASSIGN e
675: ={ abop:
676: $$ = buildtree( ASG $2, $1, $4 );
677: }
678: | e DIVOP ASSIGN e
679: ={ goto abop; }
680: | e PLUS ASSIGN e
681: ={ goto abop; }
682: | e MINUS ASSIGN e
683: ={ goto abop; }
684: | e SHIFTOP ASSIGN e
685: ={ goto abop; }
686: | e AND ASSIGN e
687: ={ goto abop; }
688: | e OR ASSIGN e
689: ={ goto abop; }
690: | e ER ASSIGN e
691: ={ goto abop; }
692: | e QUEST e COLON e
693: ={ $$=buildtree(QUEST, $1, buildtree( COLON, $3, $5 ) );
694: }
695: | e ASOP e
696: ={ werror( "old-fashioned assignment operator" ); goto bop; }
697: | e ASSIGN e
698: ={ goto bop; }
699: | term
700: ;
701: term: term INCOP
702: ={ $$ = buildtree( $2, $1, bcon(1) ); }
703: | MUL term
704: ={ ubop:
705: $$ = buildtree( UNARY $1, $2, NIL );
706: }
707: | AND term
708: ={ if( ISFTN($2->type) || ISARY($2->type) ){
709: werror( "& before array or function: ignored" );
710: $$ = $2;
711: }
712: else goto ubop;
713: }
714: | MINUS term
715: ={ goto ubop; }
716: | UNOP term
717: ={
718: $$ = buildtree( $1, $2, NIL );
719: }
720: | INCOP term
721: ={ $$ = buildtree( $1==INCR ? ASG PLUS : ASG MINUS,
722: $2,
723: bcon(1) );
724: }
725: | SIZEOF term
726: ={ $$ = doszof( $2 ); }
727: | LP cast_type RP term %prec INCOP
728: ={ $$ = buildtree( CAST, $2, $4 );
729: $$->left->op = FREE;
730: $$->op = FREE;
731: $$ = $$->right;
732: }
733: | SIZEOF LP cast_type RP %prec SIZEOF
734: ={ $$ = doszof( $3 ); }
735: | term LB e RB
736: ={ $$ = buildtree( UNARY MUL, buildtree( PLUS, $1, $3 ), NIL ); }
737: | funct_idn RP
738: ={ $$=buildtree(UNARY CALL,$1,NIL); }
739: | funct_idn elist RP
740: ={ $$=buildtree(CALL,$1,$2); }
741: | term STROP NAME
742: ={ if( $2 == DOT ){
743: $1 = buildtree( UNARY AND, $1, NIL );
744: }
745: idname = $3;
746: $$ = buildtree( STREF, $1, buildtree( NAME, NIL, NIL ) );
747: }
748: | NAME
749: ={ idname = $1;
750: /* recognize identifiers in initializations */
751: if( blevel==0 && stab[idname].stype == UNDEF ) {
752: register NODE *q;
753: werror( "undeclared initializer name %.8s", stab[idname].sname );
754: q = block( FREE, NIL, NIL, INT, 0, INT );
755: q->rval = idname;
756: defid( q, EXTERN );
757: }
758: $$=buildtree(NAME,NIL,NIL);
759: stab[$1].suse = -lineno;
760: }
761: | ICON
762: ={ $$=bcon(0);
763: $$->lval = lastcon;
764: $$->rval = NONAME;
765: if( $1 ) $$->csiz = $$->type = ctype(LONG);
766: }
767: | FCON
768: ={ $$=buildtree(FCON,NIL,NIL);
769: $$->dval = dcon;
770: }
771: | STRING
772: ={ $$ = getstr(); /* get string contents */ }
773: | LP e RP
774: ={ $$=$2; }
775: ;
776:
777: cast_type: type null_decl
778: ={
779: $$ = tymerge( $1, $2 );
780: $$->op = NAME;
781: $1->op = FREE;
782: }
783: ;
784:
785: null_decl: /* empty */
786: ={ $$ = bdty( NAME, NIL, -1 ); }
787: | LP RP
788: ={ $$ = bdty( UNARY CALL, bdty(NAME,NIL,-1),0); }
789: | LP null_decl RP LP RP
790: ={ $$ = bdty( UNARY CALL, $2, 0 ); }
791: | MUL null_decl
792: ={ goto umul; }
793: | null_decl LB RB
794: ={ goto uary; }
795: | null_decl LB con_e RB
796: ={ goto bary; }
797: | LP null_decl RP
798: ={ $$ = $2; }
799: ;
800:
801: funct_idn: NAME LP
802: ={ if( stab[$1].stype == UNDEF ){
803: register NODE *q;
804: q = block( FREE, NIL, NIL, FTN|INT, 0, INT );
805: q->rval = $1;
806: defid( q, EXTERN );
807: }
808: idname = $1;
809: $$=buildtree(NAME,NIL,NIL);
810: stab[idname].suse = -lineno;
811: }
812: | term LP
813: ;
814: %%
815:
816: NODE *
817: mkty( t, d, s ) unsigned t; {
818: return( block( TYPE, NIL, NIL, t, d, s ) );
819: }
820:
821: NODE *
822: bdty( op, p, v ) NODE *p; {
823: register NODE *q;
824:
825: q = block( op, p, NIL, INT, 0, INT );
826:
827: switch( op ){
828:
829: case UNARY MUL:
830: case UNARY CALL:
831: break;
832:
833: case LB:
834: q->right = bcon(v);
835: break;
836:
837: case NAME:
838: q->rval = v;
839: break;
840:
841: default:
842: cerror( "bad bdty" );
843: }
844:
845: return( q );
846: }
847:
848: dstash( n ){ /* put n into the dimension table */
849: if( curdim >= DIMTABSZ-1 ){
850: cerror( "dimension table overflow");
851: }
852: dimtab[ curdim++ ] = n;
853: }
854:
855: savebc() {
856: if( psavbc > & asavbc[BCSZ-4 ] ){
857: cerror( "whiles, fors, etc. too deeply nested");
858: }
859: *psavbc++ = brklab;
860: *psavbc++ = contlab;
861: *psavbc++ = flostat;
862: *psavbc++ = swx;
863: flostat = 0;
864: }
865:
866: resetbc(mask){
867:
868: swx = *--psavbc;
869: flostat = *--psavbc | (flostat&mask);
870: contlab = *--psavbc;
871: brklab = *--psavbc;
872:
873: }
874:
875: addcase(p) NODE *p; { /* add case to switch */
876:
877: p = optim( p ); /* change enum to ints */
878: if( p->op != ICON ){
879: uerror( "non-constant case expression");
880: return;
881: }
882: if( swp == swtab ){
883: uerror( "case not in switch");
884: return;
885: }
886: if( swp >= &swtab[SWITSZ] ){
887: cerror( "switch table overflow");
888: }
889: swp->sval = p->lval;
890: deflab( swp->slab = getlab() );
891: ++swp;
892: tfree(p);
893: }
894:
895: adddef(){ /* add default case to switch */
896: if( swtab[swx].slab >= 0 ){
897: uerror( "duplicate default in switch");
898: return;
899: }
900: if( swp == swtab ){
901: uerror( "default not inside switch");
902: return;
903: }
904: deflab( swtab[swx].slab = getlab() );
905: }
906:
907: swstart(){
908: /* begin a switch block */
909: if( swp >= &swtab[SWITSZ] ){
910: cerror( "switch table overflow");
911: }
912: swx = swp - swtab;
913: swp->slab = -1;
914: ++swp;
915: }
916:
917: swend(){ /* end a switch block */
918:
919: register struct sw *swbeg, *p, *q, *r, *r1;
920: CONSZ temp;
921: int tempi;
922:
923: swbeg = &swtab[swx+1];
924:
925: /* sort */
926:
927: r1 = swbeg;
928: r = swp-1;
929:
930: while( swbeg < r ){
931: /* bubble largest to end */
932: for( q=swbeg; q<r; ++q ){
933: if( q->sval > (q+1)->sval ){
934: /* swap */
935: r1 = q+1;
936: temp = q->sval;
937: q->sval = r1->sval;
938: r1->sval = temp;
939: tempi = q->slab;
940: q->slab = r1->slab;
941: r1->slab = tempi;
942: }
943: }
944: r = r1;
945: r1 = swbeg;
946: }
947:
948: /* it is now sorted */
949:
950: for( p = swbeg+1; p<swp; ++p ){
951: if( p->sval == (p-1)->sval ){
952: uerror( "duplicate case in switch, %d", tempi=p->sval );
953: return;
954: }
955: }
956:
957: genswitch( swbeg-1, swp-swbeg );
958: swp = swbeg-1;
959: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.