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