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