![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gram.y CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / cfront / ocfront|
Return to gram.y CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / ocfront |
1.1 root 1: /*ident "@(#)ctrans:src/gram.y 1.6.5.35" */
2: /*************************************************************************
3:
4: C++ source for cfront, the C++ compiler front-end
5: written in the computer science research center of Bell Labs
6:
7: Copyright (c) 1984 AT&T, Inc. All Rights Reserved
8: THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC.
9:
10: gram.y:
11:
12: This is the C++ syntax analyser.
13:
14: Syntax extensions for error handling:
15: nested functions
16: any expression can be empty
17: any expression can be a constant_expression
18:
19: A call to error() does not change the parser's state
20:
21: ***************************************************************************/
22:
23: %{
24: #include "cfront.h"
25: #include "size.h"
26: // include tqueue.h after YYSTYPE is defined ...
27:
28: #define YYMAXDEPTH 600
29:
30: #ifdef DBG
31: #ifndef YYDEBUG
32: #define YYDEBUG 1
33: #endif
34: #endif
35:
36: static init_seen = 0;
37: static cdi = 0;
38: static Pnlist cd = 0, cd_vec[BLMAX];
39: static char stmt_seen = 0, stmt_vec[BLMAX];
40:
41: //local class
42: static Plist tn_vec[BLMAX], lcl_tn_vec[BLMAX], lcl_blk_vec[BLMAX];
43: extern void local_restore();
44: extern void local_name();
45:
46: //nested class
47: static Plist nested_tn_vec[BLMAX], nested_type_vec[BLMAX];
48: extern void nested_restore();
49: extern char *class_typedef;
50:
51: static Pname err_name = 0;
52:
53: // fcts put into norm2.c just to get them out of gram.y
54: void sig_name(Pname);
55: Ptype tok_to_type(TOK);
56: void memptrdcl(Pname, Pname, Ptype, Pname);
57:
58: static Pptr doptr(TOK p, TOK t)
59: {
60: Pptr r = new ptr(p,0);
61: switch (t) {
62: case CONST:
63: r->rdo = 1;
64: // if (p == RPTR) error('w',"redundant `const' after &");
65: break;
66: case VOLATILE:
67: error('w',"\"volatile\" not implemented (ignored)");
68: break;
69: default:
70: error("syntax error: *%k",t);
71: }
72: return r;
73: }
74:
75: static Pbcl dobase(TOK pr, Pname n, TOK v = 0)
76: {
77: Pbcl b = new basecl(0,0);
78:
79: if (pr == PROTECTED) {
80: pr = PUBLIC;
81: error("protectedBC");
82: }
83: b->ppp = pr; // save protection indicator
84:
85: if (n) {
86: if (n->base != TNAME) {
87: error("BN%n not aTN",n);
88: return 0;
89: }
90:
91: Pbase bt = Pbase(n->tp);
92: while (bt->base == TYPE) bt = Pbase(bt->b_name->tp);
93:
94: if (bt->base != COBJ) {
95: error("BN%n not aCN",n);
96: return 0;
97: }
98:
99: if (v) {
100: if (v != VIRTUAL) error("syntax error:%k inBCD",v);
101: b->base = VIRTUAL;
102: }
103: else
104: b->base = NAME;
105:
106: b->bclass = Pclass(bt->b_name->tp);
107: }
108:
109: return b;
110: }
111:
112:
113: #define Ndata(a,b) b->normalize(Pbase(a),0,0)
114: #define Ncast(a,b) b->normalize(Pbase(a),0,1)
115: #define Nfct(a,b,c) b->normalize(Pbase(a),Pblock(c),0)
116: #define Ncopy(n) (n->base==TNAME)?new name(n->string):n
117:
118: #define Finit(p) Pfct(p)->f_init
119: #define Fargdcl(p,q,r) Pfct(p)->argdcl(q,r)
120: #define Freturns(p) Pfct(p)->returns
121: #define Vtype(v) Pvec(v)->typ
122: #define Ptyp(p) Pptr(p)->typ
123:
124: /* avoid redefinitions */
125: #undef EOFTOK
126: #undef ASM
127: #undef BREAK
128: #undef CASE
129: #undef CONTINUE
130: #undef DEFAULT
131: #undef DELETE
132: #undef DO
133: #undef ELSE
134: #undef ENUM
135: #undef FOR
136: #undef FORTRAN
137: #undef GOTO
138: #undef IF
139: #undef NEW
140: #undef OPERATOR
141: #undef RETURN
142: #undef SIZEOF
143: #undef SWITCH
144: #undef THIS
145: #undef WHILE
146: #undef LP
147: #undef RP
148: #undef LB
149: #undef RB
150: #undef REF
151: #undef DOT
152: #undef NOT
153: #undef COMPL
154: #undef MUL
155: #undef AND
156: #undef PLUS
157: #undef MINUS
158: #undef ER
159: #undef OR
160: #undef ANDAND
161: #undef OROR
162: #undef QUEST
163: #undef COLON
164: #undef ASSIGN
165: #undef CM
166: #undef SM
167: #undef LC
168: #undef RC
169: #undef ID
170: #undef STRING
171: #undef ICON
172: #undef FCON
173: #undef CCON
174: #undef ZERO
175: #undef ASOP
176: #undef RELOP
177: #undef EQUOP
178: #undef DIVOP
179: #undef SHIFTOP
180: #undef ICOP
181: #undef TYPE
182: #undef TNAME
183: #undef EMPTY
184: #undef NO_ID
185: #undef NO_EXPR
186: #undef FDEF
187: #undef ELLIPSIS
188: #undef AGGR
189: #undef MEM
190: #undef MEMPTR
191: #undef PR
192: #undef TSCOPE
193: #undef DECL_MARKER
194: #undef REFMUL
195: #undef LDOUBLE
196: #undef LINKAGE
197: #undef LOCAL
198: #undef NESTED
199: %}
200:
201: %union {
202: char* s;
203: TOK t;
204: int i;
205: loc l;
206: Pname pn;
207: Ptype pt;
208: Pexpr pe;
209: Pstmt ps;
210: Pbase pb;
211: Pnlist nl;
212: Pslist sl;
213: Pelist el;
214: Pbcl pbc;
215: Pptr pp;
216: PP p; // fudge: pointer to all class node objects
217: Plist pl;
218: toknode* q; // token queue
219: }
220: %{
221: #include "tqueue.h"
222: extern YYSTYPE yylval, yyval;
223: extern int yyparse();
224:
225: // in_typedef should allow for nested in_typedef
226: extern int declTag; // !1: inline, virtual mod permitted
227: int in_sizeof = 0;
228: Ptype in_typedef = 0; // catch redefinition of TNAME
229: Pname in_tag = 0; // handle complex typedefs: int (*)()
230: extern int defer_check; // redefinition typedef check delay
231: Pname curr_scope;
232:
233: extern int must_be_id; // !0, TNAME => ID, i.e., int X
234: int DECL_TYPE = 0; // lalex() wants this set for global x(*fp)()
235: int in_arg_list=0; // !0 when parsing argument list
236: static int in_binit_list=0;
237: int in_class_decl=0; // !0 when processing class definition
238: int parsing_class_members=0; // !0 when parsing class def but not member function body
239: int in_mem_fct=0; // !0 when parsing member function definition
240:
241: #define yylex lalex
242: #define NEXTTOK() ( (yychar==-1) ? (yychar=yylex(),yychar) : yychar )
243: #define EXPECT_ID() must_be_id = 1
244: #define NOT_EXPECT_ID() must_be_id = 0
245:
246: Pname syn()
247: {
248: ll:
249: switch (yyparse()) {
250: case 0: return 0; // EOF
251: case 1: goto ll; // no action needed
252: default: return yyval.pn;
253: }
254: }
255:
256: %}
257: /*
258: the token definitions are copied from token.h,
259: and all %token replaced by %token
260: */
261: /* keywords in alphabetical order */
262: %token EOFTOK 0
263: %token ASM 1
264: %token BREAK 3
265: %token CASE 4
266: %token CONTINUE 7
267: %token DEFAULT 8
268: %token DELETE 9
269: %token DO 10
270: %token ELSE 12
271: %token ENUM 13
272: %token FOR 16
273: %token FORTRAN 17
274: %token GOTO 19
275: %token IF 20
276: %token NEW 23
277: %token OPERATOR 24
278: %token RETURN 28
279: %token SIZEOF 30
280: %token SWITCH 33
281: %token THIS 34
282: %token WHILE 39
283:
284: /* operators in priority order (sort of) */
285: %token LP 40
286: %token RP 41
287: %token LB 42
288: %token RB 43
289: %token REF 44
290: %token DOT 45
291: %token NOT 46
292: %token COMPL 47
293: %token MUL 50
294: %token AND 52
295: %token PLUS 54
296: %token MINUS 55
297: %token ER 64
298: %token OR 65
299: %token ANDAND 66
300: %token OROR 67
301: %token QUEST 68
302: %token COLON 69
303: %token ASSIGN 70
304: %token CM 71
305: %token SM 72
306: %token LC 73
307: %token RC 74
308: %token MEMPTR 173
309:
310: /* constants etc. */
311: %token ID 80
312: %token STRING 81
313: %token ICON 82
314: %token FCON 83
315: %token CCON 84
316:
317: %token ZERO 86
318:
319: /* groups of tokens */
320: %token ASOP 90 /* op= */
321: %token RELOP 91 /* LE GE LT GT */
322: %token EQUOP 92 /* EQ NE */
323: %token DIVOP 93 /* DIV MOD */
324: %token SHIFTOP 94 /* LS RS */
325: %token ICOP 95 /* INCR DECR */
326:
327: %token TYPE 97 /* INT FLOAT CHAR DOUBLE
328: REGISTER STATIC EXTERN AUTO
329: CONST INLINE VIRTUAL FRIEND
330: LONG SHORT UNSIGNED OVERLOAD
331: TYPEDEF */
332: %token TNAME 123
333: %token EMPTY 124
334: %token NO_ID 125
335: %token NO_EXPR 126
336: %token FDEF 127
337: %token ELLIPSIS 155 /* ... */
338: %token AGGR 156 /* CLASS STRUCT UNION */
339: %token MEM 160 /* :: */
340: %token PR 175 /* PUBLIC PRIVATE PROTECTED */
341: %token TSCOPE 178 /* TNAME :: */
342: %token DECL_MARKER 179
343: %token REFMUL 180 /* ->*, .* */
344: %token LDOUBLE 181
345: %token LINKAGE 182 /* extern "asdf" */
346: %token LOCAL 183 /* local class */
347: %token NESTED 190 /* nested class */
348:
349: %type <p> external_def fct_dcl fct_def att_fct_def arg_dcl_list
350: base_init init_list binit
351: data_dcl ext_def vec ptr
352: type tp enum_dcl moe_list
353: moe
354: tag enumtag class_head class_dcl cl_mem_list
355: cl_mem dl decl_list
356: fname decl initializer stmt_list
357: caselab_stmt caselablist
358: block statement simple ex_list elist e ee term prim
359: term_elist
360: cast_decl cast_type c_decl c_type c_tp
361: arg_decl at arg_type arg_list arg_type_list
362: new_decl new_type
363: condition
364: TSCOPE tscope TNAME tn_list MEMPTR
365: qualified_tname
366: %type <l> LC RC SWITCH CASE DEFAULT FOR IF DO WHILE GOTO RETURN DELETE
367: BREAK CONTINUE
368: %type <t> oper ellipsis_opt
369: EQUOP DIVOP SHIFTOP ICOP RELOP ASOP
370: ANDAND OROR PLUS MINUS MUL ASSIGN OR ER AND
371: LP LB NOT COMPL AGGR
372: TYPE PR REFMUL
373: %type <s> CCON ZERO ICON FCON STRING LINKAGE
374: %type <pn> ID FDEF inline_fct_def
375: %type <pbc> base_list base_unit_list base_unit
376: %type <q> EMPTY
377: %type <i> fct_attributes
378: %type <pl> arg_lp
379:
380: %left EMPTY
381: %left NO_ID
382: %left RC LC ID BREAK CONTINUE RETURN GOTO DELETE DO IF WHILE FOR CASE DEFAULT
383: AGGR ENUM TYPE TNAME TSCOPE
384: %left NO_EXPR
385:
386: %left CM
387: %right ASOP ASSIGN
388: %right QUEST COLON
389: %left OROR
390: %left ANDAND
391: %left OR
392: %left ER
393: %left AND
394: %left EQUOP
395: %left RELOP
396: %left SHIFTOP
397: %left PLUS MINUS
398: %left MUL DIVOP MEMPTR
399: %left REFMUL
400: %right NOT COMPL NEW
401: %right ICOP SIZEOF
402: %left LB LP DOT REF MEM
403:
404: %start ext_def
405:
406: %%
407: /*
408: this parser handles declarations one by one,
409: NOT a complete .c file
410: */
411:
412:
413: /************** DECLARATIONS in the outermost scope: returns Pname (in yylval) ***/
414:
415: ext_def : external_def { return 2; }
416: | SM { return 1; }
417: | EOFTOK { return 0; }
418: | LINKAGE LC
419: {
420: set_linkage($<s>1);
421: bl_level--;
422: return 1;
423: }
424: | RC
425: {
426: set_linkage(0);
427: bl_level++;
428: return 1;
429: }
430: ;
431:
432: external_def : data_dcl
433: {
434: /* if function declartion with arguments
435: * need to make sure modified_tn is traversed */
436: if ( $<pn>1 != 0
437: && $<pn>1->tp->base == FCT
438: && Pfct($<pn>1->tp)->nargs !=0 )
439: goto mod;
440: else {
441: modified_tn = 0;
442: curr_scope = 0;
443: if ($<pn>1==0) $<i>$ = 1;
444: }
445: }
446: | att_fct_def
447: { goto mod; }
448: | fct_def
449: { goto mod; }
450: | fct_dcl
451: { mod: if (modified_tn) {
452: restore();
453: modified_tn = 0;
454: }
455: local_blk = 0;
456: curr_scope = 0;
457: if (local_tn) {
458: local_restore();
459: local_tn = 0;
460: }
461:
462: if (nested_tn) { // x::f(){}
463: nested_restore();
464: nested_tn = 0;
465: nested_type = 0;
466: }
467: }
468: | ASM LP STRING RP SM
469: { Pname n = new name(make_name('A'));
470: n->tp = new basetype(ASM,0);
471: Pbase(n->tp)->b_name = Pname($<s>3);
472: $$ = n;
473: }
474: ;
475:
476: fct_dcl : decl ASSIGN initializer SM
477: {
478: err_name = $<pn>1;
479: if(err_name) err_name->n_initializer = $<pe>3;
480: goto fix;
481: }
482: | decl SM
483: {
484: Ptype t;
485: err_name = $<pn>1;
486: fix:
487: if (err_name == 0) {
488: error("syntax error:TX");
489: $$ = Ndata(defa_type,err_name);
490: }
491: else if ((t=err_name->tp) == 0) {
492: error("TX for%n",err_name);
493: $$ = Ndata(defa_type,err_name);
494: }
495: else if (t->base==FCT) {
496: if (Pfct(t)->returns==0)
497: $$ = Nfct(defa_type,err_name,0);
498: else
499: $$ = Ndata(0,err_name);
500: }
501: else {
502: error("syntax error:TX for%k%n",t->base,err_name);
503: $$ = Ndata(defa_type,err_name);
504: }
505: }
506: ;
507:
508: att_fct_def : type decl arg_dcl_list check_inline base_init block
509: { Pname n = Nfct($1,$<pn>2,$6);
510: Fargdcl(n->tp,name_unlist($<nl>3),n);
511: Finit(n->tp) = $<pn>5;
512: $$ = n;
513: NOT_EXPECT_ID();
514: }
515: | type decl arg_dcl_list check_inline EMPTY
516: {
517: Pname n = Nfct($1,$<pn>2,dummy);
518: Fargdcl(n->tp,name_unlist($<nl>3),n);
519: $<q>5->retval.pn = n;
520: $$ = n;
521: NOT_EXPECT_ID();
522: }
523: | type decl arg_dcl_list check_inline NO_ID /*syntax error*/
524: {
525: error(&$<pn>2->where,"syntax error -- did you forget a ';'?");
526: Pname n = Nfct($1,$<pn>2,0);
527: $$ = n;
528: NOT_EXPECT_ID();
529: }
530: ;
531:
532: fct_def : decl arg_dcl_list check_inline base_init block
533: { Pname n = Nfct(defa_type,$<pn>1,$5);
534: Fargdcl(n->tp,name_unlist($<nl>2),n);
535: if ( $<pn>4 && $<pn>4->n_list &&
536: ccl && ccl->csu == UNION )
537: error( "multiple initializers in unionK %s::%n", $<pn>1->string, $<pn>1 );
538: Finit(n->tp) = $<pn>4;
539: $$ = n;
540: NOT_EXPECT_ID();
541: }
542: | decl arg_dcl_list check_inline EMPTY
543: {
544: Pname n = Nfct(defa_type,$<pn>1,dummy);
545: Fargdcl(n->tp,name_unlist($<nl>2),n);
546: $<q>4->retval.pn = n;
547: $$ = n;
548: NOT_EXPECT_ID();
549: }
550: | decl arg_dcl_list check_inline NO_ID /*syntax error*/
551: {
552: error(&$<pn>1->where,"badD of%n -- did you forget a ';'?",$<pn>1);
553: Pname n = Nfct(defa_type,$<pn>1,0);
554: $$ = n;
555: NOT_EXPECT_ID();
556: }
557: ;
558:
559: inline_fct_def : FDEF { arg_redec($<pn>1); }
560: base_init block
561: {
562: Finit($1->tp) = $<pn>3;
563: Pfct($1->tp)->body = Pblock($4);
564: $$ = $1;
565: NOT_EXPECT_ID();
566: }
567: ;
568:
569:
570: check_inline : /* empty */
571: {
572: // if parsing implicit inline def, save body
573: // of function for parsing after class def
574: switch ( NEXTTOK() ) {
575: case LC: case COLON:
576: if ( in_class_decl ) {
577: // mem or friend inline def
578: // save text of mem_init & ftn
579: la_backup(yychar,yylval);
580: // yylval used as dummy...
581: la_backup(FDEF, yylval);
582: if ( yylval.q = save_text() )
583: yychar = EMPTY;
584: else { // syntax error
585: // just parse in place
586: yylex(); // FDEF
587: yychar = yylex();
588: }
589: } // if in_class_decl
590: break;
591: default:
592: la_backup(yychar,yylval);
593: yychar = NO_ID; // 'graceful' recovery
594: break;
595: }
596: }
597: ;
598:
599: base_init : COLON { ++in_binit_list; } init_list
600: {
601: $$ = $3;
602: in_arg_list = 0;
603: --in_binit_list;
604: }
605: | %prec EMPTY
606: { $$ = 0; }
607: ;
608:
609: init_list : binit
610: { $$ = $1; }
611: | init_list CM binit
612: { $<pn>$ = $<pn>3; $<pn>$->n_list = $<pn>1; }
613: ;
614:
615: binit : LP elist RP
616: {
617: $<pn>$ = new name;
618: $<pn>$->n_initializer = $<pe>2;
619: }
620: | tag LP elist RP
621: {
622: Pname n = Ncopy($<pn>1);
623: n->base = $<pn>1->base;
624: n->tp = $<pn>1->tp;
625: n->n_initializer = $<pe>3;
626: $<pn>$ = n;
627: }
628:
629: /*
630: | NEW LP elist RP
631: { Pname n = new name;
632: n->base = NEW;
633: n->n_initializer = $<pe>3;
634: $<pn>$ = n;
635: }
636: */
637: ;
638:
639:
640:
641:
642: /*************** declarations: returns Pname ********************/
643:
644: arg_dcl_list : arg_dcl_list data_dcl
645: { if ($<pn>2 == 0)
646: error("badAD");
647: else if ($<pn>2->tp->base == FCT)
648: error("FD inAL (%n)",$<pn>2);
649: else if ($1)
650: $<nl>1->add_list($<pn>2);
651: else
652: $<nl>$ = new nlist($<pn>2);
653: }
654: | %prec EMPTY
655: {
656: $$ = 0;
657: }
658: ;
659:
660: dl : decl
661: | ID COLON e %prec CM
662: { $$ = $<pn>1;
663: $<pn>$->tp = new basetype(FIELD,$<pn>3);
664: }
665: | COLON e %prec CM
666: { $$ = new name;
667: $<pn>$->tp = new basetype(FIELD,$<pn>2);
668: }
669: | decl ASSIGN initializer
670: { Pexpr e = $<pe>3;
671: if (e == dummy) error("emptyIr");
672: $<pn>1->n_initializer = e;
673: init_seen = 0;
674: }
675: ;
676:
677: decl_list : dl
678: {
679: if ($1) $<nl>$ = new nlist($<pn>1);
680: if ( NEXTTOK() == CM && la_look() == TNAME )
681: EXPECT_ID();
682: }
683: | decl_list CM dl
684: { if ($1)
685: if ($3)
686: $<nl>1->add($<pn>3);
687: else
688: error("DL syntax");
689: else {
690: if ($3) $<nl>$ = new nlist($<pn>3);
691: error("DL syntax");
692: }
693: if ( NEXTTOK() == CM && la_look() == TNAME )
694: EXPECT_ID();
695: }
696: ;
697:
698: data_dcl : type decl_list SM
699: {
700: extern int co_hack;
701: co_hack = 1;
702: /*$$ = Ndata($1,name_unlist($<nl>2));*/
703: Pname n = Ndata($1,name_unlist($<nl>2));
704: if ( in_typedef && in_tag ) {
705: if ( n->tp->check( in_tag->tp, 0 ))
706: error("%nredefined: previous: %t now: %t", in_tag, in_tag->tp, n->tp );
707: }
708: in_typedef = 0;
709: class_typedef = 0;
710: in_tag = 0;
711: co_hack = 0;
712: DECL_TYPE = 0;
713: $$ = n;
714: }
715: | type SM
716: {
717: $$ = $<pb>1->aggr();
718: in_typedef = 0;
719: class_typedef = 0;
720: in_tag = 0;
721: DECL_TYPE = 0;
722: }
723:
724: ;
725:
726: tp : TYPE
727: {
728: $$ = new basetype($<t>1,0);
729: if ( $<t>1 == TYPEDEF ) in_typedef = $<pt>$;
730: if (DECL_TYPE == -1) DECL_TYPE = 0;
731: }
732: | LINKAGE
733: { $$ = new basetype(EXTERN,0);
734: $<pb>$->b_linkage = $<s>1;
735: if (DECL_TYPE == -1) DECL_TYPE = 0;
736: }
737: | qualified_tname
738: {
739: $$ = new basetype(TYPE,$<pn>1);
740: if (DECL_TYPE == -1) DECL_TYPE = 0;
741: }
742: /*XXX*/ | tn_list DECL_MARKER
743: { // modified tn_list TNAME
744: $$ = new basetype(TYPE,$<pn>2);
745: //xxx qualifier currently ignored...
746: if (DECL_TYPE == -1) DECL_TYPE = 0;
747: }
748: | class_dcl
749: | enum_dcl
750: | DECL_MARKER
751: {
752: if (DECL_TYPE == TNAME)
753: $$ = new basetype(TYPE,$<pn>1);
754: // else if (DECL_TYPE == TSCOPE)
755: // $$ = 0;
756: else
757: if (DECL_TYPE == 0 &&
758: $<p>1->base == TNAME)
759: $$ = new basetype(TYPE,$<pn>1);
760: else
761: $$ = new basetype($<t>1,0);
762: DECL_TYPE = -1;
763: }
764: ;
765:
766: type : tp
767: | type TYPE
768: {
769: if ( DECL_TYPE != -1 )
770: $$ = $<pb>1->type_adj($<t>2);
771: DECL_TYPE = 0;
772: }
773: | type qualified_tname
774: {
775: //error('d',"decl_type: %d $1: %t $2: %n",DECL_TYPE,$<pb>1,$<pn>2);
776: if ( DECL_TYPE != -1 )
777: $$ = $<pb>1->name_adj($<pn>2);
778: /*XXX*/ else if($<pb>1==0) $$=new basetype(TYPE,$<pn>2);
779: DECL_TYPE = 0;
780: }
781: | type class_dcl { $$ = $<pb>1->base_adj($<pb>2); }
782: | type enum_dcl { $$ = $<pb>1->base_adj($<pb>2); }
783: | type DECL_MARKER
784: {
785: if (DECL_TYPE == TYPE)
786: $$ = $<pb>1->type_adj($<t>2);
787: /*XXX*/ else if (DECL_TYPE == TSCOPE) {
788: /*XXX*/ error('i',"type decl_marker(tscope)");
789: /*XXX*/ // $$ = $1;//ignore(?)
790: /*XXX*/ }
791: else
792: $$ = $<pb>1->name_adj($<pn>2);
793: DECL_TYPE = -1;
794: }
795: ;
796:
797: /***************** aggregate: returns Pname *****************/
798:
799: enumtag : tag
800: { enumcheck:
801: Ptype tx = $<pn>1->tp;
802: $$ = $1;
803: if ( tx->base == TYPE ) {
804: $$ = Pbase(tx)->b_name;
805: tx = $<pn>$->tp;
806: if ( tx->base != EOBJ
807: || strcmp($<pn>$->string,$<pn>1->string)
808: )
809: error("%n of type%t redeclared as enum.",$<pn>1,tx);
810: } else if ( tx->base != EOBJ )
811: error("%n of type%t redeclared as enum",$<pn>1,tx);
812: }
813: | DECL_MARKER { goto enumcheck; }
814: ;
815:
816: enum_dcl : ENUM LC moe_list RC { $$ = end_enum(0,$<pn>3); }
817: | ENUM enumtag LC moe_list RC { $$ = end_enum($<pn>2,$<pn>4); }
818: | ENUM enumtag { $<pb>$ = (Pbase)$<pn>2->tp; }
819: ;
820:
821: moe_list : moe
822: { if ($1) $<nl>$ = new nlist($<pn>1); }
823: | moe_list CM moe
824: { if( $3)
825: if ($1)
826: $<nl>1->add($<pn>3);
827: else
828: $<nl>$ = new nlist($<pn>3);
829: }
830: ;
831:
832: moe : ID
833: { $$ = $<pn>1; $<pn>$->tp = moe_type; }
834: | ID ASSIGN e
835: { $$ = $<pn>1;
836: $<pn>$->tp = moe_type;
837: $<pn>$->n_initializer = $<pe>3;
838: }
839: | /* empty: handle trailing CM: enum e { a,b, }; */
840: { $$ = 0; }
841: ;
842:
843: class_dcl : class_head cl_mem_list RC
844: { parsing_class_members = 0;
845: switch ( NEXTTOK() ) {
846: case TYPE: case AGGR: case ENUM: case EOFTOK:
847: error("`;' or declaratorX afterCD");
848: la_backup(yychar,yylval);
849: yychar = SM;
850: break;
851: }
852: la_backup(yychar,yylval);
853: yychar = -1;
854: restore_text();
855: ++bl_level; // scope weirdness!
856: ++in_mem_fct;
857: }
858: inline_mem_defs
859: {
860: --in_mem_fct;
861: --bl_level; // scope weirdness!
862: if ( yychar == ID ) {
863: // (yuk!) adjust lex level
864: --yylval.pn->lex_level;
865: }
866: ccl->mem_list = name_unlist($<nl>2);
867: if ( --in_class_decl ) // nested class
868: // continue to parse enclosing class
869: parsing_class_members = 1;
870: ccl->nest_list = nested_type;
871: if ( nested_tn ) nested_restore();
872: nested_type = nested_type_vec[in_class_decl];
873: nested_tn = nested_tn_vec[in_class_decl];
874: end_cl();
875: declTag = 1;
876: }
877: | AGGR tag
878: { aggrcheck:
879: $<pb>$ = (Pbase)$<pn>2->tp;
880: if ( $$->base == TYPE ) {
881: Pname nx = $<pb>$->b_name;
882: $<pb>$ = (Pbase)nx->tp;
883: if ( $$->base != COBJ
884: || strcmp(nx->string,$<pn>2->string)
885: )
886: error("%n of type%t redeclared as%k.",$<pn>2,$<pb>$,$<t>1);
887: } else if ( $$->base != COBJ )
888: error("%n of type%t redeclared as%k",$<pn>2,$<pb>$,$<t>1);
889: check_tag();
890: }
891:
892: | AGGR DECL_MARKER
893: {
894: goto aggrcheck;
895: }
896: ;
897:
898:
899: inline_mem_defs : /* empty */
900: | inline_mem_defs inline_fct_def
901: ;
902:
903: base_list : COLON base_unit_list { $$ = $2; }
904: | %prec EMPTY { $$ = 0; }
905: ;
906:
907: base_unit_list : base_unit
908: | base_unit_list CM base_unit
909: { if ($3) { $$ = $3; $<pbc>$->next = $1; } }
910: ;
911:
912: base_unit : tag { $$ = dobase(0,$<pn>1); }
913: | PR tag { $$ = dobase($<t>1,$<pn>2); }
914: | TYPE tag { $$ = dobase(0,$<pn>2,$<t>1); }
915: | PR TYPE tag { $$ = dobase($<t>1,$<pn>3,$<t>2); }
916: | TYPE PR tag { $$ = dobase($<t>2,$<pn>3,$<t>1); }
917: ;
918:
919: class_head : AGGR LC
920: { parsing_class_members = 1;
921: $$ = start_cl($<t>1,0,0);
922: nested_tn_vec[in_class_decl] = nested_tn;
923: nested_type_vec[in_class_decl++] = nested_type;
924: nested_tn = nested_type = 0;
925: }
926:
927: | AGGR tag base_list LC
928: { parsing_class_members = 1;
929: $$ = start_cl($<t>1,$<pn>2,$<pbc>3);
930: nested_tn_vec[in_class_decl] = nested_tn;
931: nested_type_vec[in_class_decl++] = nested_type;
932: nested_tn = nested_type = 0;
933: }
934: ;
935:
936: tag : ID { $$ = $1; }
937: | qualified_tname { $$=$1; }
938: ;
939:
940: cl_mem_list : cl_mem_list cl_mem
941: {
942: if ($2) {
943: if ($1)
944: $<nl>1->add_list($<pn>2);
945: else
946: $<nl>$ = new nlist($<pn>2);
947: }
948: }
949: | %prec EMPTY
950: { $$ = 0; }
951: ;
952:
953: cl_mem : data_dcl
954: | att_fct_def SM
955: | fct_def SM
956: | fct_def
957: | att_fct_def
958: | fct_dcl
959: | PR COLON
960: { $$ = new name;
961: $<pn>$->base = $<t>1;
962: }
963: /*XXX | tn_list TNAME SM
964: * { Pname n = Ncopy($<pn>2);
965: * n->n_qualifier = $<pn>1;
966: * n->base = PR;
967: * $$ = n;
968: * }
969: */ | tn_list fname SM
970: { Pname n = Ncopy($<pn>2);
971: if (n->n_oper == TYPE) {
972: error('s',"visibilityD for conversion operator");
973: // n->tp = Ptype(n->n_initializer);
974: n->tp = Ptype(n->cond);
975: n->cond = 0;
976: // n->n_initializer = 0;
977: n->n_oper = 0;
978: sig_name(n);
979: }
980: n->n_qualifier = $<pn>1;
981: n->base = PR;
982: $$ = n;
983: }
984: ;
985:
986: /************* declarators: returns Pname **********************/
987: /* a ``decl'' is used for function and data declarations,
988: and for member declarations
989: (it has a name)
990: an ``arg_decl'' is used for argument declarations
991: (it may or may not have a name)
992: an ``cast_decl'' is used for casts
993: (it does not have a name)
994: a ``new_decl'' is used for type specifiers for the NEW operator
995: (it does not have a name, and PtoF and PtoV cannot be expressed)
996: */
997:
998: fname : ID
999: { $$ = $<pn>1; }
1000: | COMPL TNAME /* qualified_tname? */
1001: { $$ = Ncopy($<pn>2);
1002: $<pn>$->n_oper = DTOR;
1003: }
1004: | OPERATOR oper
1005: { $$ = new name(oper_name($2));
1006: $<pn>$->n_oper = $<t>2;
1007: }
1008: | OPERATOR c_type
1009: { Pname n = $<pn>2;
1010: n->string = "_type";
1011: n->n_oper = TYPE;
1012: n->cond = Pexpr(n->tp);
1013: // n->n_initializer = Pexpr(n->tp);
1014: n->tp = 0;
1015: $$ = n;
1016: }
1017: ;
1018:
1019: oper : PLUS
1020: | MINUS
1021: | MUL
1022: | AND
1023: | OR
1024: | ER
1025: | SHIFTOP
1026: | EQUOP
1027: | DIVOP
1028: | RELOP
1029: | ANDAND
1030: | OROR
1031: | LP RP { $$ = CALL; }
1032: | LB RB { $$ = DEREF; }
1033: | NOT
1034: | COMPL
1035: | ICOP
1036: | ASOP
1037: | ASSIGN
1038: | NEW { $$ = NEW; }
1039: | DELETE { $$ = DELETE; }
1040: | REF { $$ = REF; }
1041: | CM { $$ = CM; }
1042: | REFMUL { $$ = REFMUL;
1043: if ($<t>1 == DOT) error(".* cannot be overloaded");
1044: }
1045: ;
1046:
1047: tn_list : tscope
1048: /*XXX*/ { if ( $<pn>1 != sta_name ) {
1049: // error('d',"tn_list: tscope: pn1: %s", $<pn>1->string);
1050: Ptype t = $<pn>1->tp;
1051: while ( t->base == TYPE )
1052: t = Pbase(t)->b_name->tp;
1053: Pname n = Pbase(t)->b_name;
1054: if (NEXTTOK() == TNAME
1055: && strcmp(n->string,yylval.pn->string)==0){
1056: // ctor -- change to ID to avoid
1057: // parsing as type spec
1058: yychar = ID;
1059: yylval.pn = Ncopy(yylval.pn);
1060: yylval.pn->n_oper = TNAME;
1061: }
1062: }
1063: $<pn>$ = $<pn>1;
1064: }
1065: /* YYY | tn_list tscope { $<pn>$ = $<pn>1; } */
1066: | tn_list tscope { error('s', "CNs do not nest, use typedef x::y y_in_x"); };
1067: /*XXX | tn_list ID DOT { error("CNs do not nest"); } */
1068: ;
1069:
1070: qualified_tname : tn_list TNAME
1071: { $<pn>$ = $<pn>2;
1072: //xxx qualifier currently ignored...
1073: // $<pn>$ = Ncopy( $<pn>2 );
1074: // $<pn>$->n_oper = TNAME;
1075: // $<pn>$->n_qualifier = $<pn>1;
1076: }
1077: | TNAME
1078: { $<pn>$ = $<pn>1;
1079: // $<pn>$ = Ncopy( $<pn>1 );
1080: // $<pn>$->n_oper = TNAME;
1081: }
1082: ;
1083:
1084: fct_attributes : /* empty */
1085: { $$ = 0; }
1086: | fct_attributes TYPE
1087: { /* const/volatile function */
1088: switch ( $<t>2 ) {
1089: case VOLATILE:
1090: error('s',"volatile functions");
1091: break;
1092: case CONST:
1093: $$ = ($1 | 1);
1094: break;
1095: default:
1096: if ( NEXTTOK() != SM
1097: && yychar != COLON
1098: && yychar != LC ) {
1099: la_backup(yychar,yylval);
1100: yylval.t = $<t>2;
1101: la_backup(TYPE,yylval);
1102: yylval.t = SM;
1103: yychar = SM;
1104: error("syntax error: unexpected%k (did you forget a `;'?)",$<t>2);
1105: } else error("FD syntax: unexpected%k",$<t>2);
1106: break;
1107: }
1108: }
1109: ;
1110:
1111: decl : decl arg_list
1112: { Freturns($2) = $<pn>1->tp;
1113: $<pn>1->tp = $<pt>2;
1114: }
1115: | decl LP RP fct_attributes
1116: { /* function with no argument */
1117: $<pn>1->tp = new fct($<pn>1->tp,0,1);
1118: Pfct($<pn>1->tp)->f_const = ($<i>4 & 1);
1119: }
1120: | qualified_tname arg_list
1121: { Pname n = $<pn>1;
1122: $$ = Ncopy(n);
1123: if (ccl && strcmp(n->string,ccl->string)) n->hide();
1124: $<pn>$->n_oper = TNAME;
1125: Freturns($2) = $<pn>$->tp;
1126: $<pn>$->tp = $<pt>2;
1127: }
1128: | decl arg_lp elist RP
1129: /* may be class object initializer,
1130: class object vector initializer,
1131: if not elist will be a CM or an ID
1132: */
1133: {
1134: $<pn>1->tp = new fct($<pn>1->tp,$<pn>3,1);
1135: in_arg_list = 0;
1136: end_al($2,0);
1137: }
1138: | qualified_tname LP MUL ID RP arg_list
1139: {
1140: Pptr p = new ptr( PTR, 0 );
1141: Ptyp(p) = new basetype(TYPE,$<pn>1);
1142: Freturns( $6 ) = Ptype(p);
1143: $<pn>4->tp = $<pt>6;
1144: $$ = $4;
1145: if (DECL_TYPE == -1) DECL_TYPE = 0;
1146: }
1147: | qualified_tname LP elist RP
1148: { $$ = Ncopy($<pn>1);
1149: $<pn>$->n_oper = TNAME;
1150: $<pn>$->tp = new fct(0,$<pn>3,1);
1151: }
1152: | qualified_tname LP RP fct_attributes
1153: { /* function with no argument */
1154: $$ = Ncopy($<pn>1);
1155: $<pn>$->n_oper = TNAME;
1156: $<pn>$->tp = new fct(0,0,1);
1157: Pfct($<pn>1->tp)->f_const = ($<i>4 & 1);
1158: }
1159: | qualified_tname LP MEMPTR decl RP arg_list
1160: { memptrdcl($<pn>3,$<pn>1,$<pt>6,$<pn>4);
1161: $$ = $4;
1162: }
1163: | fname
1164: | ID DOT fname
1165: { $$ = Ncopy($<pn>3);
1166: $<pn>$->n_qualifier = $1;
1167: error(strict_opt?0:'w',"`.' used for qualification; please use `::' (anachronism)");
1168: }
1169: | tn_list fname
1170: { $$ = $2;
1171: if ( $<pn>1 != sta_name ) {
1172: set_scope($<pn>1);
1173: $<pn>$->n_qualifier = $<pn>1;
1174: }
1175: }
1176: /*XXX*/ | tn_list ID DOT fname
1177: { $$ = Ncopy($<pn>4);
1178: $<pn>$->n_qualifier = $2;
1179: error(ansi_opt?0:'w',"anachronism `.' used for qualification; please use `::'");
1180: if ( $<pn>1 != sta_name ) {
1181: set_scope($<pn>1);
1182: $<pn>2->n_qualifier = $<pn>1;
1183: }
1184: }
1185: /*XXX | tn_list TNAME
1186: * {
1187: * if ( $<pn>1 == sta_name )
1188: * error( ":: applied to CN%n", $<pn>2 );
1189: * $$ = Ncopy($<pn>2);
1190: * set_scope($<pn>1);
1191: * $<pn>$->n_oper = TNAME;
1192: * $<pn>$->n_qualifier = $<pn>1;
1193: * }
1194: */ | ptr decl %prec MUL
1195: { Ptyp($1) = $<pn>2->tp;
1196: $<pn>2->tp = $<pt>1;
1197: $$ = $2;
1198: }
1199: | ptr qualified_tname %prec MUL
1200: { $$ = Ncopy($<pn>2);
1201: $<pn>$->n_oper = TNAME;
1202: // cannot evaluate at this point: defer until data_dcl
1203: if ( in_typedef ) {
1204: defer_check = 1;
1205: in_tag = $<pn>2;
1206: }
1207: $<pn>2->hide();
1208: defer_check = 0;
1209: $<pn>$->tp = $<pt>1;
1210: }
1211: | qualified_tname vec %prec LB
1212: { $$ = Ncopy($<pn>1);
1213: $<pn>$->n_oper = TNAME;
1214: if ( in_typedef ) {
1215: defer_check = 1;
1216: in_tag = $<pn>2;
1217: }
1218: $<pn>1->hide();
1219: defer_check = 0;
1220: $<pn>$->tp = $<pt>2;
1221: }
1222: | decl vec %prec LB
1223: { Vtype($2) = $<pn>1->tp;
1224: $<pn>1->tp = $<pt>2;
1225: }
1226: /*
1227: | LP decl RP arg_list
1228: {
1229: Freturns($4) = $<pn>2->tp;
1230: $<pn>2->tp = $<pt>4;
1231: $$ = $2;
1232: }
1233: | LP decl RP vec
1234: { Vtype($4) = $<pn>2->tp;
1235: $<pn>2->tp = $<pt>4;
1236: $$ = $2;
1237: }
1238: */
1239: | arg_lp decl RP
1240: {
1241: $$ = $2;
1242: in_arg_list = 0;
1243: end_al($1,0);
1244: }
1245: ;
1246:
1247: arg_decl : ID
1248: { $$ = $<pn>1; }
1249: | ptr qualified_tname %prec MUL
1250: { $$ = Ncopy($<pn>2);
1251: $<pn>$->n_oper = TNAME;
1252: $<pn>2->hide();
1253: $<pn>$->tp = $<pt>1;
1254: }
1255: | %prec NO_ID
1256: {
1257: $$ = new name;
1258: NOT_EXPECT_ID();
1259: }
1260: | ptr arg_decl %prec MUL
1261: { Ptyp($1) = $<pn>2->tp;
1262: $<pn>2->tp = (Ptype)$1;
1263: $$ = $2;
1264: }
1265: | arg_decl vec %prec LB
1266: { Vtype($2) = $<pn>1->tp;
1267: $<pn>1->tp = (Ptype)$2;
1268: }
1269: | arg_decl arg_list
1270: { Freturns($2) = $<pn>1->tp;
1271: $<pn>1->tp = (Ptype)$2;
1272: }
1273: /*
1274: | LP arg_decl RP arg_list
1275: { Freturns($4) = $<pn>2->tp;
1276: $<pn>2->tp = (Ptype)$4;
1277: $$ = $2;
1278: }
1279: | LP arg_decl RP vec
1280: { Vtype($4) = $<pn>2->tp;
1281: $<pn>2->tp = (Ptype)$4;
1282: $$ = $2;
1283: }
1284: */
1285: | arg_lp arg_decl RP
1286: {
1287: // error('d', "arg_lp arg_decl rp in_arg_list: %d", in_arg_list );
1288: $$ = $2;
1289: in_arg_list = 0;
1290: end_al($1,0);
1291: }
1292: ;
1293:
1294: new_decl : %prec NO_ID
1295: { $$ = new name; }
1296: | ptr new_decl %prec MUL
1297: { Ptyp($1) = $<pn>2->tp;
1298: $<pn>2->tp = (Ptype)$1;
1299: $$ = $2;
1300: NOT_EXPECT_ID();
1301: }
1302: | new_decl vec %prec LB
1303: { Vtype($2) = $<pn>1->tp;
1304: $<pn>1->tp = (Ptype)$2;
1305: }
1306: ;
1307:
1308: cast_decl : %prec NO_ID { $$ = new name; }
1309: | ptr cast_decl %prec MUL
1310: { Ptyp($1) = $<pn>2->tp;
1311: $<pn>2->tp = (Ptype)$1;
1312: $$ = $2;
1313: NOT_EXPECT_ID();
1314: }
1315: | cast_decl vec %prec LB
1316: { Vtype($2) = $<pn>1->tp;
1317: $<pn>1->tp = (Ptype)$2;
1318: }
1319: | LP cast_decl RP arg_list
1320: { Freturns($4) = $<pn>2->tp;
1321: $<pn>2->tp = $<pt>4;
1322: $$ = $2;
1323: }
1324: | LP cast_decl RP vec
1325: { Vtype($4) = $<pn>2->tp;
1326: $<pn>2->tp = $<pt>4;
1327: $$ = $2;
1328: }
1329: ;
1330:
1331: c_decl : %prec NO_ID
1332: { $$ = new name; }
1333: | ptr c_decl %prec MUL
1334: { Ptyp($1) = $<pn>2->tp;
1335: $<pn>2->tp = (Ptype)$1;
1336: $$ = $2;
1337: }
1338: ;
1339:
1340:
1341:
1342: /***************** statements: returns Pstmt *****************/
1343: stmt_list : /* empty */
1344: {
1345: $$ = 0;
1346: }
1347: | stmt_list caselab_stmt
1348: {
1349: if ($2)
1350: if ($1)
1351: $<sl>1->add($<ps>2);
1352: else {
1353: $<sl>$ = new slist($<ps>2);
1354: stmt_seen = 1;
1355: }
1356: }
1357: ;
1358: caselab_stmt : caselablist statement
1359: {
1360: $$ = $2;
1361: if ($2) stmt_seen = 1;
1362: }
1363: ;
1364:
1365: caselablist : /* empty */
1366: {
1367: $$ = 0;
1368: check_decl();
1369: }
1370: ;
1371:
1372: condition : LP e RP
1373: { $$ = $2;
1374: /* if ($<pe>$ == dummy) error("empty condition");*/
1375: stmt_seen = 1;
1376: }
1377: ;
1378:
1379: block : LC
1380: { cd_vec[cdi] = cd;
1381: stmt_vec[cdi] = stmt_seen;
1382: tn_vec[cdi] = modified_tn;
1383: lcl_blk_vec[cdi++] = local_blk;
1384: lcl_tn_vec[cdi] = local_tn;
1385: local_blk = 0;
1386: local_tn = 0;
1387: cd = 0;
1388: stmt_seen = 0;
1389: modified_tn = 0;
1390: }
1391: stmt_list RC
1392: { Pname n = name_unlist(cd);
1393: Pstmt ss = stmt_unlist($<sl>3);
1394: $$ = new block($<l>1,n,ss,$<l>4);
1395: if ( local_tn ) local_restore();
1396: if ( local_blk ) local_name();
1397: if (modified_tn) restore();
1398: cd = cd_vec[--cdi];
1399: stmt_seen = stmt_vec[cdi];
1400: modified_tn = tn_vec[cdi];
1401: local_tn = lcl_tn_vec[cdi];
1402: local_blk = lcl_blk_vec[cdi];
1403: if (cdi < 0) error('i',"block level(%d)",cdi);
1404: NOT_EXPECT_ID();
1405: }
1406: | LC RC
1407: { $$ = new block($<l>1,0,0,$<l>2); NOT_EXPECT_ID();}
1408: | LC error RC
1409: { $$ = new block($<l>1,0,0,$<l>3); NOT_EXPECT_ID();}
1410: ;
1411:
1412: simple : ee
1413: { $$ = new estmt(SM,curloc,$<pe>1,0); }
1414: | BREAK
1415: { $$ = new stmt(BREAK,$<l>1,0); }
1416: | CONTINUE
1417: { $$ = new stmt(CONTINUE,$<l>1,0); }
1418: | GOTO ID
1419: { $$ = new lstmt(GOTO,$<l>1,$<pn>2,0); }
1420: | DO { stmt_seen=1; } caselab_stmt WHILE condition
1421: { $$ = new estmt(DO,$<l>1,$<pe>5,$<ps>3); }
1422: | ASM LP STRING RP
1423: {
1424: if (stmt_seen)
1425: $$ = new estmt(ASM,curloc,(Pexpr)$<s>3,0);
1426: else {
1427: Pname n = new name(make_name('A'));
1428: n->tp = new basetype(ASM,(Pname)$<s>3);
1429: if (cd)
1430: cd->add_list(n);
1431: else
1432: cd = new nlist(n);
1433: $$ = 0;
1434: }
1435: }
1436: ;
1437:
1438: sm : {
1439: if ( NEXTTOK() != SM ) {
1440: error("`;' missing afterS");
1441: la_backup(yychar,yylval);
1442: yychar = SM;
1443: }
1444: } SM
1445: ;
1446:
1447: statement : simple sm
1448: | SM
1449: { $$ = new estmt(SM,$<l>1,dummy,0); }
1450: | RETURN e SM
1451: { $$ = new estmt(RETURN,$<l>1,$<pe>2,0); }
1452: | TYPE STRING block
1453: {
1454: error("local linkage specification");
1455: $$ = $<pn>3;
1456: }
1457: | data_dcl
1458: { Pname n = $<pn>1;
1459: if (n)
1460: if (stmt_seen) {
1461: $$ = new block(n->where,n,0);
1462: $<ps>$->base = DCL;
1463: }
1464: else {
1465: if (cd)
1466: cd->add_list(n);
1467: else
1468: cd = new nlist(n);
1469: $$ = 0;
1470: }
1471: }
1472: | att_fct_def
1473: {
1474: Pname n = $<pn>1;
1475: error(&n->where,"%n's definition is nested (did you forget a ``}''?)",n);
1476: if (cd)
1477: cd->add_list(n);
1478: else
1479: cd = new nlist(n);
1480: $$ = 0;
1481: }
1482: | block
1483: | IF condition caselab_stmt
1484: { $$ = new ifstmt($<l>1,$<pe>2,$<ps>3,0); }
1485: | IF condition caselab_stmt ELSE caselab_stmt
1486: { $$ = new ifstmt($<l>1,$<pe>2,$<ps>3,$<ps>5); }
1487: | WHILE condition caselab_stmt
1488: { $$ = new estmt(WHILE,$<l>1,$<pe>2,$<ps>3); }
1489: | FOR LP { stmt_seen=1; } caselab_stmt e SM e RP caselab_stmt
1490: { $$ = new forstmt($<l>1,$<ps>4,$<pe>5,$<pe>7,$<ps>9); }
1491: | SWITCH condition caselab_stmt
1492: { $$ = new estmt(SWITCH,$<l>1,$<pe>2,$<ps>3); }
1493: | ID COLON { $$ = $1; stmt_seen=1; } caselab_stmt
1494: { Pname n = $<pn>3;
1495: $$ = new lstmt(LABEL,n->where,n,$<ps>4);
1496: }
1497: | TNAME COLON { $$ = new name($<pn>1->string); stmt_seen=1; } caselab_stmt
1498: { Pname n = $<pn>3;
1499: $$ = new lstmt(LABEL,n->where,n,$<ps>4);
1500: }
1501: | CASE { stmt_seen=1; } e COLON caselab_stmt
1502: { if ($<pe>3 == dummy) error("empty case label");
1503: $$ = new estmt(CASE,$<l>1,$<pe>3,$<ps>5);
1504: }
1505: | DEFAULT COLON { stmt_seen=1; } caselab_stmt
1506: { $$ = new stmt(DEFAULT,$<l>1,$<ps>4); }
1507: ;
1508:
1509:
1510:
1511: /********************* expressions: returns Pexpr **************/
1512: elist : ex_list
1513: { Pexpr e = expr_unlist($<el>1);
1514: while (e && e->e1==dummy) {
1515: register Pexpr ee2 = e->e2;
1516: if (ee2) error("EX inEL");
1517: delete e;
1518: e = ee2;
1519: }
1520: $$ = e;
1521: }
1522: ;
1523:
1524: ex_list : initializer %prec CM
1525: { $<el>$ = new elist(new expr(ELIST,$<pe>1,0)); }
1526: | ex_list CM initializer
1527: { $<el>1->add(new expr(ELIST,$<pe>3,0)); }
1528: ;
1529:
1530: initializer : e %prec CM
1531: | LC elist RC
1532: {
1533: if ( in_arg_list )
1534: error( "syntax error: IrL not permitted in AL" );
1535: else if ( in_binit_list )
1536: error( "syntax error: IrL not permitted inMIr" );
1537: else
1538: init_seen = 1;
1539: Pexpr e;
1540: if ($2)
1541: e = $<pe>2;
1542: else
1543: e = new expr(ELIST,dummy,0);
1544: $$ = new expr(ILIST,e,0);
1545: }
1546: ;
1547:
1548: ee : ee ASSIGN ee
1549: { bbinop: $$ = new expr($<t>2,$<pe>1,$<pe>3); }
1550: | ee PLUS ee { goto bbinop; }
1551: | ee MINUS ee { goto bbinop; }
1552: | ee MUL ee { goto bbinop; }
1553: | ee AND ee { goto bbinop; }
1554: | ee OR ee { goto bbinop; }
1555: | ee ER ee { goto bbinop; }
1556: | ee SHIFTOP ee { goto bbinop; }
1557: | ee EQUOP ee { goto bbinop; }
1558: | ee DIVOP ee { goto bbinop; }
1559: | ee RELOP ee { goto bbinop; }
1560: | ee ANDAND ee { goto bbinop; }
1561: | ee OROR ee { goto bbinop; }
1562: | ee ASOP ee { goto bbinop; }
1563: | ee CM ee { goto bbinop; }
1564: | ee QUEST ee COLON ee
1565: { $$ = new qexpr($<pe>1,$<pe>3,$<pe>5); }
1566: | DELETE term
1567: { $$ = new expr(DELETE,$<pe>2,0); }
1568: | DELETE LB e RB term
1569: {
1570: if($<pe>3 != dummy) {
1571: if ( warning_opt || strict_opt )
1572: error(strict_opt?0:'w',"v in `delete[v]' is redundant; use `delete[] instead (anachronism)");
1573: }
1574: $$ = new expr(DELETE,$<pe>5,$<pe>3);
1575: }
1576: | MEM DELETE term
1577: { $$ = new expr(GDELETE,$<pe>3,0); }
1578: | MEM DELETE LB e RB term
1579: {
1580: if($<pe>4 != dummy) {
1581: if ( warning_opt || strict_opt )
1582: error(strict_opt?0:'w',"v in `::delete[v]' is redundant; use `::delete[] instead (anachronism)");
1583: }
1584: $$ = new expr(DELETE,$<pe>6,$<pe>4);
1585: }
1586: | term
1587: ;
1588:
1589: e : e ASSIGN e
1590: { binop: $$ = new expr($<t>2,$<pe>1,$<pe>3); }
1591: | e PLUS e { goto binop; }
1592: | e MINUS e { goto binop; }
1593: | e MUL e { goto binop; }
1594: | e AND e { goto binop; }
1595: | e OR e { goto binop; }
1596: | e ER e { goto binop; }
1597: | e SHIFTOP e { goto binop; }
1598: | e EQUOP e { goto binop; }
1599: | e DIVOP e { goto binop; }
1600: | e RELOP e { goto binop; }
1601: | e ANDAND e { goto binop; }
1602: | e OROR e { goto binop; }
1603: | e ASOP e { goto binop; }
1604: | e CM e { goto binop; }
1605: | e QUEST e COLON e
1606: { $$ = new qexpr($<pe>1,$<pe>3,$<pe>5); }
1607: | DELETE term
1608: { $$ = new expr(DELETE,$<pe>2,0); }
1609: | DELETE LB e RB term
1610: {
1611: if($<pe>3 != dummy) {
1612: if ( warning_opt || strict_opt )
1613: error(strict_opt?0:'w',"v in `delete[v]' is redundant; use `delete[] instead (anachronism)");
1614: }
1615: $$ = new expr(DELETE,$<pe>5,$<pe>3);
1616: }
1617: | MEM DELETE term
1618: { $$ = new expr(GDELETE,$<pe>3,0); }
1619: | MEM DELETE LB e RB term
1620: {
1621: if($<pe>4 != dummy) {
1622: if ( warning_opt || strict_opt )
1623: error(strict_opt?0:'w',"v in `::delete[v]' is redundant; use `::delete[] instead (anachronism)");
1624: }
1625: $$ = new expr(DELETE,$<pe>6,$<pe>4);
1626: }
1627: | term {
1628: init_seen = 0;
1629: }
1630: | %prec NO_EXPR
1631: { $$ = dummy; }
1632: ;
1633:
1634: term : NEW cast_type { goto new1; }
1635: | NEW new_type
1636: { new1:
1637: Ptype t = $<pn>2->tp;
1638: $$ = new texpr(NEW,t,0);
1639: }
1640: | MEM NEW cast_type { goto new3; }
1641: | MEM NEW new_type
1642: { new3:
1643: Ptype t = $<pn>3->tp;
1644: $$ = new texpr(GNEW,t,0);
1645: }
1646: | term ICOP
1647: { $$ = new expr($<t>2,$<pe>1,0); }
1648: | cast_type term %prec ICOP
1649: { $$ = new texpr(CAST,$<pn>1->tp,$<pe>2); }
1650: | MUL term
1651: { $$ = new expr(DEREF,$<pe>2,0); }
1652: | AND term
1653: { $$ = new expr(ADDROF,0,$<pe>2); }
1654: | MINUS term
1655: { $$ = new expr(UMINUS,0,$<pe>2); }
1656: | PLUS term
1657: { $$ = new expr(UPLUS,0,$<pe>2); }
1658: | NOT term
1659: { $$ = new expr(NOT,0,$<pe>2); }
1660: | COMPL term
1661: { $$ = new expr(COMPL,0,$<pe>2); }
1662: | ICOP term
1663: { $$ = new expr($<t>1,0,$<pe>2); }
1664: | SIZEOF term
1665: {
1666: $$ = new texpr(SIZEOF,0,$<pe>2);
1667: in_sizeof = 0;
1668: }
1669: | SIZEOF cast_type %prec SIZEOF
1670: {
1671: $$ = new texpr(SIZEOF,$<pn>2->tp,0);
1672: in_sizeof = 0;
1673: }
1674: | term LB e RB
1675: { $$ = new expr(DEREF,$<pe>1,$<pe>3); }
1676: | term REF prim
1677: { $$ = new ref(REF,$<pe>1,$<pn>3); }
1678: | term REFMUL term
1679: { $$ = new expr($<t>2,$<pe>1,$<pe>3); }
1680: | term REF qualified_tname
1681: { $$ = new ref(REF,$<pe>1,Ncopy($<pn>3)); }
1682: | term DOT prim
1683: { $$ = new ref(DOT,$<pe>1,$<pn>3); }
1684: | term DOT qualified_tname
1685: { $$ = new ref(DOT,$<pe>1,Ncopy($<pn>3)); }
1686: | prim
1687: | term_elist
1688: {
1689: if ( init_seen )
1690: error( "syntax error:IrL illegal within ()");
1691: }
1692:
1693: | term_lp e RP
1694: {
1695: if ( $2 == dummy )
1696: error("syntax error: nullE");
1697: $$ = $2;
1698: }
1699: | ZERO
1700: { $$ = zero; }
1701: | ICON
1702: { $$ = new expr(ICON,0,0);
1703: $<pe>$->string = $<s>1;
1704: }
1705: | FCON
1706: { $$ = new expr(FCON,0,0);
1707: $<pe>$->string = $<s>1;
1708: }
1709: | STRING
1710: { $$ = new expr(STRING,0,0);
1711: $<pe>$->string = $<s>1;
1712: }
1713: | CCON
1714: { $$ = new expr(CCON,0,0);
1715: $<pe>$->string = $<s>1;
1716: }
1717: | THIS
1718: { $$ = new expr(THIS,0,0); }
1719: ;
1720:
1721: term_elist : TYPE LP elist RP
1722: { $$ = new texpr(VALUE,tok_to_type($<t>1),$<pe>3); }
1723: | qualified_tname LP elist RP
1724: { $$ = new texpr(VALUE,$<pn>1->tp,$<pe>3); }
1725: | NEW term_lp elist RP cast_type { goto new2; }
1726: | NEW term_lp elist RP new_type /* allow separate allocation */
1727: { new2:
1728: Ptype t = $<pn>5->tp;
1729: $$=new texpr(NEW,t,0);
1730: $<pe>$->e2 = $<pe>3;
1731: }
1732: | MEM NEW term_lp elist RP cast_type { goto new4; }
1733: | MEM NEW term_lp elist RP new_type /* allow separate allocation */
1734: { new4:
1735: Ptype t = $<pn>6->tp;
1736: $$ = new texpr(GNEW,t,0);
1737: $<pe>$->e2 = $<pe>4;
1738: }
1739: | term LP elist RP
1740: {
1741: Pexpr ee = $<pe>3;
1742: Pexpr e = $<pe>1;
1743: if (e->base==NEW || e->base==GNEW)
1744: e->e1 = ee;
1745: else
1746: $$ = new call(e,ee);
1747: }
1748:
1749: ;
1750: tscope : TSCOPE
1751: {
1752: $<pn>$ = $<pn>1;
1753: curr_scope = $<pn>1;
1754: }
1755: | MEM
1756: { $<pn>$ = sta_name; }
1757: ;
1758:
1759:
1760: prim : ID
1761: { $$ = $<pn>1; }
1762: /*XXX*/ | tn_list ID
1763: { $$ = Ncopy($<pn>2);
1764: $<pn>$->n_qualifier = $<pn>1;
1765: }
1766: | OPERATOR oper
1767: { $$ = new name(oper_name($2));
1768: $<pn>$->n_oper = $<t>2;
1769: }
1770: | tn_list OPERATOR oper
1771: { $$ = new name(oper_name($3));
1772: $<pn>$->n_oper = $<t>3;
1773: $<pn>$->n_qualifier = $<pn>1;
1774: }
1775: | OPERATOR c_type
1776: { $$ = $2;
1777: sig_name($<pn>$);
1778: }
1779: | tn_list OPERATOR c_type
1780: { $$ = $3;
1781: sig_name($<pn>$);
1782: $<pn>$->n_qualifier = $<pn>1;
1783: }
1784: | tn_list COMPL tag /* allow explicit call of destructor */
1785: {
1786: if (strcmp($<pn>1->string,$<pn>3->string)) error("syntax error: inconsistent destructor notation");
1787: $$ = new name(oper_name(DTOR));
1788: $<pn>$->n_oper = DTOR;
1789: $<pn>$->n_qualifier = $<pn>1;
1790: }
1791: ;
1792:
1793:
1794:
1795: /****************** abstract types (return type Pname) *************/
1796: cast_type : term_lp type cast_decl RP
1797: { $$ = Ncast($2,$<pn>3); }
1798: ;
1799:
1800: term_lp : LP { check_cast(); }
1801: ;
1802:
1803: c_tp : TYPE
1804: {
1805: TOK t = $<t>1;
1806:
1807: switch (t) {
1808: case FRIEND:
1809: case OVERLOAD:
1810: case REGISTER:
1811: case STATIC:
1812: case EXTERN:
1813: case AUTO:
1814: case VIRTUAL:
1815: error("%k in operatorT",t);
1816: t = INT;
1817:
1818: }
1819:
1820: $$ = new basetype(t,0);
1821:
1822: }
1823: | qualified_tname { $$ = new basetype(TYPE,$<pn>1); }
1824: | c_tp TYPE
1825: {
1826: if ( DECL_TYPE != -1 )
1827: $$ = $<pb>1->type_adj($<t>2);
1828: DECL_TYPE = 0;
1829: }
1830: | c_tp qualified_tname
1831: {
1832: if ( DECL_TYPE != -1 )
1833: $$ = $<pb>1->name_adj($<pn>2);
1834: DECL_TYPE = 0;
1835: }
1836: ;
1837:
1838: c_type : c_tp c_decl { $$ = Ncast($1,$<pn>2); }
1839: ;
1840:
1841: new_type : type new_decl { $$ = Ncast($1,$<pn>2); };
1842:
1843: arg_type : type arg_decl
1844: { $$ = Ndata($1,$<pn>2); }
1845: | type arg_decl ASSIGN initializer
1846: { $$ = Ndata($1,$<pn>2);
1847: $<pn>$->n_initializer = $<pe>4;
1848: }
1849: ;
1850:
1851: arg_lp : LP
1852: {
1853: check_decl();
1854: in_arg_list=1;
1855: $$ = modified_tn;
1856: modified_tn = 0;
1857: }
1858: ;
1859:
1860: arg_list : arg_lp arg_type_list ellipsis_opt RP fct_attributes
1861: {
1862: $$ = new fct(0,name_unlist($<nl>2),$<t>3);
1863: if ( NEXTTOK() != COLON ) in_arg_list=0;
1864: //in_arg_list=0;
1865: Pfct($<pt>$)->f_const = ($<i>5 & 1);
1866: if ( parsing_class_members
1867: || (NEXTTOK()!=LC && yychar!=COLON))
1868: end_al($1,1);
1869: else
1870: end_al($1,0);
1871: }
1872: ;
1873:
1874: arg_type_list : arg_type_list CM at
1875: {
1876: if ($3)
1877: if ($1)
1878: $<nl>1->add($<pn>3);
1879: else {
1880: error("AD syntax");
1881: $<nl>$ = new nlist($<pn>3);
1882: }
1883: else
1884: error("AD syntax");
1885: }
1886: | at %prec CM
1887: {
1888: if ($1) $<nl>$ = new nlist($<pn>1);
1889: }
1890: ;
1891:
1892: at : arg_type
1893: | %prec EMPTY { $$ = 0; }
1894: ;
1895:
1896: ellipsis_opt : /* empty */
1897: { $$ = 1; }
1898: | ELLIPSIS
1899: { $$ = ELLIPSIS; }
1900: | CM ELLIPSIS
1901: { $$ = ELLIPSIS; }
1902: ;
1903:
1904: ptr : MUL %prec NO_ID
1905: {
1906: $$ = new ptr(PTR,0);
1907: EXPECT_ID();
1908: }
1909: | AND %prec NO_ID
1910: {
1911: $$ = new ptr(RPTR,0);
1912: EXPECT_ID();
1913: }
1914: | MUL TYPE %prec NO_ID
1915: { $$ = doptr(PTR,$<t>2); }
1916: | ptr TYPE %prec NO_ID
1917: {
1918: switch ( $<t>2 ) {
1919: case CONST:
1920: $<pp>1->rdo = 1; break;
1921: case VOLATILE:
1922: error('w',"\"volatile\" not implemented (ignored)");
1923: break;
1924: default:
1925: error( "syntax error: *%k", $<t>2 );
1926: }
1927: $$ = $<pp>1;
1928: }
1929: | AND TYPE %prec NO_ID
1930: { $$ = doptr(RPTR,$<t>2); }
1931: | MEMPTR %prec NO_ID
1932: {
1933: $$ = new ptr(PTR,0);
1934: $<pp>$->memof = Pclass(Pbase($<pn>1->tp)->b_name->tp);
1935: EXPECT_ID();
1936: }
1937: | MEMPTR TYPE %prec NO_ID
1938: { $$ = doptr(PTR,$<t>2);
1939: $<pp>$->memof = Pclass(Pbase($<pn>1->tp)->b_name->tp);
1940: }
1941: ;
1942:
1943: vec : LB e RB { $$ = new vec(0,$<pe>2!=dummy?$<pe>2:0 ); }
1944: | NOT %prec LB { $$ = new vec(0,0); }
1945: ;
1946:
1947: %%
1948:
1949: static void
1950: check_tag()
1951: /*
1952: Allow the case of inline/virtual/overload as
1953: modifiers of return type of form struct/class/union x foo()
1954: SM, COLON, LC ==> real class declaration, not return type
1955: */
1956: {
1957: switch ( NEXTTOK() ) {
1958: case SM: case COLON: case LC:
1959: declTag = 1;
1960: break;
1961: default:
1962: declTag = 0;
1963: break;
1964: }
1965: }
1966:
1967: static void
1968: end_al( Plist mtn, int rst )
1969: // unhide type names hidden by arg names
1970: // mtn == saved modified_tn
1971: {
1972: if ( rst == 0 ) {
1973: // not really an arg list, or we are entering a function def
1974: // merge modified_tn and don't restore
1975: if ( modified_tn == 0 ) modified_tn = mtn;
1976: else {
1977: for ( Plist l = modified_tn; l->l; l = l->l ) ;
1978: l->l = mtn;
1979: }
1980: } else {
1981: restore();
1982: modified_tn = mtn;
1983: }
1984: }
1985: static void
1986: arg_redec( Pname fn )
1987: {
1988: if ( fn==0 || fn->tp->base != FCT )
1989: error('i',"bad inline rewrite!");
1990: Pname al = Pfct(fn->tp)->argtype;
1991: Pname n = 0;
1992: for ( ; al; al = al->n_list ) {
1993: DB( if(Ydebug>=1)error('d',"arg_redec: %n %d",al,al->lex_level); );
1994: // nested function args should have lex_level >= 1
1995: if ( al->lex_level==1 && (n=ktbl->look(al->string,0)) )
1996: n->hide();
1997: else if ( al->lex_level>1 && (n=ktbl->look(al->string,LOCAL)) )
1998: n->hide();
1999: DB( if(Ydebug>=1)error('d'," %n",n); );
2000: }
2001: }
2002:
2003:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.