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