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