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