![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to c-parse.in CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc|
Return to c-parse.in CVS log | Up to [GCC 2.x] / gcc |
1.1 root 1: /* YACC parser for C syntax and for Objective C. -*-c-*- 1.1.1.4 ! root 2: Copyright (C) 1987, 88, 89, 92, 93, 1994 Free Software Foundation, Inc. 1.1 root 3: 4: This file is part of GNU CC. 5: 6: GNU CC is free software; you can redistribute it and/or modify 7: it under the terms of the GNU General Public License as published by 8: the Free Software Foundation; either version 2, or (at your option) 9: any later version. 10: 11: GNU CC is distributed in the hope that it will be useful, 12: but WITHOUT ANY WARRANTY; without even the implied warranty of 13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14: GNU General Public License for more details. 15: 16: You should have received a copy of the GNU General Public License 17: along with GNU CC; see the file COPYING. If not, write to 18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ 19: 20: /* This file defines the grammar of C and that of Objective C. 21: ifobjc ... end ifobjc conditionals contain code for Objective C only. 22: ifc ... end ifc conditionals contain code for C only. 1.1.1.2 root 23: Sed commands in Makefile.in are used to convert this file into 1.1 root 24: c-parse.y and into objc-parse.y. */ 25: 26: /* To whomever it may concern: I have heard that such a thing was once 27: written by AT&T, but I have never seen it. */ 28: 29: ifobjc 1.1.1.4 ! root 30: %expect 22 1.1 root 31: end ifobjc 32: ifc 1.1.1.4 ! root 33: %expect 10 1.1 root 34: 1.1.1.4 ! root 35: /* These are the 10 conflicts you should get in parse.output; 1.1 root 36: the state numbers may vary if minor changes in the grammar are made. 37: 38: State 41 contains 1 shift/reduce conflict. (Two ways to recover from error.) 1.1.1.4 ! root 39: State 97 contains 1 shift/reduce conflict. (Two ways to recover from error.) ! 40: State 104 contains 1 shift/reduce conflict. (Two ways to recover from error.) ! 41: State 108 contains 1 shift/reduce conflict. (Two ways to recover from error.) ! 42: State 124 contains 1 shift/reduce conflict. (See comment at component_decl.) ! 43: State 191 contains 1 shift/reduce conflict. (Two ways to recover from error.) ! 44: State 204 contains 1 shift/reduce conflict. (Two ways to recover from error.) ! 45: State 210 contains 1 shift/reduce conflict. (Two ways to recover from error.) ! 46: State 449 contains 2 shift/reduce conflicts. (Four ways to parse this.) 1.1 root 47: */ 48: end ifc 49: 50: %{ 51: #include <stdio.h> 52: #include <errno.h> 53: #include <setjmp.h> 54: 55: #include "config.h" 56: #include "tree.h" 57: #include "input.h" 58: #include "c-lex.h" 59: #include "c-tree.h" 60: #include "flags.h" 61: 62: #ifdef MULTIBYTE_CHARS 63: #include <stdlib.h> 64: #include <locale.h> 65: #endif 66: 67: ifobjc 1.1.1.2 root 68: #include "objc-act.h" 1.1 root 69: end ifobjc 70: 1.1.1.2 root 71: /* Since parsers are distinct for each language, put the language string 72: definition here. */ 73: ifobjc 74: char *language_string = "GNU Obj-C"; 75: end ifobjc 76: ifc 77: char *language_string = "GNU C"; 78: end ifc 79: 1.1 root 80: #ifndef errno 81: extern int errno; 82: #endif 83: 84: void yyerror (); 85: 86: /* Like YYERROR but do call yyerror. */ 87: #define YYERROR1 { yyerror ("syntax error"); YYERROR; } 88: 89: /* Cause the `yydebug' variable to be defined. */ 90: #define YYDEBUG 1 91: %} 92: 93: %start program 94: 95: %union {long itype; tree ttype; enum tree_code code; 96: char *filename; int lineno; } 97: 98: /* All identifiers that are not reserved words 99: and are not declared typedefs in the current block */ 100: %token IDENTIFIER 101: 102: /* All identifiers that are declared typedefs in the current block. 103: In some contexts, they are treated just like IDENTIFIER, 104: but they can also serve as typespecs in declarations. */ 105: %token TYPENAME 106: 107: /* Reserved words that specify storage class. 108: yylval contains an IDENTIFIER_NODE which indicates which one. */ 109: %token SCSPEC 110: 111: /* Reserved words that specify type. 112: yylval contains an IDENTIFIER_NODE which indicates which one. */ 113: %token TYPESPEC 114: 115: /* Reserved words that qualify type: "const" or "volatile". 116: yylval contains an IDENTIFIER_NODE which indicates which one. */ 117: %token TYPE_QUAL 118: 119: /* Character or numeric constants. 120: yylval is the node for the constant. */ 121: %token CONSTANT 122: 123: /* String constants in raw form. 124: yylval is a STRING_CST node. */ 125: %token STRING 126: 127: /* "...", used for functions with variable arglists. */ 128: %token ELLIPSIS 129: 130: /* the reserved words */ 131: /* SCO include files test "ASM", so use something else. */ 132: %token SIZEOF ENUM STRUCT UNION IF ELSE WHILE DO FOR SWITCH CASE DEFAULT 133: %token BREAK CONTINUE RETURN GOTO ASM_KEYWORD TYPEOF ALIGNOF ALIGN 134: %token ATTRIBUTE EXTENSION LABEL 1.1.1.2 root 135: %token REALPART IMAGPART 1.1 root 136: 137: /* Add precedence rules to solve dangling else s/r conflict */ 138: %nonassoc IF 139: %nonassoc ELSE 140: 141: /* Define the operator tokens and their precedences. 142: The value is an integer because, if used, it is the tree code 143: to use in the expression made from the operator. */ 144: 145: %right <code> ASSIGN '=' 146: %right <code> '?' ':' 147: %left <code> OROR 148: %left <code> ANDAND 149: %left <code> '|' 150: %left <code> '^' 151: %left <code> '&' 152: %left <code> EQCOMPARE 153: %left <code> ARITHCOMPARE 154: %left <code> LSHIFT RSHIFT 155: %left <code> '+' '-' 156: %left <code> '*' '/' '%' 157: %right <code> UNARY PLUSPLUS MINUSMINUS 158: %left HYPERUNARY 159: %left <code> POINTSAT '.' '(' '[' 160: 161: /* The Objective-C keywords. These are included in C and in 162: Objective C, so that the token codes are the same in both. */ 163: %token INTERFACE IMPLEMENTATION END SELECTOR DEFS ENCODE 1.1.1.2 root 164: %token CLASSNAME PUBLIC PRIVATE PROTECTED PROTOCOL OBJECTNAME CLASS ALIAS 165: 166: /* Objective-C string constants in raw form. 167: yylval is an OBJC_STRING_CST node. */ 168: %token OBJC_STRING 1.1 root 169: 170: 171: %type <code> unop 172: 173: %type <ttype> identifier IDENTIFIER TYPENAME CONSTANT expr nonnull_exprlist exprlist 174: %type <ttype> expr_no_commas cast_expr unary_expr primary string STRING 175: %type <ttype> typed_declspecs reserved_declspecs 176: %type <ttype> typed_typespecs reserved_typespecquals 177: %type <ttype> declmods typespec typespecqual_reserved 178: %type <ttype> SCSPEC TYPESPEC TYPE_QUAL nonempty_type_quals maybe_type_qual 179: %type <ttype> initdecls notype_initdecls initdcl notype_initdcl 1.1.1.3 root 180: %type <ttype> init maybeasm 1.1 root 181: %type <ttype> asm_operands nonnull_asm_operands asm_operand asm_clobbers 1.1.1.4 ! root 182: %type <ttype> maybe_attribute attributes attribute attribute_list attrib ! 183: %type <ttype> any_word 1.1 root 184: 185: %type <ttype> compstmt 186: 187: %type <ttype> declarator 188: %type <ttype> notype_declarator after_type_declarator 189: %type <ttype> parm_declarator 190: 191: %type <ttype> structsp component_decl_list component_decl_list2 192: %type <ttype> component_decl components component_declarator 193: %type <ttype> enumlist enumerator 194: %type <ttype> typename absdcl absdcl1 type_quals 195: %type <ttype> xexpr parms parm identifiers 196: 197: %type <ttype> parmlist parmlist_1 parmlist_2 198: %type <ttype> parmlist_or_identifiers parmlist_or_identifiers_1 199: %type <ttype> identifiers_or_typenames 200: 201: %type <itype> setspecs 202: 203: %type <filename> save_filename 204: %type <lineno> save_lineno 205: 206: ifobjc 207: /* the Objective-C nonterminals */ 208: 209: %type <ttype> ivar_decl_list ivar_decls ivar_decl ivars ivar_declarator 210: %type <ttype> methoddecl unaryselector keywordselector selector 211: %type <ttype> keyworddecl receiver objcmessageexpr messageargs 212: %type <ttype> keywordexpr keywordarglist keywordarg 213: %type <ttype> myparms myparm optparmlist reservedwords objcselectorexpr 214: %type <ttype> selectorarg keywordnamelist keywordname objcencodeexpr 1.1.1.2 root 215: %type <ttype> objc_string protocolrefs identifier_list objcprotocolexpr 216: %type <ttype> CLASSNAME OBJC_STRING OBJECTNAME 1.1 root 217: end ifobjc 218: 219: %{ 220: /* Number of statements (loosely speaking) seen so far. */ 221: static int stmt_count; 222: 223: /* Input file and line number of the end of the body of last simple_if; 224: used by the stmt-rule immediately after simple_if returns. */ 225: static char *if_stmt_file; 226: static int if_stmt_line; 227: 228: /* List of types and structure classes of the current declaration. */ 229: static tree current_declspecs; 230: 231: /* Stack of saved values of current_declspecs. */ 232: static tree declspec_stack; 233: 234: /* 1 if we explained undeclared var errors. */ 235: static int undeclared_variable_notice; 236: 237: ifobjc 238: /* Objective-C specific information */ 239: 240: tree objc_interface_context; 241: tree objc_implementation_context; 242: tree objc_method_context; 243: tree objc_ivar_chain; 244: tree objc_ivar_context; 245: enum tree_code objc_inherit_code; 246: int objc_receiver_context; 247: int objc_public_flag; 248: 249: end ifobjc 250: 251: /* Tell yyparse how to print a token's value, if yydebug is set. */ 252: 253: #define YYPRINT(FILE,YYCHAR,YYLVAL) yyprint(FILE,YYCHAR,YYLVAL) 254: extern void yyprint (); 255: %} 256: 257: %% 258: program: /* empty */ 259: { if (pedantic) 260: pedwarn ("ANSI C forbids an empty source file"); 261: ifobjc 262: objc_finish (); 263: end ifobjc 264: } 265: | extdefs 266: { 1.1.1.2 root 267: /* In case there were missing closebraces, 268: get us back to the global binding level. */ 269: while (! global_bindings_p ()) 270: poplevel (0, 0, 0); 1.1 root 271: ifobjc 272: objc_finish (); 273: end ifobjc 274: } 275: ; 276: 277: /* the reason for the strange actions in this rule 278: is so that notype_initdecls when reached via datadef 279: can find a valid list of type and sc specs in $0. */ 280: 281: extdefs: 282: {$<ttype>$ = NULL_TREE; } extdef 283: | extdefs {$<ttype>$ = NULL_TREE; } extdef 284: ; 285: 286: extdef: 287: fndef 288: | datadef 289: ifobjc 290: | objcdef 291: end ifobjc 292: | ASM_KEYWORD '(' expr ')' ';' 293: { STRIP_NOPS ($3); 294: if ((TREE_CODE ($3) == ADDR_EXPR 295: && TREE_CODE (TREE_OPERAND ($3, 0)) == STRING_CST) 296: || TREE_CODE ($3) == STRING_CST) 297: assemble_asm ($3); 298: else 299: error ("argument of `asm' is not a constant string"); } 300: ; 301: 302: datadef: 303: setspecs notype_initdecls ';' 304: { if (pedantic) 305: error ("ANSI C forbids data definition with no type or storage class"); 306: else if (!flag_traditional) 307: warning ("data definition has no type or storage class"); } 308: | declmods setspecs notype_initdecls ';' 309: {} 310: | typed_declspecs setspecs initdecls ';' 311: {} 312: | declmods ';' 313: { pedwarn ("empty declaration"); } 314: | typed_declspecs ';' 315: { shadow_tag ($1); } 316: | error ';' 317: | error '}' 318: | ';' 319: { if (pedantic) 320: pedwarn ("ANSI C does not allow extra `;' outside of a function"); } 321: ; 322: 323: fndef: 324: typed_declspecs setspecs declarator 325: { if (! start_function ($1, $3, 0)) 326: YYERROR1; 327: reinit_parse_for_function (); } 328: xdecls 329: { store_parm_decls (); } 330: compstmt_or_error 331: { finish_function (0); } 332: | typed_declspecs setspecs declarator error 333: { } 334: | declmods setspecs notype_declarator 335: { if (! start_function ($1, $3, 0)) 336: YYERROR1; 337: reinit_parse_for_function (); } 338: xdecls 339: { store_parm_decls (); } 340: compstmt_or_error 341: { finish_function (0); } 342: | declmods setspecs notype_declarator error 343: { } 344: | setspecs notype_declarator 345: { if (! start_function (NULL_TREE, $2, 0)) 346: YYERROR1; 347: reinit_parse_for_function (); } 348: xdecls 349: { store_parm_decls (); } 350: compstmt_or_error 351: { finish_function (0); } 352: | setspecs notype_declarator error 353: { } 354: ; 355: 356: identifier: 357: IDENTIFIER 358: | TYPENAME 359: ifobjc 1.1.1.2 root 360: | OBJECTNAME 1.1 root 361: | CLASSNAME 362: end ifobjc 363: ; 364: 365: unop: '&' 366: { $$ = ADDR_EXPR; } 367: | '-' 368: { $$ = NEGATE_EXPR; } 369: | '+' 370: { $$ = CONVERT_EXPR; } 371: | PLUSPLUS 372: { $$ = PREINCREMENT_EXPR; } 373: | MINUSMINUS 374: { $$ = PREDECREMENT_EXPR; } 375: | '~' 376: { $$ = BIT_NOT_EXPR; } 377: | '!' 378: { $$ = TRUTH_NOT_EXPR; } 379: ; 380: 381: expr: nonnull_exprlist 382: { $$ = build_compound_expr ($1); } 383: ; 384: 385: exprlist: 386: /* empty */ 387: { $$ = NULL_TREE; } 388: | nonnull_exprlist 389: ; 390: 391: nonnull_exprlist: 392: expr_no_commas 393: { $$ = build_tree_list (NULL_TREE, $1); } 394: | nonnull_exprlist ',' expr_no_commas 395: { chainon ($1, build_tree_list (NULL_TREE, $3)); } 396: ; 397: 398: unary_expr: 399: primary 400: | '*' cast_expr %prec UNARY 401: { $$ = build_indirect_ref ($2, "unary *"); } 402: /* __extension__ turns off -pedantic for following primary. */ 403: | EXTENSION 404: { $<itype>1 = pedantic; 405: pedantic = 0; } 406: cast_expr %prec UNARY 407: { $$ = $3; 408: pedantic = $<itype>1; } 409: | unop cast_expr %prec UNARY 1.1.1.2 root 410: { $$ = build_unary_op ($1, $2, 0); 411: overflow_warning ($$); } 1.1 root 412: /* Refer to the address of a label as a pointer. */ 413: | ANDAND identifier 414: { tree label = lookup_label ($2); 1.1.1.2 root 415: if (label == 0) 416: $$ = null_pointer_node; 417: else 418: { 419: TREE_USED (label) = 1; 420: $$ = build1 (ADDR_EXPR, ptr_type_node, label); 421: TREE_CONSTANT ($$) = 1; 422: } 423: } 1.1 root 424: /* This seems to be impossible on some machines, so let's turn it off. 425: You can use __builtin_next_arg to find the anonymous stack args. 426: | '&' ELLIPSIS 427: { tree types = TYPE_ARG_TYPES (TREE_TYPE (current_function_decl)); 428: $$ = error_mark_node; 429: if (TREE_VALUE (tree_last (types)) == void_type_node) 430: error ("`&...' used in function with fixed number of arguments"); 431: else 432: { 433: if (pedantic) 434: pedwarn ("ANSI C forbids `&...'"); 435: $$ = tree_last (DECL_ARGUMENTS (current_function_decl)); 436: $$ = build_unary_op (ADDR_EXPR, $$, 0); 437: } } 438: */ 439: | SIZEOF unary_expr %prec UNARY 440: { if (TREE_CODE ($2) == COMPONENT_REF 441: && DECL_BIT_FIELD (TREE_OPERAND ($2, 1))) 442: error ("`sizeof' applied to a bit-field"); 443: $$ = c_sizeof (TREE_TYPE ($2)); } 444: | SIZEOF '(' typename ')' %prec HYPERUNARY 445: { $$ = c_sizeof (groktypename ($3)); } 446: | ALIGNOF unary_expr %prec UNARY 447: { $$ = c_alignof_expr ($2); } 448: | ALIGNOF '(' typename ')' %prec HYPERUNARY 449: { $$ = c_alignof (groktypename ($3)); } 1.1.1.2 root 450: | REALPART cast_expr %prec UNARY 451: { $$ = build_unary_op (REALPART_EXPR, $2, 0); } 452: | IMAGPART cast_expr %prec UNARY 453: { $$ = build_unary_op (IMAGPART_EXPR, $2, 0); } 1.1 root 454: ; 455: 456: cast_expr: 457: unary_expr 458: | '(' typename ')' cast_expr %prec UNARY 459: { tree type = groktypename ($2); 460: $$ = build_c_cast (type, $4); } 1.1.1.3 root 461: | '(' typename ')' '{' 462: { start_init (NULL_TREE, NULL, 0); 463: $2 = groktypename ($2); 464: really_start_incremental_init ($2); } 465: initlist_maybe_comma '}' %prec UNARY 466: { char *name; 467: tree result = pop_init_level (0); 468: tree type = $2; 469: finish_init (); 470: 1.1 root 471: if (pedantic) 472: pedwarn ("ANSI C forbids constructor expressions"); 473: if (TYPE_NAME (type) != 0) 474: { 475: if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE) 476: name = IDENTIFIER_POINTER (TYPE_NAME (type)); 477: else 478: name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))); 479: } 480: else 481: name = ""; 1.1.1.3 root 482: $$ = result; 1.1 root 483: if (TREE_CODE (type) == ARRAY_TYPE && TYPE_SIZE (type) == 0) 484: { 485: int failure = complete_array_type (type, $$, 1); 486: if (failure) 487: abort (); 488: } 489: } 490: ; 491: 492: expr_no_commas: 493: cast_expr 494: | expr_no_commas '+' expr_no_commas 495: { $$ = parser_build_binary_op ($2, $1, $3); } 496: | expr_no_commas '-' expr_no_commas 497: { $$ = parser_build_binary_op ($2, $1, $3); } 498: | expr_no_commas '*' expr_no_commas 499: { $$ = parser_build_binary_op ($2, $1, $3); } 500: | expr_no_commas '/' expr_no_commas 501: { $$ = parser_build_binary_op ($2, $1, $3); } 502: | expr_no_commas '%' expr_no_commas 503: { $$ = parser_build_binary_op ($2, $1, $3); } 504: | expr_no_commas LSHIFT expr_no_commas 505: { $$ = parser_build_binary_op ($2, $1, $3); } 506: | expr_no_commas RSHIFT expr_no_commas 507: { $$ = parser_build_binary_op ($2, $1, $3); } 508: | expr_no_commas ARITHCOMPARE expr_no_commas 509: { $$ = parser_build_binary_op ($2, $1, $3); } 510: | expr_no_commas EQCOMPARE expr_no_commas 511: { $$ = parser_build_binary_op ($2, $1, $3); } 512: | expr_no_commas '&' expr_no_commas 513: { $$ = parser_build_binary_op ($2, $1, $3); } 514: | expr_no_commas '|' expr_no_commas 515: { $$ = parser_build_binary_op ($2, $1, $3); } 516: | expr_no_commas '^' expr_no_commas 517: { $$ = parser_build_binary_op ($2, $1, $3); } 518: | expr_no_commas ANDAND expr_no_commas 519: { $$ = parser_build_binary_op (TRUTH_ANDIF_EXPR, $1, $3); } 520: | expr_no_commas OROR expr_no_commas 521: { $$ = parser_build_binary_op (TRUTH_ORIF_EXPR, $1, $3); } 522: | expr_no_commas '?' xexpr ':' expr_no_commas 523: { $$ = build_conditional_expr ($1, $3, $5); } 524: | expr_no_commas '=' expr_no_commas 525: { $$ = build_modify_expr ($1, NOP_EXPR, $3); 526: C_SET_EXP_ORIGINAL_CODE ($$, MODIFY_EXPR); } 527: | expr_no_commas ASSIGN expr_no_commas 528: { $$ = build_modify_expr ($1, $2, $3); 1.1.1.2 root 529: /* This inhibits warnings in truthvalue_conversion. */ 530: C_SET_EXP_ORIGINAL_CODE ($$, ERROR_MARK); } 1.1 root 531: ; 532: 533: primary: 534: IDENTIFIER 535: { 536: $$ = lastiddecl; 537: if (!$$ || $$ == error_mark_node) 538: { 539: if (yychar == YYEMPTY) 540: yychar = YYLEX; 541: if (yychar == '(') 542: { 543: ifobjc 1.1.1.2 root 544: tree decl; 545: 1.1 root 546: if (objc_receiver_context 547: && ! (objc_receiver_context 548: && strcmp (IDENTIFIER_POINTER ($1), "super"))) 549: /* we have a message to super */ 550: $$ = get_super_receiver (); 551: else if (objc_method_context 1.1.1.2 root 552: && (decl = is_ivar (objc_ivar_chain, $1))) 553: { 554: if (is_private (decl)) 555: $$ = error_mark_node; 556: else 557: $$ = build_ivar_reference ($1); 558: } 1.1 root 559: else 560: end ifobjc 561: { 562: /* Ordinary implicit function declaration. */ 563: $$ = implicitly_declare ($1); 564: assemble_external ($$); 565: TREE_USED ($$) = 1; 566: } 567: } 568: else if (current_function_decl == 0) 569: { 1.1.1.2 root 570: error ("`%s' undeclared here (not in a function)", 1.1 root 571: IDENTIFIER_POINTER ($1)); 572: $$ = error_mark_node; 573: } 574: else 575: { 576: ifobjc 1.1.1.2 root 577: tree decl; 578: 1.1 root 579: if (objc_receiver_context 580: && ! strcmp (IDENTIFIER_POINTER ($1), "super")) 581: /* we have a message to super */ 582: $$ = get_super_receiver (); 583: else if (objc_method_context 1.1.1.2 root 584: && (decl = is_ivar (objc_ivar_chain, $1))) 585: { 586: if (is_private (decl)) 587: $$ = error_mark_node; 588: else 589: $$ = build_ivar_reference ($1); 590: } 1.1 root 591: else 592: end ifobjc 593: { 594: if (IDENTIFIER_GLOBAL_VALUE ($1) != error_mark_node 595: || IDENTIFIER_ERROR_LOCUS ($1) != current_function_decl) 596: { 597: error ("`%s' undeclared (first use this function)", 598: IDENTIFIER_POINTER ($1)); 599: 600: if (! undeclared_variable_notice) 601: { 602: error ("(Each undeclared identifier is reported only once"); 603: error ("for each function it appears in.)"); 604: undeclared_variable_notice = 1; 605: } 606: } 607: $$ = error_mark_node; 608: /* Prevent repeated error messages. */ 609: IDENTIFIER_GLOBAL_VALUE ($1) = error_mark_node; 610: IDENTIFIER_ERROR_LOCUS ($1) = current_function_decl; 611: } 612: } 613: } 614: else if (TREE_TYPE ($$) == error_mark_node) 615: $$ = error_mark_node; 616: else if (C_DECL_ANTICIPATED ($$)) 617: { 618: /* The first time we see a build-in function used, 619: if it has not been declared. */ 620: C_DECL_ANTICIPATED ($$) = 0; 621: if (yychar == YYEMPTY) 622: yychar = YYLEX; 623: if (yychar == '(') 624: { 625: /* Omit the implicit declaration we 626: would ordinarily do, so we don't lose 627: the actual built in type. 628: But print a diagnostic for the mismatch. */ 629: ifobjc 630: if (objc_method_context 631: && is_ivar (objc_ivar_chain, $1)) 632: error ("Instance variable `%s' implicitly declared as function", 633: IDENTIFIER_POINTER (DECL_NAME ($$))); 634: else 635: end ifobjc 636: if (TREE_CODE ($$) != FUNCTION_DECL) 637: error ("`%s' implicitly declared as function", 638: IDENTIFIER_POINTER (DECL_NAME ($$))); 639: else if ((TYPE_MODE (TREE_TYPE (TREE_TYPE ($$))) 640: != TYPE_MODE (integer_type_node)) 641: && (TREE_TYPE (TREE_TYPE ($$)) 642: != void_type_node)) 643: pedwarn ("type mismatch in implicit declaration for built-in function `%s'", 644: IDENTIFIER_POINTER (DECL_NAME ($$))); 645: /* If it really returns void, change that to int. */ 646: if (TREE_TYPE (TREE_TYPE ($$)) == void_type_node) 647: TREE_TYPE ($$) 648: = build_function_type (integer_type_node, 649: TYPE_ARG_TYPES (TREE_TYPE ($$))); 650: } 651: else 652: pedwarn ("built-in function `%s' used without declaration", 653: IDENTIFIER_POINTER (DECL_NAME ($$))); 654: 655: /* Do what we would ordinarily do when a fn is used. */ 656: assemble_external ($$); 657: TREE_USED ($$) = 1; 658: } 659: else 660: { 661: assemble_external ($$); 662: TREE_USED ($$) = 1; 663: ifobjc 664: /* we have a definition - still check if iVariable */ 665: 666: if (!objc_receiver_context 667: || (objc_receiver_context 668: && strcmp (IDENTIFIER_POINTER ($1), "super"))) 669: { 1.1.1.2 root 670: tree decl; 671: 1.1 root 672: if (objc_method_context 1.1.1.2 root 673: && (decl = is_ivar (objc_ivar_chain, $1))) 1.1 root 674: { 675: if (IDENTIFIER_LOCAL_VALUE ($1)) 676: warning ("local declaration of `%s' hides instance variable", 677: IDENTIFIER_POINTER ($1)); 678: else 1.1.1.2 root 679: { 680: if (is_private (decl)) 681: $$ = error_mark_node; 682: else 683: $$ = build_ivar_reference ($1); 684: } 1.1 root 685: } 686: } 687: else /* we have a message to super */ 688: $$ = get_super_receiver (); 689: end ifobjc 690: } 691: 692: if (TREE_CODE ($$) == CONST_DECL) 693: { 694: $$ = DECL_INITIAL ($$); 695: /* This is to prevent an enum whose value is 0 696: from being considered a null pointer constant. */ 697: $$ = build1 (NOP_EXPR, TREE_TYPE ($$), $$); 698: TREE_CONSTANT ($$) = 1; 699: } 700: } 701: | CONSTANT 702: | string 703: { $$ = combine_strings ($1); } 704: | '(' expr ')' 705: { char class = TREE_CODE_CLASS (TREE_CODE ($2)); 706: if (class == 'e' || class == '1' 707: || class == '2' || class == '<') 708: C_SET_EXP_ORIGINAL_CODE ($2, ERROR_MARK); 709: $$ = $2; } 710: | '(' error ')' 711: { $$ = error_mark_node; } 712: | '(' 713: { if (current_function_decl == 0) 714: { 715: error ("braced-group within expression allowed only inside a function"); 716: YYERROR; 717: } 718: /* We must force a BLOCK for this level 719: so that, if it is not expanded later, 720: there is a way to turn off the entire subtree of blocks 721: that are contained in it. */ 722: keep_next_level (); 1.1.1.2 root 723: push_iterator_stack (); 1.1 root 724: push_label_level (); 725: $<ttype>$ = expand_start_stmt_expr (); } 726: compstmt ')' 727: { tree rtl_exp; 728: if (pedantic) 729: pedwarn ("ANSI C forbids braced-groups within expressions"); 1.1.1.2 root 730: pop_iterator_stack (); 1.1 root 731: pop_label_level (); 732: rtl_exp = expand_end_stmt_expr ($<ttype>2); 733: /* The statements have side effects, so the group does. */ 734: TREE_SIDE_EFFECTS (rtl_exp) = 1; 735: 1.1.1.3 root 736: if (TREE_CODE ($3) == BLOCK) 737: { 738: /* Make a BIND_EXPR for the BLOCK already made. */ 739: $$ = build (BIND_EXPR, TREE_TYPE (rtl_exp), 740: NULL_TREE, rtl_exp, $3); 741: /* Remove the block from the tree at this point. 742: It gets put back at the proper place 743: when the BIND_EXPR is expanded. */ 744: delete_block ($3); 745: } 746: else 747: $$ = $3; 1.1 root 748: } 749: | primary '(' exprlist ')' %prec '.' 750: { $$ = build_function_call ($1, $3); } 751: | primary '[' expr ']' %prec '.' 752: { $$ = build_array_ref ($1, $3); } 753: | primary '.' identifier 754: { 755: ifobjc 756: if (doing_objc_thang) 757: { 758: if (is_public ($1, $3)) 759: $$ = build_component_ref ($1, $3); 760: else 761: $$ = error_mark_node; 762: } 763: else 764: end ifobjc 765: $$ = build_component_ref ($1, $3); 766: } 767: | primary POINTSAT identifier 768: { 769: tree expr = build_indirect_ref ($1, "->"); 770: 771: ifobjc 772: if (doing_objc_thang) 773: { 774: if (is_public (expr, $3)) 775: $$ = build_component_ref (expr, $3); 776: else 777: $$ = error_mark_node; 778: } 779: else 780: end ifobjc 781: $$ = build_component_ref (expr, $3); 782: } 783: | primary PLUSPLUS 784: { $$ = build_unary_op (POSTINCREMENT_EXPR, $1, 0); } 785: | primary MINUSMINUS 786: { $$ = build_unary_op (POSTDECREMENT_EXPR, $1, 0); } 787: ifobjc 788: | objcmessageexpr 789: { $$ = build_message_expr ($1); } 790: | objcselectorexpr 791: { $$ = build_selector_expr ($1); } 1.1.1.2 root 792: | objcprotocolexpr 793: { $$ = build_protocol_expr ($1); } 1.1 root 794: | objcencodeexpr 795: { $$ = build_encode_expr ($1); } 1.1.1.2 root 796: | objc_string 797: { $$ = build_objc_string_object ($1); } 1.1 root 798: end ifobjc 799: ; 800: 801: /* Produces a STRING_CST with perhaps more STRING_CSTs chained onto it. */ 802: string: 803: STRING 804: | string STRING 805: { $$ = chainon ($1, $2); } 806: ; 807: 1.1.1.2 root 808: ifobjc 809: /* Produces an OBJC_STRING_CST with prehaps more OBJC_STRING_CSTs chained 810: onto it. */ 811: objc_string: 812: OBJC_STRING 813: | objc_string OBJC_STRING 814: { $$ = chainon ($1, $2); } 815: ; 816: end ifobjc 817: 1.1 root 818: xdecls: 819: /* empty */ 820: | datadecls 821: | datadecls ELLIPSIS 822: /* ... is used here to indicate a varargs function. */ 823: { c_mark_varargs (); 824: if (pedantic) 825: pedwarn ("ANSI C does not permit use of `varargs.h'"); } 826: ; 827: 828: /* The following are analogous to lineno_decl, decls and decl 829: except that they do not allow nested functions. 830: They are used for old-style parm decls. */ 831: lineno_datadecl: 832: save_filename save_lineno datadecl 833: { } 834: ; 835: 836: datadecls: 837: lineno_datadecl 838: | errstmt 839: | datadecls lineno_datadecl 840: | lineno_datadecl errstmt 841: ; 842: 843: datadecl: 844: typed_declspecs setspecs initdecls ';' 845: { current_declspecs = TREE_VALUE (declspec_stack); 846: declspec_stack = TREE_CHAIN (declspec_stack); 847: resume_momentary ($2); } 848: | declmods setspecs notype_initdecls ';' 849: { current_declspecs = TREE_VALUE (declspec_stack); 850: declspec_stack = TREE_CHAIN (declspec_stack); 851: resume_momentary ($2); } 852: | typed_declspecs ';' 853: { shadow_tag_warned ($1, 1); 854: pedwarn ("empty declaration"); } 855: | declmods ';' 856: { pedwarn ("empty declaration"); } 857: ; 858: 859: /* This combination which saves a lineno before a decl 860: is the normal thing to use, rather than decl itself. 861: This is to avoid shift/reduce conflicts in contexts 862: where statement labels are allowed. */ 863: lineno_decl: 864: save_filename save_lineno decl 865: { } 866: ; 867: 868: decls: 869: lineno_decl 870: | errstmt 871: | decls lineno_decl 872: | lineno_decl errstmt 873: ; 874: 875: /* records the type and storage class specs to use for processing 876: the declarators that follow. 877: Maintains a stack of outer-level values of current_declspecs, 878: for the sake of parm declarations nested in function declarators. */ 879: setspecs: /* empty */ 880: { $$ = suspend_momentary (); 881: pending_xref_error (); 882: declspec_stack = tree_cons (NULL_TREE, current_declspecs, 883: declspec_stack); 884: current_declspecs = $<ttype>0; } 885: ; 886: 887: decl: 888: typed_declspecs setspecs initdecls ';' 889: { current_declspecs = TREE_VALUE (declspec_stack); 890: declspec_stack = TREE_CHAIN (declspec_stack); 891: resume_momentary ($2); } 892: | declmods setspecs notype_initdecls ';' 893: { current_declspecs = TREE_VALUE (declspec_stack); 894: declspec_stack = TREE_CHAIN (declspec_stack); 895: resume_momentary ($2); } 896: | typed_declspecs setspecs nested_function 897: { current_declspecs = TREE_VALUE (declspec_stack); 898: declspec_stack = TREE_CHAIN (declspec_stack); 899: resume_momentary ($2); } 900: | declmods setspecs notype_nested_function 901: { current_declspecs = TREE_VALUE (declspec_stack); 902: declspec_stack = TREE_CHAIN (declspec_stack); 903: resume_momentary ($2); } 904: | typed_declspecs ';' 905: { shadow_tag ($1); } 906: | declmods ';' 907: { pedwarn ("empty declaration"); } 908: ; 909: 910: /* Declspecs which contain at least one type specifier or typedef name. 911: (Just `const' or `volatile' is not enough.) 912: A typedef'd name following these is taken as a name to be declared. */ 913: 914: typed_declspecs: 915: typespec reserved_declspecs 916: { $$ = tree_cons (NULL_TREE, $1, $2); } 917: | declmods typespec reserved_declspecs 918: { $$ = chainon ($3, tree_cons (NULL_TREE, $2, $1)); } 919: ; 920: 921: reserved_declspecs: /* empty */ 922: { $$ = NULL_TREE; } 923: | reserved_declspecs typespecqual_reserved 924: { $$ = tree_cons (NULL_TREE, $2, $1); } 925: | reserved_declspecs SCSPEC 926: { if (extra_warnings) 927: warning ("`%s' is not at beginning of declaration", 928: IDENTIFIER_POINTER ($2)); 929: $$ = tree_cons (NULL_TREE, $2, $1); } 930: ; 931: 932: /* List of just storage classes and type modifiers. 933: A declaration can start with just this, but then it cannot be used 934: to redeclare a typedef-name. */ 935: 936: declmods: 937: TYPE_QUAL 938: { $$ = tree_cons (NULL_TREE, $1, NULL_TREE); 939: TREE_STATIC ($$) = 1; } 940: | SCSPEC 941: { $$ = tree_cons (NULL_TREE, $1, NULL_TREE); } 942: | declmods TYPE_QUAL 943: { $$ = tree_cons (NULL_TREE, $2, $1); 944: TREE_STATIC ($$) = 1; } 945: | declmods SCSPEC 946: { if (extra_warnings && TREE_STATIC ($1)) 947: warning ("`%s' is not at beginning of declaration", 948: IDENTIFIER_POINTER ($2)); 949: $$ = tree_cons (NULL_TREE, $2, $1); 950: TREE_STATIC ($$) = TREE_STATIC ($1); } 951: ; 952: 953: 954: /* Used instead of declspecs where storage classes are not allowed 955: (that is, for typenames and structure components). 956: Don't accept a typedef-name if anything but a modifier precedes it. */ 957: 958: typed_typespecs: 959: typespec reserved_typespecquals 960: { $$ = tree_cons (NULL_TREE, $1, $2); } 961: | nonempty_type_quals typespec reserved_typespecquals 962: { $$ = chainon ($3, tree_cons (NULL_TREE, $2, $1)); } 963: ; 964: 965: reserved_typespecquals: /* empty */ 966: { $$ = NULL_TREE; } 967: | reserved_typespecquals typespecqual_reserved 968: { $$ = tree_cons (NULL_TREE, $2, $1); } 969: ; 970: 971: /* A typespec (but not a type qualifier). 972: Once we have seen one of these in a declaration, 973: if a typedef name appears then it is being redeclared. */ 974: 975: typespec: TYPESPEC 976: | structsp 977: | TYPENAME 978: { /* For a typedef name, record the meaning, not the name. 979: In case of `foo foo, bar;'. */ 980: $$ = lookup_name ($1); } 981: ifobjc 1.1.1.2 root 982: | CLASSNAME protocolrefs 983: { $$ = get_static_reference ($1, $2); } 984: | OBJECTNAME protocolrefs 985: { $$ = get_object_reference ($2); } 1.1 root 986: end ifobjc 987: | TYPEOF '(' expr ')' 988: { $$ = TREE_TYPE ($3); } 989: | TYPEOF '(' typename ')' 990: { $$ = groktypename ($3); } 991: ; 992: 993: /* A typespec that is a reserved word, or a type qualifier. */ 994: 995: typespecqual_reserved: TYPESPEC 996: | TYPE_QUAL 997: | structsp 998: ; 999: 1000: initdecls: 1001: initdcl 1002: | initdecls ',' initdcl 1003: ; 1004: 1005: notype_initdecls: 1006: notype_initdcl 1007: | notype_initdecls ',' initdcl 1008: ; 1009: 1010: maybeasm: 1011: /* empty */ 1012: { $$ = NULL_TREE; } 1013: | ASM_KEYWORD '(' string ')' 1014: { if (TREE_CHAIN ($3)) $3 = combine_strings ($3); 1015: $$ = $3; 1016: } 1017: ; 1018: 1019: initdcl: 1020: declarator maybeasm maybe_attribute '=' 1.1.1.3 root 1021: { $<ttype>$ = start_decl ($1, current_declspecs, 1); 1022: decl_attributes ($<ttype>$, $3); 1023: start_init ($<ttype>$, $2, global_bindings_p ()); } 1.1 root 1024: init 1025: /* Note how the declaration of the variable is in effect while its init is parsed! */ 1.1.1.3 root 1026: { finish_init (); 1027: decl_attributes ($<ttype>5, $3); 1.1 root 1028: finish_decl ($<ttype>5, $6, $2); } 1029: | declarator maybeasm maybe_attribute 1030: { tree d = start_decl ($1, current_declspecs, 0); 1031: decl_attributes (d, $3); 1032: finish_decl (d, NULL_TREE, $2); } 1033: ; 1034: 1035: notype_initdcl: 1036: notype_declarator maybeasm maybe_attribute '=' 1.1.1.3 root 1037: { $<ttype>$ = start_decl ($1, current_declspecs, 1); 1038: decl_attributes ($<ttype>$, $3); 1039: start_init ($<ttype>$, $2, global_bindings_p ()); } 1.1 root 1040: init 1041: /* Note how the declaration of the variable is in effect while its init is parsed! */ 1.1.1.3 root 1042: { finish_init (); 1043: decl_attributes ($<ttype>5, $3); 1.1 root 1044: finish_decl ($<ttype>5, $6, $2); } 1045: | notype_declarator maybeasm maybe_attribute 1046: { tree d = start_decl ($1, current_declspecs, 0); 1047: decl_attributes (d, $3); 1048: finish_decl (d, NULL_TREE, $2); } 1049: ; 1050: /* the * rules are dummies to accept the Apollo extended syntax 1051: so that the header files compile. */ 1052: maybe_attribute: 1.1.1.4 ! root 1053: /* empty */ ! 1054: { $$ = NULL_TREE; } ! 1055: | attributes ! 1056: { $$ = $1; } ! 1057: ; ! 1058: ! 1059: attributes: ! 1060: attribute ! 1061: { $$ = $1; } ! 1062: | attributes attribute ! 1063: { $$ = chainon ($1, $2); } ! 1064: ; ! 1065: ! 1066: attribute: ! 1067: ATTRIBUTE '(' '(' attribute_list ')' ')' ! 1068: { $$ = $4; } ! 1069: ; ! 1070: ! 1071: attribute_list: ! 1072: attrib ! 1073: { $$ = build_tree_list (NULL_TREE, $1); } ! 1074: | attribute_list ',' attrib ! 1075: { $$ = chainon ($1, build_tree_list (NULL_TREE, $3)); } ! 1076: ; ! 1077: ! 1078: attrib: 1.1 root 1079: /* empty */ 1080: { $$ = NULL_TREE; } 1.1.1.4 ! root 1081: | any_word ! 1082: { $$ = $1; } ! 1083: | any_word '(' IDENTIFIER ')' ! 1084: { $$ = tree_cons ($1, NULL_TREE, ! 1085: build_tree_list (NULL_TREE, $3)); } ! 1086: | any_word '(' IDENTIFIER ',' nonnull_exprlist ')' ! 1087: { $$ = tree_cons ($1, NULL_TREE, ! 1088: tree_cons (NULL_TREE, $3, $5)); } ! 1089: | any_word '(' nonnull_exprlist ')' ! 1090: { $$ = tree_cons ($1, NULL_TREE, $3); } ! 1091: ; ! 1092: ! 1093: /* This still leaves out most reserved keywords, ! 1094: shouldn't we include them? */ 1.1 root 1095: 1.1.1.4 ! root 1096: any_word: ! 1097: identifier ! 1098: | SCSPEC ! 1099: | TYPESPEC ! 1100: | TYPE_QUAL ! 1101: ; 1.1.1.3 root 1102: 1103: /* Initializers. `init' is the entry point. */ 1.1 root 1104: 1105: init: 1106: expr_no_commas 1.1.1.3 root 1107: | '{' 1108: { really_start_incremental_init (NULL_TREE); 1109: /* Note that the call to clear_momentary 1110: is in process_init_element. */ 1111: push_momentary (); } 1112: initlist_maybe_comma '}' 1113: { $$ = pop_init_level (0); 1.1.1.4 ! root 1114: if ($$ == error_mark_node ! 1115: && ! (yychar == STRING || yychar == CONSTANT)) 1.1.1.3 root 1116: pop_momentary (); 1117: else 1118: pop_momentary_nofree (); } 1119: 1.1 root 1120: | error 1.1.1.3 root 1121: { $$ = error_mark_node; } 1.1 root 1122: ; 1123: 1.1.1.3 root 1124: /* `initlist_maybe_comma' is the guts of an initializer in braces. */ 1125: initlist_maybe_comma: 1126: /* empty */ 1127: { if (pedantic) 1128: pedwarn ("ANSI C forbids empty initializer braces"); } 1129: | initlist1 maybecomma 1130: ; 1131: 1132: initlist1: 1133: initelt 1134: | initlist1 ',' initelt 1135: ; 1136: 1137: /* `initelt' is a single element of an initializer. 1138: It may use braces. */ 1139: initelt: 1140: expr_no_commas 1141: { process_init_element ($1); } 1142: | '{' 1143: { push_init_level (0); } 1144: initlist_maybe_comma '}' 1145: { process_init_element (pop_init_level (0)); } 1146: | error 1.1.1.2 root 1147: /* These are for labeled elements. The syntax for an array element 1148: initializer conflicts with the syntax for an Objective-C message, 1149: so don't include these productions in the Objective-C grammer. */ 1150: ifc 1.1.1.3 root 1151: | '[' expr_no_commas ELLIPSIS expr_no_commas ']' '=' 1152: { set_init_index ($2, $4); } 1153: initelt 1154: | '[' expr_no_commas ']' '=' 1155: { set_init_index ($2, NULL_TREE); } 1156: initelt 1.1.1.4 ! root 1157: | '[' expr_no_commas ']' ! 1158: { set_init_index ($2, NULL_TREE); } ! 1159: initelt 1.1.1.2 root 1160: end ifc 1.1.1.3 root 1161: | identifier ':' 1162: { set_init_label ($1); } 1163: initelt 1164: | '.' identifier '=' 1165: { set_init_label ($2); } 1166: initelt 1.1 root 1167: ; 1.1.1.3 root 1168: 1.1 root 1169: nested_function: 1170: declarator 1171: { push_c_function_context (); 1172: if (! start_function (current_declspecs, $1, 1)) 1173: { 1174: pop_c_function_context (); 1175: YYERROR1; 1176: } 1177: reinit_parse_for_function (); 1178: store_parm_decls (); } 1179: /* This used to use compstmt_or_error. 1180: That caused a bug with input `f(g) int g {}', 1181: where the use of YYERROR1 above caused an error 1182: which then was handled by compstmt_or_error. 1183: There followed a repeated execution of that same rule, 1184: which called YYERROR1 again, and so on. */ 1185: compstmt 1186: { finish_function (1); 1187: pop_c_function_context (); } 1188: ; 1189: 1190: notype_nested_function: 1191: notype_declarator 1192: { push_c_function_context (); 1193: if (! start_function (current_declspecs, $1, 1)) 1194: { 1195: pop_c_function_context (); 1196: YYERROR1; 1197: } 1198: reinit_parse_for_function (); 1199: store_parm_decls (); } 1200: /* This used to use compstmt_or_error. 1201: That caused a bug with input `f(g) int g {}', 1202: where the use of YYERROR1 above caused an error 1203: which then was handled by compstmt_or_error. 1204: There followed a repeated execution of that same rule, 1205: which called YYERROR1 again, and so on. */ 1206: compstmt 1207: { finish_function (1); 1208: pop_c_function_context (); } 1209: ; 1210: 1211: /* Any kind of declarator (thus, all declarators allowed 1212: after an explicit typespec). */ 1213: 1214: declarator: 1215: after_type_declarator 1216: | notype_declarator 1217: ; 1218: 1219: /* A declarator that is allowed only after an explicit typespec. */ 1220: 1221: after_type_declarator: 1222: '(' after_type_declarator ')' 1223: { $$ = $2; } 1224: | after_type_declarator '(' parmlist_or_identifiers %prec '.' 1225: { $$ = build_nt (CALL_EXPR, $1, $3, NULL_TREE); } 1226: /* | after_type_declarator '(' error ')' %prec '.' 1227: { $$ = build_nt (CALL_EXPR, $1, NULL_TREE, NULL_TREE); 1228: poplevel (0, 0, 0); } */ 1229: | after_type_declarator '[' expr ']' %prec '.' 1230: { $$ = build_nt (ARRAY_REF, $1, $3); } 1231: | after_type_declarator '[' ']' %prec '.' 1232: { $$ = build_nt (ARRAY_REF, $1, NULL_TREE); } 1233: | '*' type_quals after_type_declarator %prec UNARY 1234: { $$ = make_pointer_declarator ($2, $3); } 1235: | TYPENAME 1.1.1.2 root 1236: ifobjc 1237: | OBJECTNAME 1238: end ifobjc 1.1 root 1239: ; 1240: 1241: /* Kinds of declarator that can appear in a parameter list 1242: in addition to notype_declarator. This is like after_type_declarator 1243: but does not allow a typedef name in parentheses as an identifier 1244: (because it would conflict with a function with that typedef as arg). */ 1245: 1246: parm_declarator: 1247: parm_declarator '(' parmlist_or_identifiers %prec '.' 1248: { $$ = build_nt (CALL_EXPR, $1, $3, NULL_TREE); } 1249: /* | parm_declarator '(' error ')' %prec '.' 1250: { $$ = build_nt (CALL_EXPR, $1, NULL_TREE, NULL_TREE); 1251: poplevel (0, 0, 0); } */ 1252: | parm_declarator '[' expr ']' %prec '.' 1253: { $$ = build_nt (ARRAY_REF, $1, $3); } 1254: | parm_declarator '[' ']' %prec '.' 1255: { $$ = build_nt (ARRAY_REF, $1, NULL_TREE); } 1256: | '*' type_quals parm_declarator %prec UNARY 1257: { $$ = make_pointer_declarator ($2, $3); } 1258: | TYPENAME 1259: ; 1260: 1261: /* A declarator allowed whether or not there has been 1262: an explicit typespec. These cannot redeclare a typedef-name. */ 1263: 1264: notype_declarator: 1265: notype_declarator '(' parmlist_or_identifiers %prec '.' 1266: { $$ = build_nt (CALL_EXPR, $1, $3, NULL_TREE); } 1267: /* | notype_declarator '(' error ')' %prec '.' 1268: { $$ = build_nt (CALL_EXPR, $1, NULL_TREE, NULL_TREE); 1269: poplevel (0, 0, 0); } */ 1270: | '(' notype_declarator ')' 1271: { $$ = $2; } 1272: | '*' type_quals notype_declarator %prec UNARY 1273: { $$ = make_pointer_declarator ($2, $3); } 1274: | notype_declarator '[' expr ']' %prec '.' 1275: { $$ = build_nt (ARRAY_REF, $1, $3); } 1276: | notype_declarator '[' ']' %prec '.' 1277: { $$ = build_nt (ARRAY_REF, $1, NULL_TREE); } 1278: | IDENTIFIER 1279: ; 1280: 1281: structsp: 1282: STRUCT identifier '{' 1283: { $$ = start_struct (RECORD_TYPE, $2); 1284: /* Start scope of tag before parsing components. */ 1285: } 1286: component_decl_list '}' 1287: { $$ = finish_struct ($<ttype>4, $5); 1288: /* Really define the structure. */ 1289: } 1290: | STRUCT '{' component_decl_list '}' 1291: { $$ = finish_struct (start_struct (RECORD_TYPE, NULL_TREE), 1292: $3); } 1293: | STRUCT identifier 1294: { $$ = xref_tag (RECORD_TYPE, $2); } 1295: | UNION identifier '{' 1296: { $$ = start_struct (UNION_TYPE, $2); } 1297: component_decl_list '}' 1298: { $$ = finish_struct ($<ttype>4, $5); } 1299: | UNION '{' component_decl_list '}' 1300: { $$ = finish_struct (start_struct (UNION_TYPE, NULL_TREE), 1301: $3); } 1302: | UNION identifier 1303: { $$ = xref_tag (UNION_TYPE, $2); } 1304: | ENUM identifier '{' 1305: { $<itype>3 = suspend_momentary (); 1306: $$ = start_enum ($2); } 1307: enumlist maybecomma_warn '}' 1308: { $$ = finish_enum ($<ttype>4, nreverse ($5)); 1309: resume_momentary ($<itype>3); } 1310: | ENUM '{' 1311: { $<itype>2 = suspend_momentary (); 1312: $$ = start_enum (NULL_TREE); } 1313: enumlist maybecomma_warn '}' 1314: { $$ = finish_enum ($<ttype>3, nreverse ($4)); 1315: resume_momentary ($<itype>2); } 1316: | ENUM identifier 1317: { $$ = xref_tag (ENUMERAL_TYPE, $2); } 1318: ; 1319: 1320: maybecomma: 1321: /* empty */ 1322: | ',' 1323: ; 1324: 1325: maybecomma_warn: 1326: /* empty */ 1327: | ',' 1328: { if (pedantic) pedwarn ("comma at end of enumerator list"); } 1329: ; 1330: 1331: component_decl_list: 1332: component_decl_list2 1333: { $$ = $1; } 1334: | component_decl_list2 component_decl 1335: { $$ = chainon ($1, $2); 1336: pedwarn ("no semicolon at end of struct or union"); } 1337: ; 1338: 1339: component_decl_list2: /* empty */ 1340: { $$ = NULL_TREE; } 1341: | component_decl_list2 component_decl ';' 1342: { $$ = chainon ($1, $2); } 1343: | component_decl_list2 ';' 1344: { if (pedantic) 1345: pedwarn ("extra semicolon in struct or union specified"); } 1346: ifobjc 1347: /* foo(sizeof(struct{ @defs(ClassName)})); */ 1348: | DEFS '(' CLASSNAME ')' 1.1.1.2 root 1349: { 1350: tree interface = lookup_interface ($3); 1351: 1352: if (interface) 1353: $$ = get_class_ivars (interface); 1354: else 1355: { 1356: error ("Cannot find interface declaration for `%s'", 1357: IDENTIFIER_POINTER ($3)); 1358: $$ = NULL_TREE; 1359: } 1360: } 1.1 root 1361: end ifobjc 1362: ; 1363: 1364: /* There is a shift-reduce conflict here, because `components' may 1365: start with a `typename'. It happens that shifting (the default resolution) 1366: does the right thing, because it treats the `typename' as part of 1367: a `typed_typespecs'. 1368: 1369: It is possible that this same technique would allow the distinction 1370: between `notype_initdecls' and `initdecls' to be eliminated. 1371: But I am being cautious and not trying it. */ 1372: 1373: component_decl: 1374: typed_typespecs setspecs components 1375: { $$ = $3; 1376: current_declspecs = TREE_VALUE (declspec_stack); 1377: declspec_stack = TREE_CHAIN (declspec_stack); 1378: resume_momentary ($2); } 1379: | typed_typespecs 1380: { if (pedantic) 1381: pedwarn ("ANSI C forbids member declarations with no members"); 1382: shadow_tag($1); 1383: $$ = NULL_TREE; } 1384: | nonempty_type_quals setspecs components 1385: { $$ = $3; 1386: current_declspecs = TREE_VALUE (declspec_stack); 1387: declspec_stack = TREE_CHAIN (declspec_stack); 1388: resume_momentary ($2); } 1389: | nonempty_type_quals 1390: { if (pedantic) 1391: pedwarn ("ANSI C forbids member declarations with no members"); 1392: shadow_tag($1); 1393: $$ = NULL_TREE; } 1394: | error 1395: { $$ = NULL_TREE; } 1396: ; 1397: 1398: components: 1399: component_declarator 1400: | components ',' component_declarator 1401: { $$ = chainon ($1, $3); } 1402: ; 1403: 1404: component_declarator: 1405: save_filename save_lineno declarator maybe_attribute 1406: { $$ = grokfield ($1, $2, $3, current_declspecs, NULL_TREE); 1407: decl_attributes ($$, $4); } 1408: | save_filename save_lineno 1409: declarator ':' expr_no_commas maybe_attribute 1410: { $$ = grokfield ($1, $2, $3, current_declspecs, $5); 1411: decl_attributes ($$, $6); } 1.1.1.2 root 1412: | save_filename save_lineno ':' expr_no_commas maybe_attribute 1413: { $$ = grokfield ($1, $2, NULL_TREE, current_declspecs, $4); 1414: decl_attributes ($$, $5); } 1.1 root 1415: ; 1416: 1417: /* We chain the enumerators in reverse order. 1418: They are put in forward order where enumlist is used. 1419: (The order used to be significant, but no longer is so. 1420: However, we still maintain the order, just to be clean.) */ 1421: 1422: enumlist: 1423: enumerator 1424: | enumlist ',' enumerator 1425: { $$ = chainon ($3, $1); } 1.1.1.4 ! root 1426: | error ! 1427: { $$ = error_mark_node; } 1.1 root 1428: ; 1429: 1430: 1431: enumerator: 1432: identifier 1433: { $$ = build_enumerator ($1, NULL_TREE); } 1434: | identifier '=' expr_no_commas 1435: { $$ = build_enumerator ($1, $3); } 1436: ; 1437: 1438: typename: 1439: typed_typespecs absdcl 1440: { $$ = build_tree_list ($1, $2); } 1441: | nonempty_type_quals absdcl 1442: { $$ = build_tree_list ($1, $2); } 1443: ; 1444: 1445: absdcl: /* an absolute declarator */ 1446: /* empty */ 1447: { $$ = NULL_TREE; } 1448: | absdcl1 1449: ; 1450: 1451: nonempty_type_quals: 1452: TYPE_QUAL 1453: { $$ = tree_cons (NULL_TREE, $1, NULL_TREE); } 1454: | nonempty_type_quals TYPE_QUAL 1455: { $$ = tree_cons (NULL_TREE, $2, $1); } 1456: ; 1457: 1458: type_quals: 1459: /* empty */ 1460: { $$ = NULL_TREE; } 1461: | type_quals TYPE_QUAL 1462: { $$ = tree_cons (NULL_TREE, $2, $1); } 1463: ; 1464: 1465: absdcl1: /* a nonempty absolute declarator */ 1466: '(' absdcl1 ')' 1467: { $$ = $2; } 1468: /* `(typedef)1' is `int'. */ 1469: | '*' type_quals absdcl1 %prec UNARY 1470: { $$ = make_pointer_declarator ($2, $3); } 1471: | '*' type_quals %prec UNARY 1472: { $$ = make_pointer_declarator ($2, NULL_TREE); } 1473: | absdcl1 '(' parmlist %prec '.' 1474: { $$ = build_nt (CALL_EXPR, $1, $3, NULL_TREE); } 1475: | absdcl1 '[' expr ']' %prec '.' 1476: { $$ = build_nt (ARRAY_REF, $1, $3); } 1477: | absdcl1 '[' ']' %prec '.' 1478: { $$ = build_nt (ARRAY_REF, $1, NULL_TREE); } 1479: | '(' parmlist %prec '.' 1480: { $$ = build_nt (CALL_EXPR, NULL_TREE, $2, NULL_TREE); } 1481: | '[' expr ']' %prec '.' 1482: { $$ = build_nt (ARRAY_REF, NULL_TREE, $2); } 1483: | '[' ']' %prec '.' 1484: { $$ = build_nt (ARRAY_REF, NULL_TREE, NULL_TREE); } 1485: ; 1486: 1487: /* at least one statement, the first of which parses without error. */ 1488: /* stmts is used only after decls, so an invalid first statement 1489: is actually regarded as an invalid decl and part of the decls. */ 1490: 1491: stmts: 1492: lineno_stmt_or_label 1493: | stmts lineno_stmt_or_label 1494: | stmts errstmt 1495: ; 1496: 1497: xstmts: 1498: /* empty */ 1499: | stmts 1500: ; 1501: 1502: errstmt: error ';' 1503: ; 1504: 1505: pushlevel: /* empty */ 1506: { emit_line_note (input_filename, lineno); 1507: pushlevel (0); 1508: clear_last_expr (); 1509: push_momentary (); 1510: expand_start_bindings (0); 1511: ifobjc 1512: if (objc_method_context) 1513: add_objc_decls (); 1514: end ifobjc 1515: } 1516: ; 1517: 1518: /* Read zero or more forward-declarations for labels 1519: that nested functions can jump to. */ 1520: maybe_label_decls: 1521: /* empty */ 1522: | label_decls 1523: { if (pedantic) 1524: pedwarn ("ANSI C forbids label declarations"); } 1525: ; 1526: 1527: label_decls: 1528: label_decl 1529: | label_decls label_decl 1530: ; 1531: 1532: label_decl: 1533: LABEL identifiers_or_typenames ';' 1534: { tree link; 1535: for (link = $2; link; link = TREE_CHAIN (link)) 1536: { 1537: tree label = shadow_label (TREE_VALUE (link)); 1538: C_DECLARED_LABEL_FLAG (label) = 1; 1539: declare_nonlocal_label (label); 1540: } 1541: } 1542: ; 1543: 1544: /* This is the body of a function definition. 1545: It causes syntax errors to ignore to the next openbrace. */ 1546: compstmt_or_error: 1547: compstmt 1548: {} 1549: | error compstmt 1550: ; 1551: 1552: compstmt: '{' '}' 1553: { $$ = convert (void_type_node, integer_zero_node); } 1554: | '{' pushlevel maybe_label_decls decls xstmts '}' 1555: { emit_line_note (input_filename, lineno); 1556: expand_end_bindings (getdecls (), 1, 0); 1557: $$ = poplevel (1, 1, 0); 1.1.1.4 ! root 1558: if (yychar == CONSTANT || yychar == STRING) ! 1559: pop_momentary_nofree (); ! 1560: else ! 1561: pop_momentary (); } 1.1 root 1562: | '{' pushlevel maybe_label_decls error '}' 1563: { emit_line_note (input_filename, lineno); 1564: expand_end_bindings (getdecls (), kept_level_p (), 0); 1565: $$ = poplevel (kept_level_p (), 0, 0); 1.1.1.4 ! root 1566: if (yychar == CONSTANT || yychar == STRING) ! 1567: pop_momentary_nofree (); ! 1568: else ! 1569: pop_momentary (); } 1.1 root 1570: | '{' pushlevel maybe_label_decls stmts '}' 1571: { emit_line_note (input_filename, lineno); 1572: expand_end_bindings (getdecls (), kept_level_p (), 0); 1573: $$ = poplevel (kept_level_p (), 0, 0); 1.1.1.4 ! root 1574: if (yychar == CONSTANT || yychar == STRING) ! 1575: pop_momentary_nofree (); ! 1576: else ! 1577: pop_momentary (); } 1.1 root 1578: ; 1579: 1580: /* Value is number of statements counted as of the closeparen. */ 1581: simple_if: 1582: if_prefix lineno_labeled_stmt 1583: /* Make sure expand_end_cond is run once 1584: for each call to expand_start_cond. 1585: Otherwise a crash is likely. */ 1586: | if_prefix error 1587: ; 1588: 1589: if_prefix: 1590: IF '(' expr ')' 1591: { emit_line_note ($<filename>-1, $<lineno>0); 1592: expand_start_cond (truthvalue_conversion ($3), 0); 1.1.1.3 root 1593: $<itype>$ = stmt_count; 1.1 root 1594: if_stmt_file = $<filename>-1; 1595: if_stmt_line = $<lineno>0; 1596: position_after_white_space (); } 1597: ; 1598: 1599: /* This is a subroutine of stmt. 1600: It is used twice, once for valid DO statements 1601: and once for catching errors in parsing the end test. */ 1602: do_stmt_start: 1603: DO 1604: { stmt_count++; 1605: emit_line_note ($<filename>-1, $<lineno>0); 1606: /* See comment in `while' alternative, above. */ 1607: emit_nop (); 1608: expand_start_loop_continue_elsewhere (1); 1609: position_after_white_space (); } 1610: lineno_labeled_stmt WHILE 1611: { expand_loop_continue_here (); } 1612: ; 1613: 1614: save_filename: 1615: { $$ = input_filename; } 1616: ; 1617: 1618: save_lineno: 1619: { $$ = lineno; } 1620: ; 1621: 1622: lineno_labeled_stmt: 1623: save_filename save_lineno stmt 1624: { } 1625: /* | save_filename save_lineno error 1626: { } 1627: */ 1628: | save_filename save_lineno label lineno_labeled_stmt 1629: { } 1630: ; 1631: 1632: lineno_stmt_or_label: 1633: save_filename save_lineno stmt_or_label 1634: { } 1635: ; 1636: 1637: stmt_or_label: 1638: stmt 1639: | label 1640: { int next; 1641: position_after_white_space (); 1642: next = getc (finput); 1643: ungetc (next, finput); 1644: if (pedantic && next == '}') 1645: pedwarn ("ANSI C forbids label at end of compound statement"); 1646: } 1647: ; 1648: 1649: /* Parse a single real statement, not including any labels. */ 1650: stmt: 1651: compstmt 1652: { stmt_count++; } 1.1.1.2 root 1653: | all_iter_stmt 1.1 root 1654: | expr ';' 1655: { stmt_count++; 1656: emit_line_note ($<filename>-1, $<lineno>0); 1.1.1.3 root 1657: /* It appears that this should not be done--that a non-lvalue array 1658: shouldn't get an error if the value isn't used. 1659: Section 3.2.2.1 says that an array lvalue gets converted to a pointer 1660: if it appears as a top-level expression, 1661: but says nothing about non-lvalue arrays. */ 1662: #if 0 1663: /* Call default_conversion to get an error 1664: on referring to a register array if pedantic. */ 1665: if (TREE_CODE (TREE_TYPE ($1)) == ARRAY_TYPE 1666: || TREE_CODE (TREE_TYPE ($1)) == FUNCTION_TYPE) 1667: $1 = default_conversion ($1); 1668: #endif 1.1.1.2 root 1669: iterator_expand ($1); 1.1 root 1670: clear_momentary (); } 1671: | simple_if ELSE 1672: { expand_start_else (); 1673: $<itype>1 = stmt_count; 1674: position_after_white_space (); } 1675: lineno_labeled_stmt 1676: { expand_end_cond (); 1677: if (extra_warnings && stmt_count == $<itype>1) 1678: warning ("empty body in an else-statement"); } 1679: | simple_if %prec IF 1680: { expand_end_cond (); 1.1.1.3 root 1681: /* This warning is here instead of in simple_if, because we 1682: do not want a warning if an empty if is followed by an 1.1.1.4 ! root 1683: else statement. Increment stmt_count so we don't ! 1684: give a second error if this is a nested `if'. */ ! 1685: if (extra_warnings && stmt_count++ == $<itype>1) 1.1 root 1686: warning_with_file_and_line (if_stmt_file, if_stmt_line, 1687: "empty body in an if-statement"); } 1688: /* Make sure expand_end_cond is run once 1689: for each call to expand_start_cond. 1690: Otherwise a crash is likely. */ 1691: | simple_if ELSE error 1692: { expand_end_cond (); } 1693: | WHILE 1694: { stmt_count++; 1695: emit_line_note ($<filename>-1, $<lineno>0); 1696: /* The emit_nop used to come before emit_line_note, 1697: but that made the nop seem like part of the preceding line. 1698: And that was confusing when the preceding line was 1699: inside of an if statement and was not really executed. 1700: I think it ought to work to put the nop after the line number. 1701: We will see. --rms, July 15, 1991. */ 1702: emit_nop (); } 1703: '(' expr ')' 1704: { /* Don't start the loop till we have succeeded 1705: in parsing the end test. This is to make sure 1706: that we end every loop we start. */ 1707: expand_start_loop (1); 1708: emit_line_note (input_filename, lineno); 1709: expand_exit_loop_if_false (NULL_PTR, 1710: truthvalue_conversion ($4)); 1711: position_after_white_space (); } 1712: lineno_labeled_stmt 1713: { expand_end_loop (); } 1714: | do_stmt_start 1715: '(' expr ')' ';' 1716: { emit_line_note (input_filename, lineno); 1717: expand_exit_loop_if_false (NULL_PTR, 1718: truthvalue_conversion ($3)); 1719: expand_end_loop (); 1720: clear_momentary (); } 1721: /* This rule is needed to make sure we end every loop we start. */ 1722: | do_stmt_start error 1723: { expand_end_loop (); 1724: clear_momentary (); } 1725: | FOR 1726: '(' xexpr ';' 1727: { stmt_count++; 1728: emit_line_note ($<filename>-1, $<lineno>0); 1729: /* See comment in `while' alternative, above. */ 1730: emit_nop (); 1731: if ($3) c_expand_expr_stmt ($3); 1732: /* Next step is to call expand_start_loop_continue_elsewhere, 1733: but wait till after we parse the entire for (...). 1734: Otherwise, invalid input might cause us to call that 1735: fn without calling expand_end_loop. */ 1736: } 1737: xexpr ';' 1738: /* Can't emit now; wait till after expand_start_loop... */ 1739: { $<lineno>7 = lineno; 1740: $<filename>$ = input_filename; } 1741: xexpr ')' 1742: { 1743: /* Start the loop. Doing this after parsing 1744: all the expressions ensures we will end the loop. */ 1745: expand_start_loop_continue_elsewhere (1); 1746: /* Emit the end-test, with a line number. */ 1747: emit_line_note ($<filename>8, $<lineno>7); 1748: if ($6) 1749: expand_exit_loop_if_false (NULL_PTR, 1750: truthvalue_conversion ($6)); 1751: /* Don't let the tree nodes for $9 be discarded by 1752: clear_momentary during the parsing of the next stmt. */ 1753: push_momentary (); 1754: $<lineno>7 = lineno; 1.1.1.2 root 1755: $<filename>8 = input_filename; 1756: position_after_white_space (); } 1.1 root 1757: lineno_labeled_stmt 1758: { /* Emit the increment expression, with a line number. */ 1759: emit_line_note ($<filename>8, $<lineno>7); 1760: expand_loop_continue_here (); 1761: if ($9) 1762: c_expand_expr_stmt ($9); 1.1.1.4 ! root 1763: if (yychar == CONSTANT || yychar == STRING) ! 1764: pop_momentary_nofree (); ! 1765: else ! 1766: pop_momentary (); 1.1 root 1767: expand_end_loop (); } 1768: | SWITCH '(' expr ')' 1769: { stmt_count++; 1770: emit_line_note ($<filename>-1, $<lineno>0); 1771: c_expand_start_case ($3); 1772: /* Don't let the tree nodes for $3 be discarded by 1773: clear_momentary during the parsing of the next stmt. */ 1774: push_momentary (); 1775: position_after_white_space (); } 1776: lineno_labeled_stmt 1777: { expand_end_case ($3); 1.1.1.4 ! root 1778: if (yychar == CONSTANT || yychar == STRING) ! 1779: pop_momentary_nofree (); ! 1780: else ! 1781: pop_momentary (); } 1.1 root 1782: | BREAK ';' 1783: { stmt_count++; 1784: emit_line_note ($<filename>-1, $<lineno>0); 1785: if ( ! expand_exit_something ()) 1786: error ("break statement not within loop or switch"); } 1787: | CONTINUE ';' 1788: { stmt_count++; 1789: emit_line_note ($<filename>-1, $<lineno>0); 1790: if (! expand_continue_loop (NULL_PTR)) 1791: error ("continue statement not within a loop"); } 1792: | RETURN ';' 1793: { stmt_count++; 1794: emit_line_note ($<filename>-1, $<lineno>0); 1795: c_expand_return (NULL_TREE); } 1796: | RETURN expr ';' 1797: { stmt_count++; 1798: emit_line_note ($<filename>-1, $<lineno>0); 1799: c_expand_return ($2); } 1800: | ASM_KEYWORD maybe_type_qual '(' expr ')' ';' 1801: { stmt_count++; 1802: emit_line_note ($<filename>-1, $<lineno>0); 1803: STRIP_NOPS ($4); 1804: if ((TREE_CODE ($4) == ADDR_EXPR 1805: && TREE_CODE (TREE_OPERAND ($4, 0)) == STRING_CST) 1806: || TREE_CODE ($4) == STRING_CST) 1807: expand_asm ($4); 1808: else 1809: error ("argument of `asm' is not a constant string"); } 1810: /* This is the case with just output operands. */ 1811: | ASM_KEYWORD maybe_type_qual '(' expr ':' asm_operands ')' ';' 1812: { stmt_count++; 1813: emit_line_note ($<filename>-1, $<lineno>0); 1814: c_expand_asm_operands ($4, $6, NULL_TREE, NULL_TREE, 1815: $2 == ridpointers[(int)RID_VOLATILE], 1816: input_filename, lineno); } 1817: /* This is the case with input operands as well. */ 1818: | ASM_KEYWORD maybe_type_qual '(' expr ':' asm_operands ':' asm_operands ')' ';' 1819: { stmt_count++; 1820: emit_line_note ($<filename>-1, $<lineno>0); 1821: c_expand_asm_operands ($4, $6, $8, NULL_TREE, 1822: $2 == ridpointers[(int)RID_VOLATILE], 1823: input_filename, lineno); } 1824: /* This is the case with clobbered registers as well. */ 1825: | ASM_KEYWORD maybe_type_qual '(' expr ':' asm_operands ':' 1826: asm_operands ':' asm_clobbers ')' ';' 1827: { stmt_count++; 1828: emit_line_note ($<filename>-1, $<lineno>0); 1829: c_expand_asm_operands ($4, $6, $8, $10, 1830: $2 == ridpointers[(int)RID_VOLATILE], 1831: input_filename, lineno); } 1832: | GOTO identifier ';' 1833: { tree decl; 1834: stmt_count++; 1835: emit_line_note ($<filename>-1, $<lineno>0); 1836: decl = lookup_label ($2); 1837: if (decl != 0) 1838: { 1839: TREE_USED (decl) = 1; 1840: expand_goto (decl); 1841: } 1842: } 1843: | GOTO '*' expr ';' 1844: { stmt_count++; 1845: emit_line_note ($<filename>-1, $<lineno>0); 1846: expand_computed_goto (convert (ptr_type_node, $3)); } 1847: | ';' 1848: ; 1849: 1.1.1.2 root 1850: all_iter_stmt: 1851: all_iter_stmt_simple 1852: /* | all_iter_stmt_with_decl */ 1853: ; 1854: 1855: all_iter_stmt_simple: 1856: FOR '(' primary ')' 1857: { 1858: /* The value returned by this action is */ 1859: /* 1 if everything is OK */ 1860: /* 0 in case of error or already bound iterator */ 1861: 1862: $<itype>$ = 0; 1863: if (TREE_CODE ($3) != VAR_DECL) 1864: error ("invalid `for (ITERATOR)' syntax"); 1.1.1.3 root 1865: else if (! ITERATOR_P ($3)) 1.1.1.2 root 1866: error ("`%s' is not an iterator", 1867: IDENTIFIER_POINTER (DECL_NAME ($3))); 1868: else if (ITERATOR_BOUND_P ($3)) 1869: error ("`for (%s)' inside expansion of same iterator", 1870: IDENTIFIER_POINTER (DECL_NAME ($3))); 1871: else 1872: { 1873: $<itype>$ = 1; 1874: iterator_for_loop_start ($3); 1875: } 1876: } 1877: lineno_labeled_stmt 1878: { 1879: if ($<itype>5) 1880: iterator_for_loop_end ($3); 1881: } 1882: 1883: /* This really should allow any kind of declaration, 1884: for generality. Fix it before turning it back on. 1885: 1886: all_iter_stmt_with_decl: 1887: FOR '(' ITERATOR pushlevel setspecs iterator_spec ')' 1888: { 1889: */ /* The value returned by this action is */ 1890: /* 1 if everything is OK */ 1891: /* 0 in case of error or already bound iterator */ 1892: /* 1893: iterator_for_loop_start ($6); 1894: } 1895: lineno_labeled_stmt 1896: { 1897: iterator_for_loop_end ($6); 1898: emit_line_note (input_filename, lineno); 1899: expand_end_bindings (getdecls (), 1, 0); 1900: $<ttype>$ = poplevel (1, 1, 0); 1.1.1.4 ! root 1901: if (yychar == CONSTANT || yychar == STRING) ! 1902: pop_momentary_nofree (); ! 1903: else ! 1904: pop_momentary (); 1.1.1.2 root 1905: } 1906: */ 1907: 1.1 root 1908: /* Any kind of label, including jump labels and case labels. 1909: ANSI C accepts labels only before statements, but we allow them 1910: also at the end of a compound statement. */ 1911: 1.1.1.2 root 1912: label: CASE expr_no_commas ':' 1.1 root 1913: { register tree value = check_case_value ($2); 1914: register tree label 1915: = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE); 1916: 1917: stmt_count++; 1918: 1919: if (value != error_mark_node) 1920: { 1921: tree duplicate; 1.1.1.3 root 1922: int success = pushcase (value, convert_and_check, 1923: label, &duplicate); 1.1 root 1924: if (success == 1) 1925: error ("case label not within a switch statement"); 1926: else if (success == 2) 1927: { 1928: error ("duplicate case value"); 1929: error_with_decl (duplicate, "this is the first entry for that value"); 1930: } 1931: else if (success == 3) 1932: warning ("case value out of range"); 1933: else if (success == 5) 1934: error ("case label within scope of cleanup or variable array"); 1935: } 1936: position_after_white_space (); } 1.1.1.2 root 1937: | CASE expr_no_commas ELLIPSIS expr_no_commas ':' 1.1 root 1938: { register tree value1 = check_case_value ($2); 1939: register tree value2 = check_case_value ($4); 1940: register tree label 1941: = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE); 1942: 1943: stmt_count++; 1944: 1945: if (value1 != error_mark_node && value2 != error_mark_node) 1946: { 1947: tree duplicate; 1.1.1.3 root 1948: int success = pushcase_range (value1, value2, 1949: convert_and_check, label, 1.1 root 1950: &duplicate); 1951: if (success == 1) 1952: error ("case label not within a switch statement"); 1953: else if (success == 2) 1954: { 1955: error ("duplicate case value"); 1956: error_with_decl (duplicate, "this is the first entry for that value"); 1957: } 1958: else if (success == 3) 1959: warning ("case value out of range"); 1960: else if (success == 4) 1961: warning ("empty case range"); 1962: else if (success == 5) 1963: error ("case label within scope of cleanup or variable array"); 1964: } 1965: position_after_white_space (); } 1966: | DEFAULT ':' 1967: { 1968: tree duplicate; 1969: register tree label 1970: = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE); 1.1.1.3 root 1971: int success = pushcase (NULL_TREE, 0, label, &duplicate); 1.1 root 1972: stmt_count++; 1973: if (success == 1) 1974: error ("default label not within a switch statement"); 1975: else if (success == 2) 1976: { 1977: error ("multiple default labels in one switch"); 1978: error_with_decl (duplicate, "this is the first default label"); 1979: } 1980: position_after_white_space (); } 1981: | identifier ':' 1982: { tree label = define_label (input_filename, lineno, $1); 1983: stmt_count++; 1984: emit_nop (); 1985: if (label) 1986: expand_label (label); 1987: position_after_white_space (); } 1988: ; 1989: 1990: /* Either a type-qualifier or nothing. First thing in an `asm' statement. */ 1991: 1992: maybe_type_qual: 1993: /* empty */ 1.1.1.3 root 1994: { emit_line_note (input_filename, lineno); 1995: $$ = NULL_TREE; } 1.1 root 1996: | TYPE_QUAL 1997: { emit_line_note (input_filename, lineno); } 1998: ; 1999: 2000: xexpr: 2001: /* empty */ 2002: { $$ = NULL_TREE; } 2003: | expr 2004: ; 2005: 2006: /* These are the operands other than the first string and colon 2007: in asm ("addextend %2,%1": "=dm" (x), "0" (y), "g" (*x)) */ 2008: asm_operands: /* empty */ 2009: { $$ = NULL_TREE; } 2010: | nonnull_asm_operands 2011: ; 2012: 2013: nonnull_asm_operands: 2014: asm_operand 2015: | nonnull_asm_operands ',' asm_operand 2016: { $$ = chainon ($1, $3); } 2017: ; 2018: 2019: asm_operand: 2020: STRING '(' expr ')' 2021: { $$ = build_tree_list ($1, $3); } 2022: ; 2023: 2024: asm_clobbers: 2025: string 2026: { $$ = tree_cons (NULL_TREE, combine_strings ($1), NULL_TREE); } 2027: | asm_clobbers ',' string 2028: { $$ = tree_cons (NULL_TREE, combine_strings ($3), $1); } 2029: ; 2030: 2031: /* This is what appears inside the parens in a function declarator. 2032: Its value is a list of ..._TYPE nodes. */ 2033: parmlist: 2034: { pushlevel (0); 2035: clear_parm_order (); 2036: declare_parm_level (0); } 2037: parmlist_1 2038: { $$ = $2; 2039: parmlist_tags_warning (); 2040: poplevel (0, 0, 0); } 2041: ; 2042: 2043: parmlist_1: 2044: parmlist_2 ')' 2045: | parms ';' 2046: { tree parm; 2047: if (pedantic) 2048: pedwarn ("ANSI C forbids forward parameter declarations"); 2049: /* Mark the forward decls as such. */ 2050: for (parm = getdecls (); parm; parm = TREE_CHAIN (parm)) 2051: TREE_ASM_WRITTEN (parm) = 1; 2052: clear_parm_order (); } 2053: parmlist_1 2054: { $$ = $4; } 2055: | error ')' 2056: { $$ = tree_cons (NULL_TREE, NULL_TREE, NULL_TREE); } 2057: ; 2058: 2059: /* This is what appears inside the parens in a function declarator. 2060: Is value is represented in the format that grokdeclarator expects. */ 2061: parmlist_2: /* empty */ 2062: { $$ = get_parm_info (0); } 2063: | ELLIPSIS 2064: { $$ = get_parm_info (0); 1.1.1.4 ! root 2065: /* Gcc used to allow this as an extension. However, it does ! 2066: not work for all targets, and thus has been disabled. ! 2067: Also, since func (...) and func () are indistinguishable, ! 2068: it caused problems with the code in expand_builtin which ! 2069: tries to verify that BUILT_IN_NEXT_ARG is being used ! 2070: correctly. */ ! 2071: error ("ANSI C requires a named argument before `...'"); 1.1 root 2072: } 2073: | parms 2074: { $$ = get_parm_info (1); } 2075: | parms ',' ELLIPSIS 2076: { $$ = get_parm_info (0); } 2077: ; 2078: 2079: parms: 2080: parm 2081: { push_parm_decl ($1); } 2082: | parms ',' parm 2083: { push_parm_decl ($3); } 2084: ; 2085: 2086: /* A single parameter declaration or parameter type name, 2087: as found in a parmlist. */ 2088: parm: 2089: typed_declspecs parm_declarator 2090: { $$ = build_tree_list ($1, $2) ; } 2091: | typed_declspecs notype_declarator 2092: { $$ = build_tree_list ($1, $2) ; } 2093: | typed_declspecs absdcl 2094: { $$ = build_tree_list ($1, $2); } 2095: | declmods notype_declarator 2096: { $$ = build_tree_list ($1, $2) ; } 2097: | declmods absdcl 2098: { $$ = build_tree_list ($1, $2); } 2099: ; 2100: 2101: /* This is used in a function definition 2102: where either a parmlist or an identifier list is ok. 2103: Its value is a list of ..._TYPE nodes or a list of identifiers. */ 2104: parmlist_or_identifiers: 2105: { pushlevel (0); 2106: clear_parm_order (); 2107: declare_parm_level (1); } 2108: parmlist_or_identifiers_1 2109: { $$ = $2; 2110: parmlist_tags_warning (); 2111: poplevel (0, 0, 0); } 2112: ; 2113: 2114: parmlist_or_identifiers_1: 2115: parmlist_1 2116: | identifiers ')' 2117: { tree t; 2118: for (t = $1; t; t = TREE_CHAIN (t)) 2119: if (TREE_VALUE (t) == NULL_TREE) 2120: error ("`...' in old-style identifier list"); 2121: $$ = tree_cons (NULL_TREE, NULL_TREE, $1); } 2122: ; 2123: 2124: /* A nonempty list of identifiers. */ 2125: identifiers: 2126: IDENTIFIER 2127: { $$ = build_tree_list (NULL_TREE, $1); } 2128: | identifiers ',' IDENTIFIER 2129: { $$ = chainon ($1, build_tree_list (NULL_TREE, $3)); } 2130: ; 2131: 2132: /* A nonempty list of identifiers, including typenames. */ 2133: identifiers_or_typenames: 2134: identifier 2135: { $$ = build_tree_list (NULL_TREE, $1); } 2136: | identifiers_or_typenames ',' identifier 2137: { $$ = chainon ($1, build_tree_list (NULL_TREE, $3)); } 2138: ; 2139: 2140: ifobjc 2141: /* Objective-C productions. */ 2142: 2143: objcdef: 2144: classdef 1.1.1.2 root 2145: | classdecl 2146: | aliasdecl 2147: | protocoldef 1.1 root 2148: | methoddef 2149: | END 2150: { 2151: if (objc_implementation_context) 2152: { 2153: finish_class (objc_implementation_context); 2154: objc_ivar_chain = NULL_TREE; 2155: objc_implementation_context = NULL_TREE; 2156: } 2157: else 2158: warning ("`@end' must appear in an implementation context"); 2159: } 2160: ; 2161: 1.1.1.2 root 2162: /* A nonempty list of identifiers. */ 2163: identifier_list: 2164: identifier 2165: { $$ = build_tree_list (NULL_TREE, $1); } 2166: | identifier_list ',' identifier 2167: { $$ = chainon ($1, build_tree_list (NULL_TREE, $3)); } 2168: ; 2169: 2170: classdecl: 2171: CLASS identifier_list ';' 2172: { 2173: objc_declare_class ($2); 2174: } 2175: 2176: aliasdecl: 2177: ALIAS identifier identifier ';' 2178: { 2179: objc_declare_alias ($2, $3); 2180: } 2181: 1.1 root 2182: classdef: 1.1.1.2 root 2183: INTERFACE identifier protocolrefs '{' 1.1 root 2184: { 2185: objc_interface_context = objc_ivar_context 1.1.1.2 root 2186: = start_class (CLASS_INTERFACE_TYPE, $2, NULL_TREE, $3); 1.1 root 2187: objc_public_flag = 0; 2188: } 2189: ivar_decl_list '}' 2190: { 2191: continue_class (objc_interface_context); 2192: } 2193: methodprotolist 2194: END 2195: { 2196: finish_class (objc_interface_context); 2197: objc_interface_context = NULL_TREE; 2198: } 2199: 1.1.1.2 root 2200: | INTERFACE identifier protocolrefs 1.1 root 2201: { 2202: objc_interface_context 1.1.1.2 root 2203: = start_class (CLASS_INTERFACE_TYPE, $2, NULL_TREE, $3); 1.1 root 2204: continue_class (objc_interface_context); 2205: } 2206: methodprotolist 2207: END 2208: { 2209: finish_class (objc_interface_context); 2210: objc_interface_context = NULL_TREE; 2211: } 2212: 1.1.1.2 root 2213: | INTERFACE identifier ':' identifier protocolrefs '{' 1.1 root 2214: { 2215: objc_interface_context = objc_ivar_context 1.1.1.2 root 2216: = start_class (CLASS_INTERFACE_TYPE, $2, $4, $5); 1.1 root 2217: objc_public_flag = 0; 2218: } 2219: ivar_decl_list '}' 2220: { 2221: continue_class (objc_interface_context); 2222: } 2223: methodprotolist 2224: END 2225: { 2226: finish_class (objc_interface_context); 2227: objc_interface_context = NULL_TREE; 2228: } 2229: 1.1.1.2 root 2230: | INTERFACE identifier ':' identifier protocolrefs 1.1 root 2231: { 2232: objc_interface_context 1.1.1.2 root 2233: = start_class (CLASS_INTERFACE_TYPE, $2, $4, $5); 1.1 root 2234: continue_class (objc_interface_context); 2235: } 2236: methodprotolist 2237: END 2238: { 2239: finish_class (objc_interface_context); 2240: objc_interface_context = NULL_TREE; 2241: } 2242: 2243: | IMPLEMENTATION identifier '{' 2244: { 2245: objc_implementation_context = objc_ivar_context 1.1.1.2 root 2246: = start_class (CLASS_IMPLEMENTATION_TYPE, $2, NULL_TREE, NULL_TREE); 1.1 root 2247: objc_public_flag = 0; 2248: } 2249: ivar_decl_list '}' 2250: { 2251: objc_ivar_chain 2252: = continue_class (objc_implementation_context); 2253: } 2254: 2255: | IMPLEMENTATION identifier 2256: { 2257: objc_implementation_context 1.1.1.2 root 2258: = start_class (CLASS_IMPLEMENTATION_TYPE, $2, NULL_TREE, NULL_TREE); 1.1 root 2259: objc_ivar_chain 2260: = continue_class (objc_implementation_context); 2261: } 2262: 2263: | IMPLEMENTATION identifier ':' identifier '{' 2264: { 2265: objc_implementation_context = objc_ivar_context 1.1.1.2 root 2266: = start_class (CLASS_IMPLEMENTATION_TYPE, $2, $4, NULL_TREE); 1.1 root 2267: objc_public_flag = 0; 2268: } 2269: ivar_decl_list '}' 2270: { 2271: objc_ivar_chain 2272: = continue_class (objc_implementation_context); 2273: } 2274: 2275: | IMPLEMENTATION identifier ':' identifier 2276: { 2277: objc_implementation_context 1.1.1.2 root 2278: = start_class (CLASS_IMPLEMENTATION_TYPE, $2, $4, NULL_TREE); 1.1 root 2279: objc_ivar_chain 2280: = continue_class (objc_implementation_context); 2281: } 2282: 1.1.1.2 root 2283: | INTERFACE identifier '(' identifier ')' protocolrefs 1.1 root 2284: { 2285: objc_interface_context 1.1.1.2 root 2286: = start_class (CATEGORY_INTERFACE_TYPE, $2, $4, $6); 1.1 root 2287: continue_class (objc_interface_context); 2288: } 2289: methodprotolist 2290: END 2291: { 2292: finish_class (objc_interface_context); 2293: objc_interface_context = NULL_TREE; 2294: } 2295: 2296: | IMPLEMENTATION identifier '(' identifier ')' 2297: { 2298: objc_implementation_context 1.1.1.2 root 2299: = start_class (CATEGORY_IMPLEMENTATION_TYPE, $2, $4, NULL_TREE); 1.1 root 2300: objc_ivar_chain 2301: = continue_class (objc_implementation_context); 2302: } 2303: ; 2304: 1.1.1.2 root 2305: protocoldef: 2306: PROTOCOL identifier protocolrefs 2307: { 2308: remember_protocol_qualifiers (); 2309: objc_interface_context 2310: = start_protocol(PROTOCOL_INTERFACE_TYPE, $2, $3); 2311: } 2312: methodprotolist END 2313: { 2314: forget_protocol_qualifiers(); 2315: finish_protocol(objc_interface_context); 2316: objc_interface_context = NULL_TREE; 2317: } 2318: ; 2319: 2320: protocolrefs: 2321: /* empty */ 2322: { 2323: $$ = NULL_TREE; 2324: } 2325: | ARITHCOMPARE identifier_list ARITHCOMPARE 2326: { 2327: if ($1 == LT_EXPR && $3 == GT_EXPR) 2328: $$ = $2; 2329: else 2330: YYERROR1; 2331: } 2332: ; 2333: 1.1 root 2334: ivar_decl_list: 1.1.1.2 root 2335: ivar_decl_list visibility_spec ivar_decls 1.1 root 2336: | ivar_decls 2337: ; 2338: 1.1.1.2 root 2339: visibility_spec: 2340: PRIVATE { objc_public_flag = 2; } 2341: | PROTECTED { objc_public_flag = 0; } 2342: | PUBLIC { objc_public_flag = 1; } 2343: ; 2344: 1.1 root 2345: ivar_decls: 2346: /* empty */ 2347: { 2348: $$ = NULL_TREE; 2349: } 2350: | ivar_decls ivar_decl ';' 2351: | ivar_decls ';' 2352: { 2353: if (pedantic) 1.1.1.2 root 2354: pedwarn ("extra semicolon in struct or union specified"); 1.1 root 2355: } 2356: ; 2357: 2358: 2359: /* There is a shift-reduce conflict here, because `components' may 2360: start with a `typename'. It happens that shifting (the default resolution) 2361: does the right thing, because it treats the `typename' as part of 2362: a `typed_typespecs'. 2363: 2364: It is possible that this same technique would allow the distinction 2365: between `notype_initdecls' and `initdecls' to be eliminated. 2366: But I am being cautious and not trying it. */ 2367: 2368: ivar_decl: 2369: typed_typespecs setspecs ivars 2370: { 2371: $$ = $3; 2372: resume_momentary ($2); 2373: } 2374: | nonempty_type_quals setspecs ivars 2375: { 2376: $$ = $3; 2377: resume_momentary ($2); 2378: } 2379: | error 2380: { $$ = NULL_TREE; } 2381: ; 2382: 2383: ivars: 2384: /* empty */ 2385: { $$ = NULL_TREE; } 2386: | ivar_declarator 2387: | ivars ',' ivar_declarator 2388: ; 2389: 2390: ivar_declarator: 2391: declarator 2392: { 2393: $$ = add_instance_variable (objc_ivar_context, 2394: objc_public_flag, 2395: $1, current_declspecs, 2396: NULL_TREE); 2397: } 2398: | declarator ':' expr_no_commas 2399: { 2400: $$ = add_instance_variable (objc_ivar_context, 2401: objc_public_flag, 2402: $1, current_declspecs, $3); 2403: } 2404: | ':' expr_no_commas 2405: { 2406: $$ = add_instance_variable (objc_ivar_context, 2407: objc_public_flag, 2408: NULL_TREE, 2409: current_declspecs, $2); 2410: } 2411: ; 2412: 2413: methoddef: 2414: '+' 2415: { 1.1.1.2 root 2416: remember_protocol_qualifiers (); 1.1 root 2417: if (objc_implementation_context) 2418: objc_inherit_code = CLASS_METHOD_DECL; 2419: else 2420: fatal ("method definition not in class context"); 2421: } 2422: methoddecl 2423: { 1.1.1.2 root 2424: forget_protocol_qualifiers (); 1.1 root 2425: add_class_method (objc_implementation_context, $3); 2426: start_method_def ($3); 2427: objc_method_context = $3; 2428: } 2429: optarglist 2430: { 2431: continue_method_def (); 2432: } 2433: compstmt_or_error 2434: { 2435: finish_method_def (); 2436: objc_method_context = NULL_TREE; 2437: } 2438: 2439: | '-' 2440: { 1.1.1.2 root 2441: remember_protocol_qualifiers (); 1.1 root 2442: if (objc_implementation_context) 2443: objc_inherit_code = INSTANCE_METHOD_DECL; 2444: else 2445: fatal ("method definition not in class context"); 2446: } 2447: methoddecl 2448: { 1.1.1.2 root 2449: forget_protocol_qualifiers (); 1.1 root 2450: add_instance_method (objc_implementation_context, $3); 2451: start_method_def ($3); 2452: objc_method_context = $3; 2453: } 2454: optarglist 2455: { 2456: continue_method_def (); 2457: } 2458: compstmt_or_error 2459: { 2460: finish_method_def (); 2461: objc_method_context = NULL_TREE; 2462: } 2463: ; 2464: 2465: /* the reason for the strange actions in this rule 2466: is so that notype_initdecls when reached via datadef 2467: can find a valid list of type and sc specs in $0. */ 2468: 2469: methodprotolist: 2470: /* empty */ 2471: | {$<ttype>$ = NULL_TREE; } methodprotolist2 2472: ; 2473: 2474: methodprotolist2: /* eliminates a shift/reduce conflict */ 2475: methodproto 2476: | datadef 2477: | methodprotolist2 methodproto 2478: | methodprotolist2 {$<ttype>$ = NULL_TREE; } datadef 2479: ; 2480: 2481: semi_or_error: 2482: ';' 2483: | error 2484: ; 2485: 2486: methodproto: 2487: '+' 2488: { 2489: objc_inherit_code = CLASS_METHOD_DECL; 2490: } 2491: methoddecl 2492: { 2493: add_class_method (objc_interface_context, $3); 2494: } 2495: semi_or_error 2496: 2497: | '-' 2498: { 2499: objc_inherit_code = INSTANCE_METHOD_DECL; 2500: } 2501: methoddecl 2502: { 2503: add_instance_method (objc_interface_context, $3); 2504: } 2505: semi_or_error 2506: ; 2507: 2508: methoddecl: 2509: '(' typename ')' unaryselector 2510: { 2511: $$ = build_method_decl (objc_inherit_code, $2, $4, NULL_TREE); 2512: } 2513: 2514: | unaryselector 2515: { 2516: $$ = build_method_decl (objc_inherit_code, NULL_TREE, $1, NULL_TREE); 2517: } 2518: 2519: | '(' typename ')' keywordselector optparmlist 2520: { 2521: $$ = build_method_decl (objc_inherit_code, $2, $4, $5); 2522: } 2523: 2524: | keywordselector optparmlist 2525: { 2526: $$ = build_method_decl (objc_inherit_code, NULL_TREE, $1, $2); 2527: } 2528: ; 2529: 2530: /* "optarglist" assumes that start_method_def has already been called... 2531: if it is not, the "xdecls" will not be placed in the proper scope */ 2532: 2533: optarglist: 2534: /* empty */ 2535: | ';' myxdecls 2536: ; 2537: 2538: /* to get around the following situation: "int foo (int a) int b; {}" that 2539: is synthesized when parsing "- a:a b:b; id c; id d; { ... }" */ 2540: 2541: myxdecls: 2542: /* empty */ 2543: | mydecls 2544: ; 2545: 2546: mydecls: 2547: mydecl 2548: | errstmt 2549: | mydecls mydecl 2550: | mydecl errstmt 2551: ; 2552: 2553: mydecl: 2554: typed_declspecs setspecs myparms ';' 2555: { resume_momentary ($2); } 2556: | typed_declspecs ';' 2557: { shadow_tag ($1); } 2558: | declmods ';' 2559: { pedwarn ("empty declaration"); } 2560: ; 2561: 2562: myparms: 2563: myparm 2564: { push_parm_decl ($1); } 2565: | myparms ',' myparm 2566: { push_parm_decl ($3); } 2567: ; 2568: 2569: /* A single parameter declaration or parameter type name, 2570: as found in a parmlist. DOES NOT ALLOW AN INITIALIZER OR ASMSPEC */ 2571: 2572: myparm: 2573: parm_declarator 2574: { $$ = build_tree_list (current_declspecs, $1) ; } 2575: | notype_declarator 2576: { $$ = build_tree_list (current_declspecs, $1) ; } 2577: | absdcl 2578: { $$ = build_tree_list (current_declspecs, $1) ; } 2579: ; 2580: 2581: optparmlist: 2582: /* empty */ 2583: { 2584: $$ = NULL_TREE; 2585: } 2586: | ',' ELLIPSIS 2587: { 2588: /* oh what a kludge! */ 2589: $$ = (tree)1; 2590: } 2591: | ',' 2592: { 2593: pushlevel (0); 2594: } 2595: parmlist_2 2596: { 2597: /* returns a tree list node generated by get_parm_info */ 2598: $$ = $3; 2599: poplevel (0, 0, 0); 2600: } 2601: ; 2602: 2603: unaryselector: 2604: selector 2605: ; 2606: 2607: keywordselector: 2608: keyworddecl 2609: 2610: | keywordselector keyworddecl 2611: { 2612: $$ = chainon ($1, $2); 2613: } 2614: ; 2615: 2616: selector: 2617: IDENTIFIER 2618: | TYPENAME 1.1.1.2 root 2619: | OBJECTNAME 1.1 root 2620: | reservedwords 2621: ; 2622: 2623: reservedwords: 2624: ENUM { $$ = get_identifier (token_buffer); } 2625: | STRUCT { $$ = get_identifier (token_buffer); } 2626: | UNION { $$ = get_identifier (token_buffer); } 2627: | IF { $$ = get_identifier (token_buffer); } 2628: | ELSE { $$ = get_identifier (token_buffer); } 2629: | WHILE { $$ = get_identifier (token_buffer); } 2630: | DO { $$ = get_identifier (token_buffer); } 2631: | FOR { $$ = get_identifier (token_buffer); } 2632: | SWITCH { $$ = get_identifier (token_buffer); } 2633: | CASE { $$ = get_identifier (token_buffer); } 2634: | DEFAULT { $$ = get_identifier (token_buffer); } 2635: | BREAK { $$ = get_identifier (token_buffer); } 2636: | CONTINUE { $$ = get_identifier (token_buffer); } 2637: | RETURN { $$ = get_identifier (token_buffer); } 2638: | GOTO { $$ = get_identifier (token_buffer); } 2639: | ASM_KEYWORD { $$ = get_identifier (token_buffer); } 2640: | SIZEOF { $$ = get_identifier (token_buffer); } 2641: | TYPEOF { $$ = get_identifier (token_buffer); } 2642: | ALIGNOF { $$ = get_identifier (token_buffer); } 2643: | TYPESPEC | TYPE_QUAL 2644: ; 2645: 2646: keyworddecl: 2647: selector ':' '(' typename ')' identifier 2648: { 2649: $$ = build_keyword_decl ($1, $4, $6); 2650: } 2651: 2652: | selector ':' identifier 2653: { 2654: $$ = build_keyword_decl ($1, NULL_TREE, $3); 2655: } 2656: 2657: | ':' '(' typename ')' identifier 2658: { 2659: $$ = build_keyword_decl (NULL_TREE, $3, $5); 2660: } 2661: 2662: | ':' identifier 2663: { 2664: $$ = build_keyword_decl (NULL_TREE, NULL_TREE, $2); 2665: } 2666: ; 2667: 2668: messageargs: 2669: selector 2670: | keywordarglist 2671: ; 2672: 2673: keywordarglist: 2674: keywordarg 2675: | keywordarglist keywordarg 2676: { 2677: $$ = chainon ($1, $2); 2678: } 2679: ; 2680: 2681: 2682: keywordexpr: 2683: nonnull_exprlist 2684: { 2685: if (TREE_CHAIN ($1) == NULL_TREE) 2686: /* just return the expr., remove a level of indirection */ 2687: $$ = TREE_VALUE ($1); 2688: else 2689: /* we have a comma expr., we will collapse later */ 2690: $$ = $1; 2691: } 2692: ; 2693: 2694: keywordarg: 2695: selector ':' keywordexpr 2696: { 2697: $$ = build_tree_list ($1, $3); 2698: } 2699: | ':' keywordexpr 2700: { 2701: $$ = build_tree_list (NULL_TREE, $2); 2702: } 2703: ; 2704: 2705: receiver: 2706: expr 2707: | CLASSNAME 2708: { 2709: $$ = get_class_reference ($1); 2710: } 2711: ; 2712: 2713: objcmessageexpr: 2714: '[' 2715: { objc_receiver_context = 1; } 2716: receiver 2717: { objc_receiver_context = 0; } 2718: messageargs ']' 2719: { 2720: $$ = build_tree_list ($3, $5); 2721: } 2722: ; 2723: 2724: selectorarg: 2725: selector 2726: | keywordnamelist 2727: ; 2728: 2729: keywordnamelist: 2730: keywordname 2731: | keywordnamelist keywordname 2732: { 2733: $$ = chainon ($1, $2); 2734: } 2735: ; 2736: 2737: keywordname: 2738: selector ':' 2739: { 2740: $$ = build_tree_list ($1, NULL_TREE); 2741: } 2742: | ':' 2743: { 2744: $$ = build_tree_list (NULL_TREE, NULL_TREE); 2745: } 2746: ; 2747: 2748: objcselectorexpr: 2749: SELECTOR '(' selectorarg ')' 2750: { 2751: $$ = $3; 2752: } 2753: ; 2754: 1.1.1.2 root 2755: objcprotocolexpr: 2756: PROTOCOL '(' identifier ')' 2757: { 2758: $$ = $3; 2759: } 2760: ; 2761: 1.1 root 2762: /* extension to support C-structures in the archiver */ 2763: 2764: objcencodeexpr: 2765: ENCODE '(' typename ')' 2766: { 2767: $$ = groktypename ($3); 2768: } 2769: ; 2770: 2771: end ifobjc 2772: %%
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.