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