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