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