1169689Skan/* Parser for C and Objective-C. 2169689Skan Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 3169689Skan 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. 4169689Skan 5169689Skan Parser actions based on the old Bison parser; structure somewhat 6169689Skan influenced by and fragments based on the C++ parser. 7169689Skan 8169689SkanThis file is part of GCC. 9169689Skan 10169689SkanGCC is free software; you can redistribute it and/or modify it under 11169689Skanthe terms of the GNU General Public License as published by the Free 12169689SkanSoftware Foundation; either version 2, or (at your option) any later 13169689Skanversion. 14169689Skan 15169689SkanGCC is distributed in the hope that it will be useful, but WITHOUT ANY 16169689SkanWARRANTY; without even the implied warranty of MERCHANTABILITY or 17169689SkanFITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 18169689Skanfor more details. 19169689Skan 20169689SkanYou should have received a copy of the GNU General Public License 21169689Skanalong with GCC; see the file COPYING. If not, write to the Free 22169689SkanSoftware Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 23169689Skan02110-1301, USA. */ 24169689Skan 25169689Skan/* TODO: 26169689Skan 27169689Skan Make sure all relevant comments, and all relevant code from all 28169689Skan actions, brought over from old parser. Verify exact correspondence 29169689Skan of syntax accepted. 30169689Skan 31169689Skan Add testcases covering every input symbol in every state in old and 32169689Skan new parsers. 33169689Skan 34169689Skan Include full syntax for GNU C, including erroneous cases accepted 35169689Skan with error messages, in syntax productions in comments. 36169689Skan 37169689Skan Make more diagnostics in the front end generally take an explicit 38169689Skan location rather than implicitly using input_location. */ 39169689Skan 40169689Skan#include "config.h" 41169689Skan#include "system.h" 42169689Skan#include "coretypes.h" 43169689Skan#include "tm.h" 44169689Skan#include "tree.h" 45169689Skan#include "rtl.h" 46169689Skan#include "langhooks.h" 47169689Skan#include "input.h" 48169689Skan#include "cpplib.h" 49169689Skan#include "timevar.h" 50169689Skan#include "c-pragma.h" 51169689Skan#include "c-tree.h" 52169689Skan#include "flags.h" 53169689Skan#include "output.h" 54169689Skan#include "toplev.h" 55169689Skan#include "ggc.h" 56169689Skan#include "c-common.h" 57169689Skan#include "vec.h" 58169689Skan#include "target.h" 59169689Skan#include "cgraph.h" 60169689Skan 61169689Skan 62169689Skan/* Miscellaneous data and functions needed for the parser. */ 63169689Skan 64169689Skanint yydebug; 65169689Skan 66169689Skan/* Objective-C specific parser/lexer information. */ 67169689Skan 68169689Skanstatic int objc_pq_context = 0; 69169689Skan 70169689Skan/* The following flag is needed to contextualize Objective-C lexical 71169689Skan analysis. In some cases (e.g., 'int NSObject;'), it is undesirable 72169689Skan to bind an identifier to an Objective-C class, even if a class with 73169689Skan that name exists. */ 74169689Skanstatic int objc_need_raw_identifier = 0; 75169689Skan#define OBJC_NEED_RAW_IDENTIFIER(VAL) \ 76169689Skan do { \ 77169689Skan if (c_dialect_objc ()) \ 78169689Skan objc_need_raw_identifier = VAL; \ 79169689Skan } while (0) 80169689Skan 81169689Skan/* The reserved keyword table. */ 82169689Skanstruct resword 83169689Skan{ 84169689Skan const char *word; 85169689Skan ENUM_BITFIELD(rid) rid : 16; 86169689Skan unsigned int disable : 16; 87169689Skan}; 88169689Skan 89169689Skan/* Disable mask. Keywords are disabled if (reswords[i].disable & 90169689Skan mask) is _true_. */ 91169689Skan#define D_C89 0x01 /* not in C89 */ 92169689Skan#define D_EXT 0x02 /* GCC extension */ 93169689Skan#define D_EXT89 0x04 /* GCC extension incorporated in C99 */ 94169689Skan#define D_OBJC 0x08 /* Objective C only */ 95169689Skan 96169689Skanstatic const struct resword reswords[] = 97169689Skan{ 98169689Skan { "_Bool", RID_BOOL, 0 }, 99169689Skan { "_Complex", RID_COMPLEX, 0 }, 100169689Skan { "_Decimal32", RID_DFLOAT32, D_EXT }, 101169689Skan { "_Decimal64", RID_DFLOAT64, D_EXT }, 102169689Skan { "_Decimal128", RID_DFLOAT128, D_EXT }, 103169689Skan { "__FUNCTION__", RID_FUNCTION_NAME, 0 }, 104169689Skan { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 }, 105169689Skan { "__alignof", RID_ALIGNOF, 0 }, 106169689Skan { "__alignof__", RID_ALIGNOF, 0 }, 107169689Skan { "__asm", RID_ASM, 0 }, 108169689Skan { "__asm__", RID_ASM, 0 }, 109169689Skan { "__attribute", RID_ATTRIBUTE, 0 }, 110169689Skan { "__attribute__", RID_ATTRIBUTE, 0 }, 111169689Skan { "__builtin_choose_expr", RID_CHOOSE_EXPR, 0 }, 112169689Skan { "__builtin_offsetof", RID_OFFSETOF, 0 }, 113169689Skan { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P, 0 }, 114169689Skan { "__builtin_va_arg", RID_VA_ARG, 0 }, 115169689Skan { "__complex", RID_COMPLEX, 0 }, 116169689Skan { "__complex__", RID_COMPLEX, 0 }, 117169689Skan { "__const", RID_CONST, 0 }, 118169689Skan { "__const__", RID_CONST, 0 }, 119169689Skan { "__extension__", RID_EXTENSION, 0 }, 120169689Skan { "__func__", RID_C99_FUNCTION_NAME, 0 }, 121169689Skan { "__imag", RID_IMAGPART, 0 }, 122169689Skan { "__imag__", RID_IMAGPART, 0 }, 123169689Skan { "__inline", RID_INLINE, 0 }, 124169689Skan { "__inline__", RID_INLINE, 0 }, 125169689Skan { "__label__", RID_LABEL, 0 }, 126169689Skan { "__real", RID_REALPART, 0 }, 127169689Skan { "__real__", RID_REALPART, 0 }, 128169689Skan { "__restrict", RID_RESTRICT, 0 }, 129169689Skan { "__restrict__", RID_RESTRICT, 0 }, 130169689Skan { "__signed", RID_SIGNED, 0 }, 131169689Skan { "__signed__", RID_SIGNED, 0 }, 132169689Skan { "__thread", RID_THREAD, 0 }, 133169689Skan { "__typeof", RID_TYPEOF, 0 }, 134169689Skan { "__typeof__", RID_TYPEOF, 0 }, 135169689Skan { "__volatile", RID_VOLATILE, 0 }, 136169689Skan { "__volatile__", RID_VOLATILE, 0 }, 137169689Skan { "asm", RID_ASM, D_EXT }, 138169689Skan { "auto", RID_AUTO, 0 }, 139169689Skan { "break", RID_BREAK, 0 }, 140169689Skan { "case", RID_CASE, 0 }, 141169689Skan { "char", RID_CHAR, 0 }, 142169689Skan { "const", RID_CONST, 0 }, 143169689Skan { "continue", RID_CONTINUE, 0 }, 144169689Skan { "default", RID_DEFAULT, 0 }, 145169689Skan { "do", RID_DO, 0 }, 146169689Skan { "double", RID_DOUBLE, 0 }, 147169689Skan { "else", RID_ELSE, 0 }, 148169689Skan { "enum", RID_ENUM, 0 }, 149169689Skan { "extern", RID_EXTERN, 0 }, 150169689Skan { "float", RID_FLOAT, 0 }, 151169689Skan { "for", RID_FOR, 0 }, 152169689Skan { "goto", RID_GOTO, 0 }, 153169689Skan { "if", RID_IF, 0 }, 154169689Skan { "inline", RID_INLINE, D_EXT89 }, 155169689Skan { "int", RID_INT, 0 }, 156169689Skan { "long", RID_LONG, 0 }, 157169689Skan { "register", RID_REGISTER, 0 }, 158169689Skan { "restrict", RID_RESTRICT, D_C89 }, 159169689Skan { "return", RID_RETURN, 0 }, 160169689Skan { "short", RID_SHORT, 0 }, 161169689Skan { "signed", RID_SIGNED, 0 }, 162169689Skan { "sizeof", RID_SIZEOF, 0 }, 163169689Skan { "static", RID_STATIC, 0 }, 164169689Skan { "struct", RID_STRUCT, 0 }, 165169689Skan { "switch", RID_SWITCH, 0 }, 166169689Skan { "typedef", RID_TYPEDEF, 0 }, 167169689Skan { "typeof", RID_TYPEOF, D_EXT }, 168169689Skan { "union", RID_UNION, 0 }, 169169689Skan { "unsigned", RID_UNSIGNED, 0 }, 170169689Skan { "void", RID_VOID, 0 }, 171169689Skan { "volatile", RID_VOLATILE, 0 }, 172169689Skan { "while", RID_WHILE, 0 }, 173169689Skan /* These Objective-C keywords are recognized only immediately after 174169689Skan an '@'. */ 175169689Skan { "class", RID_AT_CLASS, D_OBJC }, 176169689Skan { "compatibility_alias", RID_AT_ALIAS, D_OBJC }, 177169689Skan { "defs", RID_AT_DEFS, D_OBJC }, 178169689Skan { "encode", RID_AT_ENCODE, D_OBJC }, 179169689Skan { "end", RID_AT_END, D_OBJC }, 180169689Skan { "implementation", RID_AT_IMPLEMENTATION, D_OBJC }, 181169689Skan { "interface", RID_AT_INTERFACE, D_OBJC }, 182169689Skan { "private", RID_AT_PRIVATE, D_OBJC }, 183169689Skan { "protected", RID_AT_PROTECTED, D_OBJC }, 184169689Skan { "protocol", RID_AT_PROTOCOL, D_OBJC }, 185169689Skan { "public", RID_AT_PUBLIC, D_OBJC }, 186169689Skan { "selector", RID_AT_SELECTOR, D_OBJC }, 187169689Skan { "throw", RID_AT_THROW, D_OBJC }, 188169689Skan { "try", RID_AT_TRY, D_OBJC }, 189169689Skan { "catch", RID_AT_CATCH, D_OBJC }, 190169689Skan { "finally", RID_AT_FINALLY, D_OBJC }, 191169689Skan { "synchronized", RID_AT_SYNCHRONIZED, D_OBJC }, 192169689Skan /* These are recognized only in protocol-qualifier context 193169689Skan (see above) */ 194169689Skan { "bycopy", RID_BYCOPY, D_OBJC }, 195169689Skan { "byref", RID_BYREF, D_OBJC }, 196169689Skan { "in", RID_IN, D_OBJC }, 197169689Skan { "inout", RID_INOUT, D_OBJC }, 198169689Skan { "oneway", RID_ONEWAY, D_OBJC }, 199169689Skan { "out", RID_OUT, D_OBJC }, 200169689Skan}; 201169689Skan#define N_reswords (sizeof reswords / sizeof (struct resword)) 202169689Skan 203169689Skan/* All OpenMP clauses. OpenMP 2.5. */ 204169689Skantypedef enum pragma_omp_clause { 205169689Skan PRAGMA_OMP_CLAUSE_NONE = 0, 206169689Skan 207169689Skan PRAGMA_OMP_CLAUSE_COPYIN, 208169689Skan PRAGMA_OMP_CLAUSE_COPYPRIVATE, 209169689Skan PRAGMA_OMP_CLAUSE_DEFAULT, 210169689Skan PRAGMA_OMP_CLAUSE_FIRSTPRIVATE, 211169689Skan PRAGMA_OMP_CLAUSE_IF, 212169689Skan PRAGMA_OMP_CLAUSE_LASTPRIVATE, 213169689Skan PRAGMA_OMP_CLAUSE_NOWAIT, 214169689Skan PRAGMA_OMP_CLAUSE_NUM_THREADS, 215169689Skan PRAGMA_OMP_CLAUSE_ORDERED, 216169689Skan PRAGMA_OMP_CLAUSE_PRIVATE, 217169689Skan PRAGMA_OMP_CLAUSE_REDUCTION, 218169689Skan PRAGMA_OMP_CLAUSE_SCHEDULE, 219169689Skan PRAGMA_OMP_CLAUSE_SHARED 220169689Skan} pragma_omp_clause; 221169689Skan 222169689Skan 223169689Skan/* Initialization routine for this file. */ 224169689Skan 225169689Skanvoid 226169689Skanc_parse_init (void) 227169689Skan{ 228169689Skan /* The only initialization required is of the reserved word 229169689Skan identifiers. */ 230169689Skan unsigned int i; 231169689Skan tree id; 232169689Skan int mask = (flag_isoc99 ? 0 : D_C89) 233169689Skan | (flag_no_asm ? (flag_isoc99 ? D_EXT : D_EXT|D_EXT89) : 0); 234169689Skan 235169689Skan if (!c_dialect_objc ()) 236169689Skan mask |= D_OBJC; 237169689Skan 238169689Skan ridpointers = GGC_CNEWVEC (tree, (int) RID_MAX); 239169689Skan for (i = 0; i < N_reswords; i++) 240169689Skan { 241169689Skan /* If a keyword is disabled, do not enter it into the table 242169689Skan and so create a canonical spelling that isn't a keyword. */ 243169689Skan if (reswords[i].disable & mask) 244169689Skan continue; 245169689Skan 246169689Skan id = get_identifier (reswords[i].word); 247169689Skan C_RID_CODE (id) = reswords[i].rid; 248169689Skan C_IS_RESERVED_WORD (id) = 1; 249169689Skan ridpointers [(int) reswords[i].rid] = id; 250169689Skan } 251169689Skan} 252169689Skan 253169689Skan/* The C lexer intermediates between the lexer in cpplib and c-lex.c 254169689Skan and the C parser. Unlike the C++ lexer, the parser structure 255169689Skan stores the lexer information instead of using a separate structure. 256169689Skan Identifiers are separated into ordinary identifiers, type names, 257169689Skan keywords and some other Objective-C types of identifiers, and some 258169689Skan look-ahead is maintained. 259169689Skan 260169689Skan ??? It might be a good idea to lex the whole file up front (as for 261169689Skan C++). It would then be possible to share more of the C and C++ 262169689Skan lexer code, if desired. */ 263169689Skan 264169689Skan/* The following local token type is used. */ 265169689Skan 266169689Skan/* A keyword. */ 267169689Skan#define CPP_KEYWORD ((enum cpp_ttype) (N_TTYPES + 1)) 268169689Skan 269169689Skan/* More information about the type of a CPP_NAME token. */ 270169689Skantypedef enum c_id_kind { 271169689Skan /* An ordinary identifier. */ 272169689Skan C_ID_ID, 273169689Skan /* An identifier declared as a typedef name. */ 274169689Skan C_ID_TYPENAME, 275169689Skan /* An identifier declared as an Objective-C class name. */ 276169689Skan C_ID_CLASSNAME, 277169689Skan /* Not an identifier. */ 278169689Skan C_ID_NONE 279169689Skan} c_id_kind; 280169689Skan 281169689Skan/* A single C token after string literal concatenation and conversion 282169689Skan of preprocessing tokens to tokens. */ 283169689Skantypedef struct c_token GTY (()) 284169689Skan{ 285169689Skan /* The kind of token. */ 286169689Skan ENUM_BITFIELD (cpp_ttype) type : 8; 287169689Skan /* If this token is a CPP_NAME, this value indicates whether also 288169689Skan declared as some kind of type. Otherwise, it is C_ID_NONE. */ 289169689Skan ENUM_BITFIELD (c_id_kind) id_kind : 8; 290169689Skan /* If this token is a keyword, this value indicates which keyword. 291169689Skan Otherwise, this value is RID_MAX. */ 292169689Skan ENUM_BITFIELD (rid) keyword : 8; 293169689Skan /* If this token is a CPP_PRAGMA, this indicates the pragma that 294169689Skan was seen. Otherwise it is PRAGMA_NONE. */ 295169689Skan ENUM_BITFIELD (pragma_kind) pragma_kind : 7; 296169689Skan /* True if this token is from a system header. */ 297169689Skan BOOL_BITFIELD in_system_header : 1; 298169689Skan /* The value associated with this token, if any. */ 299169689Skan tree value; 300169689Skan /* The location at which this token was found. */ 301169689Skan location_t location; 302169689Skan} c_token; 303169689Skan 304169689Skan/* A parser structure recording information about the state and 305169689Skan context of parsing. Includes lexer information with up to two 306169689Skan tokens of look-ahead; more are not needed for C. */ 307169689Skantypedef struct c_parser GTY(()) 308169689Skan{ 309169689Skan /* The look-ahead tokens. */ 310169689Skan c_token tokens[2]; 311169689Skan /* How many look-ahead tokens are available (0, 1 or 2). */ 312169689Skan short tokens_avail; 313169689Skan /* True if a syntax error is being recovered from; false otherwise. 314169689Skan c_parser_error sets this flag. It should clear this flag when 315169689Skan enough tokens have been consumed to recover from the error. */ 316169689Skan BOOL_BITFIELD error : 1; 317169689Skan /* True if we're processing a pragma, and shouldn't automatically 318169689Skan consume CPP_PRAGMA_EOL. */ 319169689Skan BOOL_BITFIELD in_pragma : 1; 320169689Skan} c_parser; 321169689Skan 322169689Skan 323169689Skan/* The actual parser and external interface. ??? Does this need to be 324169689Skan garbage-collected? */ 325169689Skan 326169689Skanstatic GTY (()) c_parser *the_parser; 327169689Skan 328169689Skan 329169689Skan/* Read in and lex a single token, storing it in *TOKEN. */ 330169689Skan 331169689Skanstatic void 332169689Skanc_lex_one_token (c_token *token) 333169689Skan{ 334169689Skan timevar_push (TV_LEX); 335169689Skan 336169689Skan token->type = c_lex_with_flags (&token->value, &token->location, NULL); 337169689Skan token->id_kind = C_ID_NONE; 338169689Skan token->keyword = RID_MAX; 339169689Skan token->pragma_kind = PRAGMA_NONE; 340169689Skan token->in_system_header = in_system_header; 341169689Skan 342169689Skan switch (token->type) 343169689Skan { 344169689Skan case CPP_NAME: 345169689Skan { 346169689Skan tree decl; 347169689Skan 348169689Skan int objc_force_identifier = objc_need_raw_identifier; 349169689Skan OBJC_NEED_RAW_IDENTIFIER (0); 350169689Skan 351169689Skan if (C_IS_RESERVED_WORD (token->value)) 352169689Skan { 353169689Skan enum rid rid_code = C_RID_CODE (token->value); 354169689Skan 355169689Skan if (c_dialect_objc ()) 356169689Skan { 357169689Skan if (!OBJC_IS_AT_KEYWORD (rid_code) 358169689Skan && (!OBJC_IS_PQ_KEYWORD (rid_code) || objc_pq_context)) 359169689Skan { 360169689Skan /* Return the canonical spelling for this keyword. */ 361169689Skan token->value = ridpointers[(int) rid_code]; 362169689Skan token->type = CPP_KEYWORD; 363169689Skan token->keyword = rid_code; 364169689Skan break; 365169689Skan } 366169689Skan } 367169689Skan else 368169689Skan { 369169689Skan /* Return the canonical spelling for this keyword. */ 370169689Skan token->value = ridpointers[(int) rid_code]; 371169689Skan token->type = CPP_KEYWORD; 372169689Skan token->keyword = rid_code; 373169689Skan break; 374169689Skan } 375169689Skan } 376169689Skan 377169689Skan decl = lookup_name (token->value); 378169689Skan if (decl) 379169689Skan { 380169689Skan if (TREE_CODE (decl) == TYPE_DECL) 381169689Skan { 382169689Skan token->id_kind = C_ID_TYPENAME; 383169689Skan break; 384169689Skan } 385169689Skan } 386169689Skan else if (c_dialect_objc ()) 387169689Skan { 388169689Skan tree objc_interface_decl = objc_is_class_name (token->value); 389169689Skan /* Objective-C class names are in the same namespace as 390169689Skan variables and typedefs, and hence are shadowed by local 391169689Skan declarations. */ 392169689Skan if (objc_interface_decl 393169689Skan && (global_bindings_p () 394169689Skan || (!objc_force_identifier && !decl))) 395169689Skan { 396169689Skan token->value = objc_interface_decl; 397169689Skan token->id_kind = C_ID_CLASSNAME; 398169689Skan break; 399169689Skan } 400169689Skan } 401169689Skan token->id_kind = C_ID_ID; 402169689Skan } 403169689Skan break; 404169689Skan case CPP_AT_NAME: 405169689Skan /* This only happens in Objective-C; it must be a keyword. */ 406169689Skan token->type = CPP_KEYWORD; 407169689Skan token->keyword = C_RID_CODE (token->value); 408169689Skan break; 409169689Skan case CPP_COLON: 410169689Skan case CPP_COMMA: 411169689Skan case CPP_CLOSE_PAREN: 412169689Skan case CPP_SEMICOLON: 413169689Skan /* These tokens may affect the interpretation of any identifiers 414169689Skan following, if doing Objective-C. */ 415169689Skan OBJC_NEED_RAW_IDENTIFIER (0); 416169689Skan break; 417169689Skan case CPP_PRAGMA: 418169689Skan /* We smuggled the cpp_token->u.pragma value in an INTEGER_CST. */ 419169689Skan token->pragma_kind = TREE_INT_CST_LOW (token->value); 420169689Skan token->value = NULL; 421169689Skan break; 422169689Skan default: 423169689Skan break; 424169689Skan } 425169689Skan timevar_pop (TV_LEX); 426169689Skan} 427169689Skan 428169689Skan/* Return a pointer to the next token from PARSER, reading it in if 429169689Skan necessary. */ 430169689Skan 431169689Skanstatic inline c_token * 432169689Skanc_parser_peek_token (c_parser *parser) 433169689Skan{ 434169689Skan if (parser->tokens_avail == 0) 435169689Skan { 436169689Skan c_lex_one_token (&parser->tokens[0]); 437169689Skan parser->tokens_avail = 1; 438169689Skan } 439169689Skan return &parser->tokens[0]; 440169689Skan} 441169689Skan 442169689Skan/* Return true if the next token from PARSER has the indicated 443169689Skan TYPE. */ 444169689Skan 445169689Skanstatic inline bool 446169689Skanc_parser_next_token_is (c_parser *parser, enum cpp_ttype type) 447169689Skan{ 448169689Skan return c_parser_peek_token (parser)->type == type; 449169689Skan} 450169689Skan 451169689Skan/* Return true if the next token from PARSER does not have the 452169689Skan indicated TYPE. */ 453169689Skan 454169689Skanstatic inline bool 455169689Skanc_parser_next_token_is_not (c_parser *parser, enum cpp_ttype type) 456169689Skan{ 457169689Skan return !c_parser_next_token_is (parser, type); 458169689Skan} 459169689Skan 460169689Skan/* Return true if the next token from PARSER is the indicated 461169689Skan KEYWORD. */ 462169689Skan 463169689Skanstatic inline bool 464169689Skanc_parser_next_token_is_keyword (c_parser *parser, enum rid keyword) 465169689Skan{ 466169689Skan c_token *token; 467169689Skan 468169689Skan /* Peek at the next token. */ 469169689Skan token = c_parser_peek_token (parser); 470169689Skan /* Check to see if it is the indicated keyword. */ 471169689Skan return token->keyword == keyword; 472169689Skan} 473169689Skan 474169689Skan/* Return true if TOKEN can start a type name, 475169689Skan false otherwise. */ 476169689Skanstatic bool 477169689Skanc_token_starts_typename (c_token *token) 478169689Skan{ 479169689Skan switch (token->type) 480169689Skan { 481169689Skan case CPP_NAME: 482169689Skan switch (token->id_kind) 483169689Skan { 484169689Skan case C_ID_ID: 485169689Skan return false; 486169689Skan case C_ID_TYPENAME: 487169689Skan return true; 488169689Skan case C_ID_CLASSNAME: 489169689Skan gcc_assert (c_dialect_objc ()); 490169689Skan return true; 491169689Skan default: 492169689Skan gcc_unreachable (); 493169689Skan } 494169689Skan case CPP_KEYWORD: 495169689Skan switch (token->keyword) 496169689Skan { 497169689Skan case RID_UNSIGNED: 498169689Skan case RID_LONG: 499169689Skan case RID_SHORT: 500169689Skan case RID_SIGNED: 501169689Skan case RID_COMPLEX: 502169689Skan case RID_INT: 503169689Skan case RID_CHAR: 504169689Skan case RID_FLOAT: 505169689Skan case RID_DOUBLE: 506169689Skan case RID_VOID: 507169689Skan case RID_DFLOAT32: 508169689Skan case RID_DFLOAT64: 509169689Skan case RID_DFLOAT128: 510169689Skan case RID_BOOL: 511169689Skan case RID_ENUM: 512169689Skan case RID_STRUCT: 513169689Skan case RID_UNION: 514169689Skan case RID_TYPEOF: 515169689Skan case RID_CONST: 516169689Skan case RID_VOLATILE: 517169689Skan case RID_RESTRICT: 518169689Skan case RID_ATTRIBUTE: 519169689Skan return true; 520169689Skan default: 521169689Skan return false; 522169689Skan } 523169689Skan case CPP_LESS: 524169689Skan if (c_dialect_objc ()) 525169689Skan return true; 526169689Skan return false; 527169689Skan default: 528169689Skan return false; 529169689Skan } 530169689Skan} 531169689Skan 532169689Skan/* Return true if the next token from PARSER can start a type name, 533169689Skan false otherwise. */ 534169689Skanstatic inline bool 535169689Skanc_parser_next_token_starts_typename (c_parser *parser) 536169689Skan{ 537169689Skan c_token *token = c_parser_peek_token (parser); 538169689Skan return c_token_starts_typename (token); 539169689Skan} 540169689Skan 541169689Skan/* Return true if TOKEN can start declaration specifiers, false 542169689Skan otherwise. */ 543169689Skanstatic bool 544169689Skanc_token_starts_declspecs (c_token *token) 545169689Skan{ 546169689Skan switch (token->type) 547169689Skan { 548169689Skan case CPP_NAME: 549169689Skan switch (token->id_kind) 550169689Skan { 551169689Skan case C_ID_ID: 552169689Skan return false; 553169689Skan case C_ID_TYPENAME: 554169689Skan return true; 555169689Skan case C_ID_CLASSNAME: 556169689Skan gcc_assert (c_dialect_objc ()); 557169689Skan return true; 558169689Skan default: 559169689Skan gcc_unreachable (); 560169689Skan } 561169689Skan case CPP_KEYWORD: 562169689Skan switch (token->keyword) 563169689Skan { 564169689Skan case RID_STATIC: 565169689Skan case RID_EXTERN: 566169689Skan case RID_REGISTER: 567169689Skan case RID_TYPEDEF: 568169689Skan case RID_INLINE: 569169689Skan case RID_AUTO: 570169689Skan case RID_THREAD: 571169689Skan case RID_UNSIGNED: 572169689Skan case RID_LONG: 573169689Skan case RID_SHORT: 574169689Skan case RID_SIGNED: 575169689Skan case RID_COMPLEX: 576169689Skan case RID_INT: 577169689Skan case RID_CHAR: 578169689Skan case RID_FLOAT: 579169689Skan case RID_DOUBLE: 580169689Skan case RID_VOID: 581169689Skan case RID_DFLOAT32: 582169689Skan case RID_DFLOAT64: 583169689Skan case RID_DFLOAT128: 584169689Skan case RID_BOOL: 585169689Skan case RID_ENUM: 586169689Skan case RID_STRUCT: 587169689Skan case RID_UNION: 588169689Skan case RID_TYPEOF: 589169689Skan case RID_CONST: 590169689Skan case RID_VOLATILE: 591169689Skan case RID_RESTRICT: 592169689Skan case RID_ATTRIBUTE: 593169689Skan return true; 594169689Skan default: 595169689Skan return false; 596169689Skan } 597169689Skan case CPP_LESS: 598169689Skan if (c_dialect_objc ()) 599169689Skan return true; 600169689Skan return false; 601169689Skan default: 602169689Skan return false; 603169689Skan } 604169689Skan} 605169689Skan 606169689Skan/* Return true if the next token from PARSER can start declaration 607169689Skan specifiers, false otherwise. */ 608169689Skanstatic inline bool 609169689Skanc_parser_next_token_starts_declspecs (c_parser *parser) 610169689Skan{ 611169689Skan c_token *token = c_parser_peek_token (parser); 612169689Skan return c_token_starts_declspecs (token); 613169689Skan} 614169689Skan 615169689Skan/* Return a pointer to the next-but-one token from PARSER, reading it 616169689Skan in if necessary. The next token is already read in. */ 617169689Skan 618169689Skanstatic c_token * 619169689Skanc_parser_peek_2nd_token (c_parser *parser) 620169689Skan{ 621169689Skan if (parser->tokens_avail >= 2) 622169689Skan return &parser->tokens[1]; 623169689Skan gcc_assert (parser->tokens_avail == 1); 624169689Skan gcc_assert (parser->tokens[0].type != CPP_EOF); 625169689Skan gcc_assert (parser->tokens[0].type != CPP_PRAGMA_EOL); 626169689Skan c_lex_one_token (&parser->tokens[1]); 627169689Skan parser->tokens_avail = 2; 628169689Skan return &parser->tokens[1]; 629169689Skan} 630169689Skan 631169689Skan/* Consume the next token from PARSER. */ 632169689Skan 633169689Skanstatic void 634169689Skanc_parser_consume_token (c_parser *parser) 635169689Skan{ 636169689Skan gcc_assert (parser->tokens_avail >= 1); 637169689Skan gcc_assert (parser->tokens[0].type != CPP_EOF); 638169689Skan gcc_assert (!parser->in_pragma || parser->tokens[0].type != CPP_PRAGMA_EOL); 639169689Skan gcc_assert (parser->error || parser->tokens[0].type != CPP_PRAGMA); 640169689Skan if (parser->tokens_avail == 2) 641169689Skan parser->tokens[0] = parser->tokens[1]; 642169689Skan parser->tokens_avail--; 643169689Skan} 644169689Skan 645169689Skan/* Expect the current token to be a #pragma. Consume it and remember 646169689Skan that we've begun parsing a pragma. */ 647169689Skan 648169689Skanstatic void 649169689Skanc_parser_consume_pragma (c_parser *parser) 650169689Skan{ 651169689Skan gcc_assert (!parser->in_pragma); 652169689Skan gcc_assert (parser->tokens_avail >= 1); 653169689Skan gcc_assert (parser->tokens[0].type == CPP_PRAGMA); 654169689Skan if (parser->tokens_avail == 2) 655169689Skan parser->tokens[0] = parser->tokens[1]; 656169689Skan parser->tokens_avail--; 657169689Skan parser->in_pragma = true; 658169689Skan} 659169689Skan 660169689Skan/* Update the globals input_location and in_system_header from 661169689Skan TOKEN. */ 662169689Skanstatic inline void 663169689Skanc_parser_set_source_position_from_token (c_token *token) 664169689Skan{ 665169689Skan if (token->type != CPP_EOF) 666169689Skan { 667169689Skan input_location = token->location; 668169689Skan in_system_header = token->in_system_header; 669169689Skan } 670169689Skan} 671169689Skan 672169689Skan/* Issue a diagnostic of the form 673169689Skan FILE:LINE: MESSAGE before TOKEN 674169689Skan where TOKEN is the next token in the input stream of PARSER. 675169689Skan MESSAGE (specified by the caller) is usually of the form "expected 676169689Skan OTHER-TOKEN". 677169689Skan 678169689Skan Do not issue a diagnostic if still recovering from an error. 679169689Skan 680169689Skan ??? This is taken from the C++ parser, but building up messages in 681169689Skan this way is not i18n-friendly and some other approach should be 682169689Skan used. */ 683169689Skan 684169689Skanstatic void 685169689Skanc_parser_error (c_parser *parser, const char *gmsgid) 686169689Skan{ 687169689Skan c_token *token = c_parser_peek_token (parser); 688169689Skan if (parser->error) 689169689Skan return; 690169689Skan parser->error = true; 691169689Skan if (!gmsgid) 692169689Skan return; 693169689Skan /* This diagnostic makes more sense if it is tagged to the line of 694169689Skan the token we just peeked at. */ 695169689Skan c_parser_set_source_position_from_token (token); 696169689Skan c_parse_error (gmsgid, 697169689Skan /* Because c_parse_error does not understand 698169689Skan CPP_KEYWORD, keywords are treated like 699169689Skan identifiers. */ 700169689Skan (token->type == CPP_KEYWORD ? CPP_NAME : token->type), 701169689Skan token->value); 702169689Skan} 703169689Skan 704169689Skan/* If the next token is of the indicated TYPE, consume it. Otherwise, 705169689Skan issue the error MSGID. If MSGID is NULL then a message has already 706169689Skan been produced and no message will be produced this time. Returns 707169689Skan true if found, false otherwise. */ 708169689Skan 709169689Skanstatic bool 710169689Skanc_parser_require (c_parser *parser, 711169689Skan enum cpp_ttype type, 712169689Skan const char *msgid) 713169689Skan{ 714169689Skan if (c_parser_next_token_is (parser, type)) 715169689Skan { 716169689Skan c_parser_consume_token (parser); 717169689Skan return true; 718169689Skan } 719169689Skan else 720169689Skan { 721169689Skan c_parser_error (parser, msgid); 722169689Skan return false; 723169689Skan } 724169689Skan} 725169689Skan 726169689Skan/* If the next token is the indicated keyword, consume it. Otherwise, 727169689Skan issue the error MSGID. Returns true if found, false otherwise. */ 728169689Skan 729169689Skanstatic bool 730169689Skanc_parser_require_keyword (c_parser *parser, 731169689Skan enum rid keyword, 732169689Skan const char *msgid) 733169689Skan{ 734169689Skan if (c_parser_next_token_is_keyword (parser, keyword)) 735169689Skan { 736169689Skan c_parser_consume_token (parser); 737169689Skan return true; 738169689Skan } 739169689Skan else 740169689Skan { 741169689Skan c_parser_error (parser, msgid); 742169689Skan return false; 743169689Skan } 744169689Skan} 745169689Skan 746169689Skan/* Like c_parser_require, except that tokens will be skipped until the 747169689Skan desired token is found. An error message is still produced if the 748169689Skan next token is not as expected. If MSGID is NULL then a message has 749169689Skan already been produced and no message will be produced this 750169689Skan time. */ 751169689Skan 752169689Skanstatic void 753169689Skanc_parser_skip_until_found (c_parser *parser, 754169689Skan enum cpp_ttype type, 755169689Skan const char *msgid) 756169689Skan{ 757169689Skan unsigned nesting_depth = 0; 758169689Skan 759169689Skan if (c_parser_require (parser, type, msgid)) 760169689Skan return; 761169689Skan 762169689Skan /* Skip tokens until the desired token is found. */ 763169689Skan while (true) 764169689Skan { 765169689Skan /* Peek at the next token. */ 766169689Skan c_token *token = c_parser_peek_token (parser); 767169689Skan /* If we've reached the token we want, consume it and stop. */ 768169689Skan if (token->type == type && !nesting_depth) 769169689Skan { 770169689Skan c_parser_consume_token (parser); 771169689Skan break; 772169689Skan } 773169689Skan 774169689Skan /* If we've run out of tokens, stop. */ 775169689Skan if (token->type == CPP_EOF) 776169689Skan return; 777169689Skan if (token->type == CPP_PRAGMA_EOL && parser->in_pragma) 778169689Skan return; 779169689Skan if (token->type == CPP_OPEN_BRACE 780169689Skan || token->type == CPP_OPEN_PAREN 781169689Skan || token->type == CPP_OPEN_SQUARE) 782169689Skan ++nesting_depth; 783169689Skan else if (token->type == CPP_CLOSE_BRACE 784169689Skan || token->type == CPP_CLOSE_PAREN 785169689Skan || token->type == CPP_CLOSE_SQUARE) 786169689Skan { 787169689Skan if (nesting_depth-- == 0) 788169689Skan break; 789169689Skan } 790169689Skan /* Consume this token. */ 791169689Skan c_parser_consume_token (parser); 792169689Skan } 793169689Skan parser->error = false; 794169689Skan} 795169689Skan 796169689Skan/* Skip tokens until the end of a parameter is found, but do not 797169689Skan consume the comma, semicolon or closing delimiter. */ 798169689Skan 799169689Skanstatic void 800169689Skanc_parser_skip_to_end_of_parameter (c_parser *parser) 801169689Skan{ 802169689Skan unsigned nesting_depth = 0; 803169689Skan 804169689Skan while (true) 805169689Skan { 806169689Skan c_token *token = c_parser_peek_token (parser); 807169689Skan if ((token->type == CPP_COMMA || token->type == CPP_SEMICOLON) 808169689Skan && !nesting_depth) 809169689Skan break; 810169689Skan /* If we've run out of tokens, stop. */ 811169689Skan if (token->type == CPP_EOF) 812169689Skan return; 813169689Skan if (token->type == CPP_PRAGMA_EOL && parser->in_pragma) 814169689Skan return; 815169689Skan if (token->type == CPP_OPEN_BRACE 816169689Skan || token->type == CPP_OPEN_PAREN 817169689Skan || token->type == CPP_OPEN_SQUARE) 818169689Skan ++nesting_depth; 819169689Skan else if (token->type == CPP_CLOSE_BRACE 820169689Skan || token->type == CPP_CLOSE_PAREN 821169689Skan || token->type == CPP_CLOSE_SQUARE) 822169689Skan { 823169689Skan if (nesting_depth-- == 0) 824169689Skan break; 825169689Skan } 826169689Skan /* Consume this token. */ 827169689Skan c_parser_consume_token (parser); 828169689Skan } 829169689Skan parser->error = false; 830169689Skan} 831169689Skan 832169689Skan/* Expect to be at the end of the pragma directive and consume an 833169689Skan end of line marker. */ 834169689Skan 835169689Skanstatic void 836169689Skanc_parser_skip_to_pragma_eol (c_parser *parser) 837169689Skan{ 838169689Skan gcc_assert (parser->in_pragma); 839169689Skan parser->in_pragma = false; 840169689Skan 841169689Skan if (!c_parser_require (parser, CPP_PRAGMA_EOL, "expected end of line")) 842169689Skan while (true) 843169689Skan { 844169689Skan c_token *token = c_parser_peek_token (parser); 845169689Skan if (token->type == CPP_EOF) 846169689Skan break; 847169689Skan if (token->type == CPP_PRAGMA_EOL) 848169689Skan { 849169689Skan c_parser_consume_token (parser); 850169689Skan break; 851169689Skan } 852169689Skan c_parser_consume_token (parser); 853169689Skan } 854169689Skan 855169689Skan parser->error = false; 856169689Skan} 857169689Skan 858169689Skan/* Skip tokens until we have consumed an entire block, or until we 859169689Skan have consumed a non-nested ';'. */ 860169689Skan 861169689Skanstatic void 862169689Skanc_parser_skip_to_end_of_block_or_statement (c_parser *parser) 863169689Skan{ 864169689Skan unsigned nesting_depth = 0; 865169689Skan bool save_error = parser->error; 866169689Skan 867169689Skan while (true) 868169689Skan { 869169689Skan c_token *token; 870169689Skan 871169689Skan /* Peek at the next token. */ 872169689Skan token = c_parser_peek_token (parser); 873169689Skan 874169689Skan switch (token->type) 875169689Skan { 876169689Skan case CPP_EOF: 877169689Skan return; 878169689Skan 879169689Skan case CPP_PRAGMA_EOL: 880169689Skan if (parser->in_pragma) 881169689Skan return; 882169689Skan break; 883169689Skan 884169689Skan case CPP_SEMICOLON: 885169689Skan /* If the next token is a ';', we have reached the 886169689Skan end of the statement. */ 887169689Skan if (!nesting_depth) 888169689Skan { 889169689Skan /* Consume the ';'. */ 890169689Skan c_parser_consume_token (parser); 891169689Skan goto finished; 892169689Skan } 893169689Skan break; 894169689Skan 895169689Skan case CPP_CLOSE_BRACE: 896169689Skan /* If the next token is a non-nested '}', then we have 897169689Skan reached the end of the current block. */ 898169689Skan if (nesting_depth == 0 || --nesting_depth == 0) 899169689Skan { 900169689Skan c_parser_consume_token (parser); 901169689Skan goto finished; 902169689Skan } 903169689Skan break; 904169689Skan 905169689Skan case CPP_OPEN_BRACE: 906169689Skan /* If it the next token is a '{', then we are entering a new 907169689Skan block. Consume the entire block. */ 908169689Skan ++nesting_depth; 909169689Skan break; 910169689Skan 911169689Skan case CPP_PRAGMA: 912169689Skan /* If we see a pragma, consume the whole thing at once. We 913169689Skan have some safeguards against consuming pragmas willy-nilly. 914169689Skan Normally, we'd expect to be here with parser->error set, 915169689Skan which disables these safeguards. But it's possible to get 916169689Skan here for secondary error recovery, after parser->error has 917169689Skan been cleared. */ 918169689Skan c_parser_consume_pragma (parser); 919169689Skan c_parser_skip_to_pragma_eol (parser); 920169689Skan parser->error = save_error; 921169689Skan continue; 922169689Skan 923169689Skan default: 924169689Skan break; 925169689Skan } 926169689Skan 927169689Skan c_parser_consume_token (parser); 928169689Skan } 929169689Skan 930169689Skan finished: 931169689Skan parser->error = false; 932169689Skan} 933169689Skan 934169689Skan/* Save the warning flags which are controlled by __extension__. */ 935169689Skan 936169689Skanstatic inline int 937169689Skandisable_extension_diagnostics (void) 938169689Skan{ 939169689Skan int ret = (pedantic 940169689Skan | (warn_pointer_arith << 1) 941169689Skan | (warn_traditional << 2) 942169689Skan | (flag_iso << 3)); 943169689Skan pedantic = 0; 944169689Skan warn_pointer_arith = 0; 945169689Skan warn_traditional = 0; 946169689Skan flag_iso = 0; 947169689Skan return ret; 948169689Skan} 949169689Skan 950169689Skan/* Restore the warning flags which are controlled by __extension__. 951169689Skan FLAGS is the return value from disable_extension_diagnostics. */ 952169689Skan 953169689Skanstatic inline void 954169689Skanrestore_extension_diagnostics (int flags) 955169689Skan{ 956169689Skan pedantic = flags & 1; 957169689Skan warn_pointer_arith = (flags >> 1) & 1; 958169689Skan warn_traditional = (flags >> 2) & 1; 959169689Skan flag_iso = (flags >> 3) & 1; 960169689Skan} 961169689Skan 962169689Skan/* Possibly kinds of declarator to parse. */ 963169689Skantypedef enum c_dtr_syn { 964169689Skan /* A normal declarator with an identifier. */ 965169689Skan C_DTR_NORMAL, 966169689Skan /* An abstract declarator (maybe empty). */ 967169689Skan C_DTR_ABSTRACT, 968169689Skan /* A parameter declarator: may be either, but after a type name does 969169689Skan not redeclare a typedef name as an identifier if it can 970169689Skan alternatively be interpreted as a typedef name; see DR#009, 971169689Skan applied in C90 TC1, omitted from C99 and reapplied in C99 TC2 972169689Skan following DR#249. For example, given a typedef T, "int T" and 973169689Skan "int *T" are valid parameter declarations redeclaring T, while 974169689Skan "int (T)" and "int * (T)" and "int (T[])" and "int (T (int))" are 975169689Skan abstract declarators rather than involving redundant parentheses; 976169689Skan the same applies with attributes inside the parentheses before 977169689Skan "T". */ 978169689Skan C_DTR_PARM 979169689Skan} c_dtr_syn; 980169689Skan 981169689Skanstatic void c_parser_external_declaration (c_parser *); 982169689Skanstatic void c_parser_asm_definition (c_parser *); 983169689Skanstatic void c_parser_declaration_or_fndef (c_parser *, bool, bool, bool, bool); 984169689Skanstatic void c_parser_declspecs (c_parser *, struct c_declspecs *, bool, bool, 985169689Skan bool); 986169689Skanstatic struct c_typespec c_parser_enum_specifier (c_parser *); 987169689Skanstatic struct c_typespec c_parser_struct_or_union_specifier (c_parser *); 988169689Skanstatic tree c_parser_struct_declaration (c_parser *); 989169689Skanstatic struct c_typespec c_parser_typeof_specifier (c_parser *); 990169689Skanstatic struct c_declarator *c_parser_declarator (c_parser *, bool, c_dtr_syn, 991169689Skan bool *); 992169689Skanstatic struct c_declarator *c_parser_direct_declarator (c_parser *, bool, 993169689Skan c_dtr_syn, bool *); 994169689Skanstatic struct c_declarator *c_parser_direct_declarator_inner (c_parser *, 995169689Skan bool, 996169689Skan struct c_declarator *); 997169689Skanstatic struct c_arg_info *c_parser_parms_declarator (c_parser *, bool, tree); 998169689Skanstatic struct c_arg_info *c_parser_parms_list_declarator (c_parser *, tree); 999169689Skanstatic struct c_parm *c_parser_parameter_declaration (c_parser *, tree); 1000169689Skanstatic tree c_parser_simple_asm_expr (c_parser *); 1001169689Skanstatic tree c_parser_attributes (c_parser *); 1002169689Skanstatic struct c_type_name *c_parser_type_name (c_parser *); 1003169689Skanstatic struct c_expr c_parser_initializer (c_parser *); 1004169689Skanstatic struct c_expr c_parser_braced_init (c_parser *, tree, bool); 1005169689Skanstatic void c_parser_initelt (c_parser *); 1006169689Skanstatic void c_parser_initval (c_parser *, struct c_expr *); 1007169689Skanstatic tree c_parser_compound_statement (c_parser *); 1008169689Skanstatic void c_parser_compound_statement_nostart (c_parser *); 1009169689Skanstatic void c_parser_label (c_parser *); 1010169689Skanstatic void c_parser_statement (c_parser *); 1011169689Skanstatic void c_parser_statement_after_labels (c_parser *); 1012169689Skanstatic void c_parser_if_statement (c_parser *); 1013169689Skanstatic void c_parser_switch_statement (c_parser *); 1014169689Skanstatic void c_parser_while_statement (c_parser *); 1015169689Skanstatic void c_parser_do_statement (c_parser *); 1016169689Skanstatic void c_parser_for_statement (c_parser *); 1017169689Skanstatic tree c_parser_asm_statement (c_parser *); 1018169689Skanstatic tree c_parser_asm_operands (c_parser *, bool); 1019169689Skanstatic tree c_parser_asm_clobbers (c_parser *); 1020169689Skanstatic struct c_expr c_parser_expr_no_commas (c_parser *, struct c_expr *); 1021169689Skanstatic struct c_expr c_parser_conditional_expression (c_parser *, 1022169689Skan struct c_expr *); 1023169689Skanstatic struct c_expr c_parser_binary_expression (c_parser *, struct c_expr *); 1024169689Skanstatic struct c_expr c_parser_cast_expression (c_parser *, struct c_expr *); 1025169689Skanstatic struct c_expr c_parser_unary_expression (c_parser *); 1026169689Skanstatic struct c_expr c_parser_sizeof_expression (c_parser *); 1027169689Skanstatic struct c_expr c_parser_alignof_expression (c_parser *); 1028169689Skanstatic struct c_expr c_parser_postfix_expression (c_parser *); 1029169689Skanstatic struct c_expr c_parser_postfix_expression_after_paren_type (c_parser *, 1030169689Skan struct c_type_name *); 1031169689Skanstatic struct c_expr c_parser_postfix_expression_after_primary (c_parser *, 1032169689Skan struct c_expr); 1033169689Skanstatic struct c_expr c_parser_expression (c_parser *); 1034169689Skanstatic struct c_expr c_parser_expression_conv (c_parser *); 1035169689Skanstatic tree c_parser_expr_list (c_parser *, bool); 1036169689Skanstatic void c_parser_omp_construct (c_parser *); 1037169689Skanstatic void c_parser_omp_threadprivate (c_parser *); 1038169689Skanstatic void c_parser_omp_barrier (c_parser *); 1039169689Skanstatic void c_parser_omp_flush (c_parser *); 1040169689Skan 1041169689Skanenum pragma_context { pragma_external, pragma_stmt, pragma_compound }; 1042169689Skanstatic bool c_parser_pragma (c_parser *, enum pragma_context); 1043169689Skan 1044169689Skan/* These Objective-C parser functions are only ever called when 1045169689Skan compiling Objective-C. */ 1046169689Skanstatic void c_parser_objc_class_definition (c_parser *); 1047169689Skanstatic void c_parser_objc_class_instance_variables (c_parser *); 1048169689Skanstatic void c_parser_objc_class_declaration (c_parser *); 1049169689Skanstatic void c_parser_objc_alias_declaration (c_parser *); 1050169689Skanstatic void c_parser_objc_protocol_definition (c_parser *); 1051169689Skanstatic enum tree_code c_parser_objc_method_type (c_parser *); 1052169689Skanstatic void c_parser_objc_method_definition (c_parser *); 1053169689Skanstatic void c_parser_objc_methodprotolist (c_parser *); 1054169689Skanstatic void c_parser_objc_methodproto (c_parser *); 1055169689Skanstatic tree c_parser_objc_method_decl (c_parser *); 1056169689Skanstatic tree c_parser_objc_type_name (c_parser *); 1057169689Skanstatic tree c_parser_objc_protocol_refs (c_parser *); 1058169689Skanstatic void c_parser_objc_try_catch_statement (c_parser *); 1059169689Skanstatic void c_parser_objc_synchronized_statement (c_parser *); 1060169689Skanstatic tree c_parser_objc_selector (c_parser *); 1061169689Skanstatic tree c_parser_objc_selector_arg (c_parser *); 1062169689Skanstatic tree c_parser_objc_receiver (c_parser *); 1063169689Skanstatic tree c_parser_objc_message_args (c_parser *); 1064169689Skanstatic tree c_parser_objc_keywordexpr (c_parser *); 1065169689Skan 1066169689Skan/* Parse a translation unit (C90 6.7, C99 6.9). 1067169689Skan 1068169689Skan translation-unit: 1069169689Skan external-declarations 1070169689Skan 1071169689Skan external-declarations: 1072169689Skan external-declaration 1073169689Skan external-declarations external-declaration 1074169689Skan 1075169689Skan GNU extensions: 1076169689Skan 1077169689Skan translation-unit: 1078169689Skan empty 1079169689Skan*/ 1080169689Skan 1081169689Skanstatic void 1082169689Skanc_parser_translation_unit (c_parser *parser) 1083169689Skan{ 1084169689Skan if (c_parser_next_token_is (parser, CPP_EOF)) 1085169689Skan { 1086169689Skan if (pedantic) 1087169689Skan pedwarn ("ISO C forbids an empty source file"); 1088169689Skan } 1089169689Skan else 1090169689Skan { 1091169689Skan void *obstack_position = obstack_alloc (&parser_obstack, 0); 1092169689Skan do 1093169689Skan { 1094169689Skan ggc_collect (); 1095169689Skan c_parser_external_declaration (parser); 1096169689Skan obstack_free (&parser_obstack, obstack_position); 1097169689Skan } 1098169689Skan while (c_parser_next_token_is_not (parser, CPP_EOF)); 1099169689Skan } 1100169689Skan} 1101169689Skan 1102169689Skan/* Parse an external declaration (C90 6.7, C99 6.9). 1103169689Skan 1104169689Skan external-declaration: 1105169689Skan function-definition 1106169689Skan declaration 1107169689Skan 1108169689Skan GNU extensions: 1109169689Skan 1110169689Skan external-declaration: 1111169689Skan asm-definition 1112169689Skan ; 1113169689Skan __extension__ external-declaration 1114169689Skan 1115169689Skan Objective-C: 1116169689Skan 1117169689Skan external-declaration: 1118169689Skan objc-class-definition 1119169689Skan objc-class-declaration 1120169689Skan objc-alias-declaration 1121169689Skan objc-protocol-definition 1122169689Skan objc-method-definition 1123169689Skan @end 1124169689Skan*/ 1125169689Skan 1126169689Skanstatic void 1127169689Skanc_parser_external_declaration (c_parser *parser) 1128169689Skan{ 1129169689Skan int ext; 1130169689Skan switch (c_parser_peek_token (parser)->type) 1131169689Skan { 1132169689Skan case CPP_KEYWORD: 1133169689Skan switch (c_parser_peek_token (parser)->keyword) 1134169689Skan { 1135169689Skan case RID_EXTENSION: 1136169689Skan ext = disable_extension_diagnostics (); 1137169689Skan c_parser_consume_token (parser); 1138169689Skan c_parser_external_declaration (parser); 1139169689Skan restore_extension_diagnostics (ext); 1140169689Skan break; 1141169689Skan case RID_ASM: 1142169689Skan c_parser_asm_definition (parser); 1143169689Skan break; 1144169689Skan case RID_AT_INTERFACE: 1145169689Skan case RID_AT_IMPLEMENTATION: 1146169689Skan gcc_assert (c_dialect_objc ()); 1147169689Skan c_parser_objc_class_definition (parser); 1148169689Skan break; 1149169689Skan case RID_AT_CLASS: 1150169689Skan gcc_assert (c_dialect_objc ()); 1151169689Skan c_parser_objc_class_declaration (parser); 1152169689Skan break; 1153169689Skan case RID_AT_ALIAS: 1154169689Skan gcc_assert (c_dialect_objc ()); 1155169689Skan c_parser_objc_alias_declaration (parser); 1156169689Skan break; 1157169689Skan case RID_AT_PROTOCOL: 1158169689Skan gcc_assert (c_dialect_objc ()); 1159169689Skan c_parser_objc_protocol_definition (parser); 1160169689Skan break; 1161169689Skan case RID_AT_END: 1162169689Skan gcc_assert (c_dialect_objc ()); 1163169689Skan c_parser_consume_token (parser); 1164169689Skan objc_finish_implementation (); 1165169689Skan break; 1166169689Skan default: 1167169689Skan goto decl_or_fndef; 1168169689Skan } 1169169689Skan break; 1170169689Skan case CPP_SEMICOLON: 1171169689Skan if (pedantic) 1172169689Skan pedwarn ("ISO C does not allow extra %<;%> outside of a function"); 1173169689Skan c_parser_consume_token (parser); 1174169689Skan break; 1175169689Skan case CPP_PRAGMA: 1176169689Skan c_parser_pragma (parser, pragma_external); 1177169689Skan break; 1178169689Skan case CPP_PLUS: 1179169689Skan case CPP_MINUS: 1180169689Skan if (c_dialect_objc ()) 1181169689Skan { 1182169689Skan c_parser_objc_method_definition (parser); 1183169689Skan break; 1184169689Skan } 1185169689Skan /* Else fall through, and yield a syntax error trying to parse 1186169689Skan as a declaration or function definition. */ 1187169689Skan default: 1188169689Skan decl_or_fndef: 1189169689Skan /* A declaration or a function definition. We can only tell 1190169689Skan which after parsing the declaration specifiers, if any, and 1191169689Skan the first declarator. */ 1192169689Skan c_parser_declaration_or_fndef (parser, true, true, false, true); 1193169689Skan break; 1194169689Skan } 1195169689Skan} 1196169689Skan 1197169689Skan 1198169689Skan/* Parse a declaration or function definition (C90 6.5, 6.7.1, C99 1199169689Skan 6.7, 6.9.1). If FNDEF_OK is true, a function definition is 1200169689Skan accepted; otherwise (old-style parameter declarations) only other 1201169689Skan declarations are accepted. If NESTED is true, we are inside a 1202169689Skan function or parsing old-style parameter declarations; any functions 1203169689Skan encountered are nested functions and declaration specifiers are 1204169689Skan required; otherwise we are at top level and functions are normal 1205169689Skan functions and declaration specifiers may be optional. If EMPTY_OK 1206169689Skan is true, empty declarations are OK (subject to all other 1207169689Skan constraints); otherwise (old-style parameter declarations) they are 1208169689Skan diagnosed. If START_ATTR_OK is true, the declaration specifiers 1209169689Skan may start with attributes; otherwise they may not. 1210169689Skan 1211169689Skan declaration: 1212169689Skan declaration-specifiers init-declarator-list[opt] ; 1213169689Skan 1214169689Skan function-definition: 1215169689Skan declaration-specifiers[opt] declarator declaration-list[opt] 1216169689Skan compound-statement 1217169689Skan 1218169689Skan declaration-list: 1219169689Skan declaration 1220169689Skan declaration-list declaration 1221169689Skan 1222169689Skan init-declarator-list: 1223169689Skan init-declarator 1224169689Skan init-declarator-list , init-declarator 1225169689Skan 1226169689Skan init-declarator: 1227169689Skan declarator simple-asm-expr[opt] attributes[opt] 1228169689Skan declarator simple-asm-expr[opt] attributes[opt] = initializer 1229169689Skan 1230169689Skan GNU extensions: 1231169689Skan 1232169689Skan nested-function-definition: 1233169689Skan declaration-specifiers declarator declaration-list[opt] 1234169689Skan compound-statement 1235169689Skan 1236169689Skan The simple-asm-expr and attributes are GNU extensions. 1237169689Skan 1238169689Skan This function does not handle __extension__; that is handled in its 1239169689Skan callers. ??? Following the old parser, __extension__ may start 1240169689Skan external declarations, declarations in functions and declarations 1241169689Skan at the start of "for" loops, but not old-style parameter 1242169689Skan declarations. 1243169689Skan 1244169689Skan C99 requires declaration specifiers in a function definition; the 1245169689Skan absence is diagnosed through the diagnosis of implicit int. In GNU 1246169689Skan C we also allow but diagnose declarations without declaration 1247169689Skan specifiers, but only at top level (elsewhere they conflict with 1248169689Skan other syntax). 1249169689Skan 1250169689Skan OpenMP: 1251169689Skan 1252169689Skan declaration: 1253169689Skan threadprivate-directive */ 1254169689Skan 1255169689Skanstatic void 1256169689Skanc_parser_declaration_or_fndef (c_parser *parser, bool fndef_ok, bool empty_ok, 1257169689Skan bool nested, bool start_attr_ok) 1258169689Skan{ 1259169689Skan struct c_declspecs *specs; 1260169689Skan tree prefix_attrs; 1261169689Skan tree all_prefix_attrs; 1262169689Skan bool diagnosed_no_specs = false; 1263169689Skan 1264169689Skan specs = build_null_declspecs (); 1265169689Skan c_parser_declspecs (parser, specs, true, true, start_attr_ok); 1266169689Skan if (parser->error) 1267169689Skan { 1268169689Skan c_parser_skip_to_end_of_block_or_statement (parser); 1269169689Skan return; 1270169689Skan } 1271169689Skan if (nested && !specs->declspecs_seen_p) 1272169689Skan { 1273169689Skan c_parser_error (parser, "expected declaration specifiers"); 1274169689Skan c_parser_skip_to_end_of_block_or_statement (parser); 1275169689Skan return; 1276169689Skan } 1277169689Skan finish_declspecs (specs); 1278169689Skan if (c_parser_next_token_is (parser, CPP_SEMICOLON)) 1279169689Skan { 1280169689Skan if (empty_ok) 1281169689Skan shadow_tag (specs); 1282169689Skan else 1283169689Skan { 1284169689Skan shadow_tag_warned (specs, 1); 1285169689Skan pedwarn ("empty declaration"); 1286169689Skan } 1287169689Skan c_parser_consume_token (parser); 1288169689Skan return; 1289169689Skan } 1290169689Skan pending_xref_error (); 1291169689Skan prefix_attrs = specs->attrs; 1292169689Skan all_prefix_attrs = prefix_attrs; 1293169689Skan specs->attrs = NULL_TREE; 1294169689Skan while (true) 1295169689Skan { 1296169689Skan struct c_declarator *declarator; 1297169689Skan bool dummy = false; 1298169689Skan tree fnbody; 1299169689Skan /* Declaring either one or more declarators (in which case we 1300169689Skan should diagnose if there were no declaration specifiers) or a 1301169689Skan function definition (in which case the diagnostic for 1302169689Skan implicit int suffices). */ 1303169689Skan declarator = c_parser_declarator (parser, specs->type_seen_p, 1304169689Skan C_DTR_NORMAL, &dummy); 1305169689Skan if (declarator == NULL) 1306169689Skan { 1307169689Skan c_parser_skip_to_end_of_block_or_statement (parser); 1308169689Skan return; 1309169689Skan } 1310169689Skan if (c_parser_next_token_is (parser, CPP_EQ) 1311169689Skan || c_parser_next_token_is (parser, CPP_COMMA) 1312169689Skan || c_parser_next_token_is (parser, CPP_SEMICOLON) 1313169689Skan || c_parser_next_token_is_keyword (parser, RID_ASM) 1314169689Skan || c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE)) 1315169689Skan { 1316169689Skan tree asm_name = NULL_TREE; 1317169689Skan tree postfix_attrs = NULL_TREE; 1318169689Skan if (!diagnosed_no_specs && !specs->declspecs_seen_p) 1319169689Skan { 1320169689Skan diagnosed_no_specs = true; 1321169689Skan pedwarn ("data definition has no type or storage class"); 1322169689Skan } 1323169689Skan /* Having seen a data definition, there cannot now be a 1324169689Skan function definition. */ 1325169689Skan fndef_ok = false; 1326169689Skan if (c_parser_next_token_is_keyword (parser, RID_ASM)) 1327169689Skan asm_name = c_parser_simple_asm_expr (parser); 1328169689Skan if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE)) 1329169689Skan postfix_attrs = c_parser_attributes (parser); 1330169689Skan if (c_parser_next_token_is (parser, CPP_EQ)) 1331169689Skan { 1332169689Skan tree d; 1333169689Skan struct c_expr init; 1334169689Skan c_parser_consume_token (parser); 1335169689Skan /* The declaration of the variable is in effect while 1336169689Skan its initializer is parsed. */ 1337169689Skan d = start_decl (declarator, specs, true, 1338169689Skan chainon (postfix_attrs, all_prefix_attrs)); 1339169689Skan if (!d) 1340169689Skan d = error_mark_node; 1341169689Skan start_init (d, asm_name, global_bindings_p ()); 1342169689Skan init = c_parser_initializer (parser); 1343169689Skan finish_init (); 1344169689Skan if (d != error_mark_node) 1345169689Skan { 1346169689Skan maybe_warn_string_init (TREE_TYPE (d), init); 1347169689Skan finish_decl (d, init.value, asm_name); 1348169689Skan } 1349169689Skan } 1350169689Skan else 1351169689Skan { 1352169689Skan tree d = start_decl (declarator, specs, false, 1353169689Skan chainon (postfix_attrs, 1354169689Skan all_prefix_attrs)); 1355169689Skan if (d) 1356169689Skan finish_decl (d, NULL_TREE, asm_name); 1357169689Skan } 1358169689Skan if (c_parser_next_token_is (parser, CPP_COMMA)) 1359169689Skan { 1360169689Skan c_parser_consume_token (parser); 1361169689Skan if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE)) 1362169689Skan all_prefix_attrs = chainon (c_parser_attributes (parser), 1363169689Skan prefix_attrs); 1364169689Skan else 1365169689Skan all_prefix_attrs = prefix_attrs; 1366169689Skan continue; 1367169689Skan } 1368169689Skan else if (c_parser_next_token_is (parser, CPP_SEMICOLON)) 1369169689Skan { 1370169689Skan c_parser_consume_token (parser); 1371169689Skan return; 1372169689Skan } 1373169689Skan else 1374169689Skan { 1375169689Skan c_parser_error (parser, "expected %<,%> or %<;%>"); 1376169689Skan c_parser_skip_to_end_of_block_or_statement (parser); 1377169689Skan return; 1378169689Skan } 1379169689Skan } 1380169689Skan else if (!fndef_ok) 1381169689Skan { 1382169689Skan c_parser_error (parser, "expected %<=%>, %<,%>, %<;%>, " 1383169689Skan "%<asm%> or %<__attribute__%>"); 1384169689Skan c_parser_skip_to_end_of_block_or_statement (parser); 1385169689Skan return; 1386169689Skan } 1387169689Skan /* Function definition (nested or otherwise). */ 1388169689Skan if (nested) 1389169689Skan { 1390169689Skan if (pedantic) 1391169689Skan pedwarn ("ISO C forbids nested functions"); 1392169689Skan push_function_context (); 1393169689Skan } 1394169689Skan if (!start_function (specs, declarator, all_prefix_attrs)) 1395169689Skan { 1396169689Skan /* This can appear in many cases looking nothing like a 1397169689Skan function definition, so we don't give a more specific 1398169689Skan error suggesting there was one. */ 1399169689Skan c_parser_error (parser, "expected %<=%>, %<,%>, %<;%>, %<asm%> " 1400169689Skan "or %<__attribute__%>"); 1401169689Skan if (nested) 1402169689Skan pop_function_context (); 1403169689Skan break; 1404169689Skan } 1405169689Skan /* Parse old-style parameter declarations. ??? Attributes are 1406169689Skan not allowed to start declaration specifiers here because of a 1407169689Skan syntax conflict between a function declaration with attribute 1408169689Skan suffix and a function definition with an attribute prefix on 1409169689Skan first old-style parameter declaration. Following the old 1410169689Skan parser, they are not accepted on subsequent old-style 1411169689Skan parameter declarations either. However, there is no 1412169689Skan ambiguity after the first declaration, nor indeed on the 1413169689Skan first as long as we don't allow postfix attributes after a 1414169689Skan declarator with a nonempty identifier list in a definition; 1415169689Skan and postfix attributes have never been accepted here in 1416169689Skan function definitions either. */ 1417169689Skan while (c_parser_next_token_is_not (parser, CPP_EOF) 1418169689Skan && c_parser_next_token_is_not (parser, CPP_OPEN_BRACE)) 1419169689Skan c_parser_declaration_or_fndef (parser, false, false, true, false); 1420169689Skan DECL_SOURCE_LOCATION (current_function_decl) 1421169689Skan = c_parser_peek_token (parser)->location; 1422169689Skan store_parm_decls (); 1423169689Skan fnbody = c_parser_compound_statement (parser); 1424169689Skan if (nested) 1425169689Skan { 1426169689Skan tree decl = current_function_decl; 1427169689Skan add_stmt (fnbody); 1428169689Skan finish_function (); 1429169689Skan pop_function_context (); 1430169689Skan add_stmt (build_stmt (DECL_EXPR, decl)); 1431169689Skan } 1432169689Skan else 1433169689Skan { 1434169689Skan add_stmt (fnbody); 1435169689Skan finish_function (); 1436169689Skan } 1437169689Skan break; 1438169689Skan } 1439169689Skan} 1440169689Skan 1441169689Skan/* Parse an asm-definition (asm() outside a function body). This is a 1442169689Skan GNU extension. 1443169689Skan 1444169689Skan asm-definition: 1445169689Skan simple-asm-expr ; 1446169689Skan*/ 1447169689Skan 1448169689Skanstatic void 1449169689Skanc_parser_asm_definition (c_parser *parser) 1450169689Skan{ 1451169689Skan tree asm_str = c_parser_simple_asm_expr (parser); 1452169689Skan if (asm_str) 1453169689Skan cgraph_add_asm_node (asm_str); 1454169689Skan c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>"); 1455169689Skan} 1456169689Skan 1457169689Skan/* Parse some declaration specifiers (possibly none) (C90 6.5, C99 1458169689Skan 6.7), adding them to SPECS (which may already include some). 1459169689Skan Storage class specifiers are accepted iff SCSPEC_OK; type 1460169689Skan specifiers are accepted iff TYPESPEC_OK; attributes are accepted at 1461169689Skan the start iff START_ATTR_OK. 1462169689Skan 1463169689Skan declaration-specifiers: 1464169689Skan storage-class-specifier declaration-specifiers[opt] 1465169689Skan type-specifier declaration-specifiers[opt] 1466169689Skan type-qualifier declaration-specifiers[opt] 1467169689Skan function-specifier declaration-specifiers[opt] 1468169689Skan 1469169689Skan Function specifiers (inline) are from C99, and are currently 1470169689Skan handled as storage class specifiers, as is __thread. 1471169689Skan 1472169689Skan C90 6.5.1, C99 6.7.1: 1473169689Skan storage-class-specifier: 1474169689Skan typedef 1475169689Skan extern 1476169689Skan static 1477169689Skan auto 1478169689Skan register 1479169689Skan 1480169689Skan C99 6.7.4: 1481169689Skan function-specifier: 1482169689Skan inline 1483169689Skan 1484169689Skan C90 6.5.2, C99 6.7.2: 1485169689Skan type-specifier: 1486169689Skan void 1487169689Skan char 1488169689Skan short 1489169689Skan int 1490169689Skan long 1491169689Skan float 1492169689Skan double 1493169689Skan signed 1494169689Skan unsigned 1495169689Skan _Bool 1496169689Skan _Complex 1497169689Skan [_Imaginary removed in C99 TC2] 1498169689Skan struct-or-union-specifier 1499169689Skan enum-specifier 1500169689Skan typedef-name 1501169689Skan 1502169689Skan (_Bool and _Complex are new in C99.) 1503169689Skan 1504169689Skan C90 6.5.3, C99 6.7.3: 1505169689Skan 1506169689Skan type-qualifier: 1507169689Skan const 1508169689Skan restrict 1509169689Skan volatile 1510169689Skan 1511169689Skan (restrict is new in C99.) 1512169689Skan 1513169689Skan GNU extensions: 1514169689Skan 1515169689Skan declaration-specifiers: 1516169689Skan attributes declaration-specifiers[opt] 1517169689Skan 1518169689Skan storage-class-specifier: 1519169689Skan __thread 1520169689Skan 1521169689Skan type-specifier: 1522169689Skan typeof-specifier 1523169689Skan _Decimal32 1524169689Skan _Decimal64 1525169689Skan _Decimal128 1526169689Skan 1527169689Skan Objective-C: 1528169689Skan 1529169689Skan type-specifier: 1530169689Skan class-name objc-protocol-refs[opt] 1531169689Skan typedef-name objc-protocol-refs 1532169689Skan objc-protocol-refs 1533169689Skan*/ 1534169689Skan 1535169689Skanstatic void 1536169689Skanc_parser_declspecs (c_parser *parser, struct c_declspecs *specs, 1537169689Skan bool scspec_ok, bool typespec_ok, bool start_attr_ok) 1538169689Skan{ 1539169689Skan bool attrs_ok = start_attr_ok; 1540169689Skan bool seen_type = specs->type_seen_p; 1541169689Skan while (c_parser_next_token_is (parser, CPP_NAME) 1542169689Skan || c_parser_next_token_is (parser, CPP_KEYWORD) 1543169689Skan || (c_dialect_objc () && c_parser_next_token_is (parser, CPP_LESS))) 1544169689Skan { 1545169689Skan struct c_typespec t; 1546169689Skan tree attrs; 1547169689Skan if (c_parser_next_token_is (parser, CPP_NAME)) 1548169689Skan { 1549169689Skan tree value = c_parser_peek_token (parser)->value; 1550169689Skan c_id_kind kind = c_parser_peek_token (parser)->id_kind; 1551169689Skan /* This finishes the specifiers unless a type name is OK, it 1552169689Skan is declared as a type name and a type name hasn't yet 1553169689Skan been seen. */ 1554169689Skan if (!typespec_ok || seen_type 1555169689Skan || (kind != C_ID_TYPENAME && kind != C_ID_CLASSNAME)) 1556169689Skan break; 1557169689Skan c_parser_consume_token (parser); 1558169689Skan seen_type = true; 1559169689Skan attrs_ok = true; 1560169689Skan if (kind == C_ID_TYPENAME 1561169689Skan && (!c_dialect_objc () 1562169689Skan || c_parser_next_token_is_not (parser, CPP_LESS))) 1563169689Skan { 1564169689Skan t.kind = ctsk_typedef; 1565169689Skan /* For a typedef name, record the meaning, not the name. 1566169689Skan In case of 'foo foo, bar;'. */ 1567169689Skan t.spec = lookup_name (value); 1568169689Skan } 1569169689Skan else 1570169689Skan { 1571169689Skan tree proto = NULL_TREE; 1572169689Skan gcc_assert (c_dialect_objc ()); 1573169689Skan t.kind = ctsk_objc; 1574169689Skan if (c_parser_next_token_is (parser, CPP_LESS)) 1575169689Skan proto = c_parser_objc_protocol_refs (parser); 1576169689Skan t.spec = objc_get_protocol_qualified_type (value, proto); 1577169689Skan } 1578169689Skan declspecs_add_type (specs, t); 1579169689Skan continue; 1580169689Skan } 1581169689Skan if (c_parser_next_token_is (parser, CPP_LESS)) 1582169689Skan { 1583169689Skan /* Make "<SomeProtocol>" equivalent to "id <SomeProtocol>" - 1584169689Skan nisse@lysator.liu.se. */ 1585169689Skan tree proto; 1586169689Skan gcc_assert (c_dialect_objc ()); 1587169689Skan if (!typespec_ok || seen_type) 1588169689Skan break; 1589169689Skan proto = c_parser_objc_protocol_refs (parser); 1590169689Skan t.kind = ctsk_objc; 1591169689Skan t.spec = objc_get_protocol_qualified_type (NULL_TREE, proto); 1592169689Skan declspecs_add_type (specs, t); 1593169689Skan continue; 1594169689Skan } 1595169689Skan gcc_assert (c_parser_next_token_is (parser, CPP_KEYWORD)); 1596169689Skan switch (c_parser_peek_token (parser)->keyword) 1597169689Skan { 1598169689Skan case RID_STATIC: 1599169689Skan case RID_EXTERN: 1600169689Skan case RID_REGISTER: 1601169689Skan case RID_TYPEDEF: 1602169689Skan case RID_INLINE: 1603169689Skan case RID_AUTO: 1604169689Skan case RID_THREAD: 1605169689Skan if (!scspec_ok) 1606169689Skan goto out; 1607169689Skan attrs_ok = true; 1608169689Skan /* TODO: Distinguish between function specifiers (inline) 1609169689Skan and storage class specifiers, either here or in 1610169689Skan declspecs_add_scspec. */ 1611169689Skan declspecs_add_scspec (specs, c_parser_peek_token (parser)->value); 1612169689Skan c_parser_consume_token (parser); 1613169689Skan break; 1614169689Skan case RID_UNSIGNED: 1615169689Skan case RID_LONG: 1616169689Skan case RID_SHORT: 1617169689Skan case RID_SIGNED: 1618169689Skan case RID_COMPLEX: 1619169689Skan case RID_INT: 1620169689Skan case RID_CHAR: 1621169689Skan case RID_FLOAT: 1622169689Skan case RID_DOUBLE: 1623169689Skan case RID_VOID: 1624169689Skan case RID_DFLOAT32: 1625169689Skan case RID_DFLOAT64: 1626169689Skan case RID_DFLOAT128: 1627169689Skan case RID_BOOL: 1628169689Skan if (!typespec_ok) 1629169689Skan goto out; 1630169689Skan attrs_ok = true; 1631169689Skan seen_type = true; 1632169689Skan OBJC_NEED_RAW_IDENTIFIER (1); 1633169689Skan t.kind = ctsk_resword; 1634169689Skan t.spec = c_parser_peek_token (parser)->value; 1635169689Skan declspecs_add_type (specs, t); 1636169689Skan c_parser_consume_token (parser); 1637169689Skan break; 1638169689Skan case RID_ENUM: 1639169689Skan if (!typespec_ok) 1640169689Skan goto out; 1641169689Skan attrs_ok = true; 1642169689Skan seen_type = true; 1643169689Skan t = c_parser_enum_specifier (parser); 1644169689Skan declspecs_add_type (specs, t); 1645169689Skan break; 1646169689Skan case RID_STRUCT: 1647169689Skan case RID_UNION: 1648169689Skan if (!typespec_ok) 1649169689Skan goto out; 1650169689Skan attrs_ok = true; 1651169689Skan seen_type = true; 1652169689Skan t = c_parser_struct_or_union_specifier (parser); 1653169689Skan declspecs_add_type (specs, t); 1654169689Skan break; 1655169689Skan case RID_TYPEOF: 1656169689Skan /* ??? The old parser rejected typeof after other type 1657169689Skan specifiers, but is a syntax error the best way of 1658169689Skan handling this? */ 1659169689Skan if (!typespec_ok || seen_type) 1660169689Skan goto out; 1661169689Skan attrs_ok = true; 1662169689Skan seen_type = true; 1663169689Skan t = c_parser_typeof_specifier (parser); 1664169689Skan declspecs_add_type (specs, t); 1665169689Skan break; 1666169689Skan case RID_CONST: 1667169689Skan case RID_VOLATILE: 1668169689Skan case RID_RESTRICT: 1669169689Skan attrs_ok = true; 1670169689Skan declspecs_add_qual (specs, c_parser_peek_token (parser)->value); 1671169689Skan c_parser_consume_token (parser); 1672169689Skan break; 1673169689Skan case RID_ATTRIBUTE: 1674169689Skan if (!attrs_ok) 1675169689Skan goto out; 1676169689Skan attrs = c_parser_attributes (parser); 1677169689Skan declspecs_add_attrs (specs, attrs); 1678169689Skan break; 1679169689Skan default: 1680169689Skan goto out; 1681169689Skan } 1682169689Skan } 1683169689Skan out: ; 1684169689Skan} 1685169689Skan 1686169689Skan/* Parse an enum specifier (C90 6.5.2.2, C99 6.7.2.2). 1687169689Skan 1688169689Skan enum-specifier: 1689169689Skan enum attributes[opt] identifier[opt] { enumerator-list } attributes[opt] 1690169689Skan enum attributes[opt] identifier[opt] { enumerator-list , } attributes[opt] 1691169689Skan enum attributes[opt] identifier 1692169689Skan 1693169689Skan The form with trailing comma is new in C99. The forms with 1694169689Skan attributes are GNU extensions. In GNU C, we accept any expression 1695169689Skan without commas in the syntax (assignment expressions, not just 1696169689Skan conditional expressions); assignment expressions will be diagnosed 1697169689Skan as non-constant. 1698169689Skan 1699169689Skan enumerator-list: 1700169689Skan enumerator 1701169689Skan enumerator-list , enumerator 1702169689Skan 1703169689Skan enumerator: 1704169689Skan enumeration-constant 1705169689Skan enumeration-constant = constant-expression 1706169689Skan*/ 1707169689Skan 1708169689Skanstatic struct c_typespec 1709169689Skanc_parser_enum_specifier (c_parser *parser) 1710169689Skan{ 1711169689Skan struct c_typespec ret; 1712169689Skan tree attrs; 1713169689Skan tree ident = NULL_TREE; 1714169689Skan gcc_assert (c_parser_next_token_is_keyword (parser, RID_ENUM)); 1715169689Skan c_parser_consume_token (parser); 1716169689Skan attrs = c_parser_attributes (parser); 1717169689Skan if (c_parser_next_token_is (parser, CPP_NAME)) 1718169689Skan { 1719169689Skan ident = c_parser_peek_token (parser)->value; 1720169689Skan c_parser_consume_token (parser); 1721169689Skan } 1722169689Skan if (c_parser_next_token_is (parser, CPP_OPEN_BRACE)) 1723169689Skan { 1724169689Skan /* Parse an enum definition. */ 1725169689Skan tree type = start_enum (ident); 1726169689Skan tree postfix_attrs; 1727169689Skan /* We chain the enumerators in reverse order, then put them in 1728169689Skan forward order at the end. */ 1729169689Skan tree values = NULL_TREE; 1730169689Skan c_parser_consume_token (parser); 1731169689Skan while (true) 1732169689Skan { 1733169689Skan tree enum_id; 1734169689Skan tree enum_value; 1735169689Skan tree enum_decl; 1736169689Skan bool seen_comma; 1737169689Skan if (c_parser_next_token_is_not (parser, CPP_NAME)) 1738169689Skan { 1739169689Skan c_parser_error (parser, "expected identifier"); 1740169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL); 1741169689Skan values = error_mark_node; 1742169689Skan break; 1743169689Skan } 1744169689Skan enum_id = c_parser_peek_token (parser)->value; 1745169689Skan c_parser_consume_token (parser); 1746169689Skan if (c_parser_next_token_is (parser, CPP_EQ)) 1747169689Skan { 1748169689Skan c_parser_consume_token (parser); 1749169689Skan enum_value = c_parser_expr_no_commas (parser, NULL).value; 1750169689Skan } 1751169689Skan else 1752169689Skan enum_value = NULL_TREE; 1753169689Skan enum_decl = build_enumerator (enum_id, enum_value); 1754169689Skan TREE_CHAIN (enum_decl) = values; 1755169689Skan values = enum_decl; 1756169689Skan seen_comma = false; 1757169689Skan if (c_parser_next_token_is (parser, CPP_COMMA)) 1758169689Skan { 1759169689Skan seen_comma = true; 1760169689Skan c_parser_consume_token (parser); 1761169689Skan } 1762169689Skan if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE)) 1763169689Skan { 1764169689Skan if (seen_comma && pedantic && !flag_isoc99) 1765169689Skan pedwarn ("comma at end of enumerator list"); 1766169689Skan c_parser_consume_token (parser); 1767169689Skan break; 1768169689Skan } 1769169689Skan if (!seen_comma) 1770169689Skan { 1771169689Skan c_parser_error (parser, "expected %<,%> or %<}%>"); 1772169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL); 1773169689Skan values = error_mark_node; 1774169689Skan break; 1775169689Skan } 1776169689Skan } 1777169689Skan postfix_attrs = c_parser_attributes (parser); 1778169689Skan ret.spec = finish_enum (type, nreverse (values), 1779169689Skan chainon (attrs, postfix_attrs)); 1780169689Skan ret.kind = ctsk_tagdef; 1781169689Skan return ret; 1782169689Skan } 1783169689Skan else if (!ident) 1784169689Skan { 1785169689Skan c_parser_error (parser, "expected %<{%>"); 1786169689Skan ret.spec = error_mark_node; 1787169689Skan ret.kind = ctsk_tagref; 1788169689Skan return ret; 1789169689Skan } 1790169689Skan ret = parser_xref_tag (ENUMERAL_TYPE, ident); 1791169689Skan /* In ISO C, enumerated types can be referred to only if already 1792169689Skan defined. */ 1793169689Skan if (pedantic && !COMPLETE_TYPE_P (ret.spec)) 1794169689Skan pedwarn ("ISO C forbids forward references to %<enum%> types"); 1795169689Skan return ret; 1796169689Skan} 1797169689Skan 1798169689Skan/* Parse a struct or union specifier (C90 6.5.2.1, C99 6.7.2.1). 1799169689Skan 1800169689Skan struct-or-union-specifier: 1801169689Skan struct-or-union attributes[opt] identifier[opt] 1802169689Skan { struct-contents } attributes[opt] 1803169689Skan struct-or-union attributes[opt] identifier 1804169689Skan 1805169689Skan struct-contents: 1806169689Skan struct-declaration-list 1807169689Skan 1808169689Skan struct-declaration-list: 1809169689Skan struct-declaration ; 1810169689Skan struct-declaration-list struct-declaration ; 1811169689Skan 1812169689Skan GNU extensions: 1813169689Skan 1814169689Skan struct-contents: 1815169689Skan empty 1816169689Skan struct-declaration 1817169689Skan struct-declaration-list struct-declaration 1818169689Skan 1819169689Skan struct-declaration-list: 1820169689Skan struct-declaration-list ; 1821169689Skan ; 1822169689Skan 1823169689Skan (Note that in the syntax here, unlike that in ISO C, the semicolons 1824169689Skan are included here rather than in struct-declaration, in order to 1825169689Skan describe the syntax with extra semicolons and missing semicolon at 1826169689Skan end.) 1827169689Skan 1828169689Skan Objective-C: 1829169689Skan 1830169689Skan struct-declaration-list: 1831169689Skan @defs ( class-name ) 1832169689Skan 1833169689Skan (Note this does not include a trailing semicolon, but can be 1834169689Skan followed by further declarations, and gets a pedwarn-if-pedantic 1835169689Skan when followed by a semicolon.) */ 1836169689Skan 1837169689Skanstatic struct c_typespec 1838169689Skanc_parser_struct_or_union_specifier (c_parser *parser) 1839169689Skan{ 1840169689Skan struct c_typespec ret; 1841169689Skan tree attrs; 1842169689Skan tree ident = NULL_TREE; 1843169689Skan enum tree_code code; 1844169689Skan switch (c_parser_peek_token (parser)->keyword) 1845169689Skan { 1846169689Skan case RID_STRUCT: 1847169689Skan code = RECORD_TYPE; 1848169689Skan break; 1849169689Skan case RID_UNION: 1850169689Skan code = UNION_TYPE; 1851169689Skan break; 1852169689Skan default: 1853169689Skan gcc_unreachable (); 1854169689Skan } 1855169689Skan c_parser_consume_token (parser); 1856169689Skan attrs = c_parser_attributes (parser); 1857169689Skan if (c_parser_next_token_is (parser, CPP_NAME)) 1858169689Skan { 1859169689Skan ident = c_parser_peek_token (parser)->value; 1860169689Skan c_parser_consume_token (parser); 1861169689Skan } 1862169689Skan if (c_parser_next_token_is (parser, CPP_OPEN_BRACE)) 1863169689Skan { 1864169689Skan /* Parse a struct or union definition. Start the scope of the 1865169689Skan tag before parsing components. */ 1866169689Skan tree type = start_struct (code, ident); 1867169689Skan tree postfix_attrs; 1868169689Skan /* We chain the components in reverse order, then put them in 1869169689Skan forward order at the end. Each struct-declaration may 1870169689Skan declare multiple components (comma-separated), so we must use 1871169689Skan chainon to join them, although when parsing each 1872169689Skan struct-declaration we can use TREE_CHAIN directly. 1873169689Skan 1874169689Skan The theory behind all this is that there will be more 1875169689Skan semicolon separated fields than comma separated fields, and 1876169689Skan so we'll be minimizing the number of node traversals required 1877169689Skan by chainon. */ 1878169689Skan tree contents = NULL_TREE; 1879169689Skan c_parser_consume_token (parser); 1880169689Skan /* Handle the Objective-C @defs construct, 1881169689Skan e.g. foo(sizeof(struct{ @defs(ClassName) }));. */ 1882169689Skan if (c_parser_next_token_is_keyword (parser, RID_AT_DEFS)) 1883169689Skan { 1884169689Skan tree name; 1885169689Skan gcc_assert (c_dialect_objc ()); 1886169689Skan c_parser_consume_token (parser); 1887169689Skan if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 1888169689Skan goto end_at_defs; 1889169689Skan if (c_parser_next_token_is (parser, CPP_NAME) 1890169689Skan && c_parser_peek_token (parser)->id_kind == C_ID_CLASSNAME) 1891169689Skan { 1892169689Skan name = c_parser_peek_token (parser)->value; 1893169689Skan c_parser_consume_token (parser); 1894169689Skan } 1895169689Skan else 1896169689Skan { 1897169689Skan c_parser_error (parser, "expected class name"); 1898169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); 1899169689Skan goto end_at_defs; 1900169689Skan } 1901169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 1902169689Skan "expected %<)%>"); 1903169689Skan contents = nreverse (objc_get_class_ivars (name)); 1904169689Skan } 1905169689Skan end_at_defs: 1906169689Skan /* Parse the struct-declarations and semicolons. Problems with 1907169689Skan semicolons are diagnosed here; empty structures are diagnosed 1908169689Skan elsewhere. */ 1909169689Skan while (true) 1910169689Skan { 1911169689Skan tree decls; 1912169689Skan /* Parse any stray semicolon. */ 1913169689Skan if (c_parser_next_token_is (parser, CPP_SEMICOLON)) 1914169689Skan { 1915169689Skan if (pedantic) 1916169689Skan pedwarn ("extra semicolon in struct or union specified"); 1917169689Skan c_parser_consume_token (parser); 1918169689Skan continue; 1919169689Skan } 1920169689Skan /* Stop if at the end of the struct or union contents. */ 1921169689Skan if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE)) 1922169689Skan { 1923169689Skan c_parser_consume_token (parser); 1924169689Skan break; 1925169689Skan } 1926169689Skan /* Accept #pragmas at struct scope. */ 1927169689Skan if (c_parser_next_token_is (parser, CPP_PRAGMA)) 1928169689Skan { 1929169689Skan c_parser_pragma (parser, pragma_external); 1930169689Skan continue; 1931169689Skan } 1932169689Skan /* Parse some comma-separated declarations, but not the 1933169689Skan trailing semicolon if any. */ 1934169689Skan decls = c_parser_struct_declaration (parser); 1935169689Skan contents = chainon (decls, contents); 1936169689Skan /* If no semicolon follows, either we have a parse error or 1937169689Skan are at the end of the struct or union and should 1938169689Skan pedwarn. */ 1939169689Skan if (c_parser_next_token_is (parser, CPP_SEMICOLON)) 1940169689Skan c_parser_consume_token (parser); 1941169689Skan else 1942169689Skan { 1943169689Skan if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE)) 1944169689Skan pedwarn ("no semicolon at end of struct or union"); 1945169689Skan else 1946169689Skan { 1947169689Skan c_parser_error (parser, "expected %<;%>"); 1948169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL); 1949169689Skan break; 1950169689Skan } 1951169689Skan } 1952169689Skan } 1953169689Skan postfix_attrs = c_parser_attributes (parser); 1954169689Skan ret.spec = finish_struct (type, nreverse (contents), 1955169689Skan chainon (attrs, postfix_attrs)); 1956169689Skan ret.kind = ctsk_tagdef; 1957169689Skan return ret; 1958169689Skan } 1959169689Skan else if (!ident) 1960169689Skan { 1961169689Skan c_parser_error (parser, "expected %<{%>"); 1962169689Skan ret.spec = error_mark_node; 1963169689Skan ret.kind = ctsk_tagref; 1964169689Skan return ret; 1965169689Skan } 1966169689Skan ret = parser_xref_tag (code, ident); 1967169689Skan return ret; 1968169689Skan} 1969169689Skan 1970169689Skan/* Parse a struct-declaration (C90 6.5.2.1, C99 6.7.2.1), *without* 1971169689Skan the trailing semicolon. 1972169689Skan 1973169689Skan struct-declaration: 1974169689Skan specifier-qualifier-list struct-declarator-list 1975169689Skan 1976169689Skan specifier-qualifier-list: 1977169689Skan type-specifier specifier-qualifier-list[opt] 1978169689Skan type-qualifier specifier-qualifier-list[opt] 1979169689Skan attributes specifier-qualifier-list[opt] 1980169689Skan 1981169689Skan struct-declarator-list: 1982169689Skan struct-declarator 1983169689Skan struct-declarator-list , attributes[opt] struct-declarator 1984169689Skan 1985169689Skan struct-declarator: 1986169689Skan declarator attributes[opt] 1987169689Skan declarator[opt] : constant-expression attributes[opt] 1988169689Skan 1989169689Skan GNU extensions: 1990169689Skan 1991169689Skan struct-declaration: 1992169689Skan __extension__ struct-declaration 1993169689Skan specifier-qualifier-list 1994169689Skan 1995169689Skan Unlike the ISO C syntax, semicolons are handled elsewhere. The use 1996169689Skan of attributes where shown is a GNU extension. In GNU C, we accept 1997169689Skan any expression without commas in the syntax (assignment 1998169689Skan expressions, not just conditional expressions); assignment 1999169689Skan expressions will be diagnosed as non-constant. */ 2000169689Skan 2001169689Skanstatic tree 2002169689Skanc_parser_struct_declaration (c_parser *parser) 2003169689Skan{ 2004169689Skan struct c_declspecs *specs; 2005169689Skan tree prefix_attrs; 2006169689Skan tree all_prefix_attrs; 2007169689Skan tree decls; 2008169689Skan if (c_parser_next_token_is_keyword (parser, RID_EXTENSION)) 2009169689Skan { 2010169689Skan int ext; 2011169689Skan tree decl; 2012169689Skan ext = disable_extension_diagnostics (); 2013169689Skan c_parser_consume_token (parser); 2014169689Skan decl = c_parser_struct_declaration (parser); 2015169689Skan restore_extension_diagnostics (ext); 2016169689Skan return decl; 2017169689Skan } 2018169689Skan specs = build_null_declspecs (); 2019169689Skan c_parser_declspecs (parser, specs, false, true, true); 2020169689Skan if (parser->error) 2021169689Skan return NULL_TREE; 2022169689Skan if (!specs->declspecs_seen_p) 2023169689Skan { 2024169689Skan c_parser_error (parser, "expected specifier-qualifier-list"); 2025169689Skan return NULL_TREE; 2026169689Skan } 2027169689Skan finish_declspecs (specs); 2028169689Skan if (c_parser_next_token_is (parser, CPP_SEMICOLON)) 2029169689Skan { 2030169689Skan tree ret; 2031169689Skan if (!specs->type_seen_p) 2032169689Skan { 2033169689Skan if (pedantic) 2034169689Skan pedwarn ("ISO C forbids member declarations with no members"); 2035169689Skan shadow_tag_warned (specs, pedantic); 2036169689Skan ret = NULL_TREE; 2037169689Skan } 2038169689Skan else 2039169689Skan { 2040169689Skan /* Support for unnamed structs or unions as members of 2041169689Skan structs or unions (which is [a] useful and [b] supports 2042169689Skan MS P-SDK). */ 2043169689Skan ret = grokfield (build_id_declarator (NULL_TREE), specs, NULL_TREE); 2044169689Skan } 2045169689Skan return ret; 2046169689Skan } 2047169689Skan pending_xref_error (); 2048169689Skan prefix_attrs = specs->attrs; 2049169689Skan all_prefix_attrs = prefix_attrs; 2050169689Skan specs->attrs = NULL_TREE; 2051169689Skan decls = NULL_TREE; 2052169689Skan while (true) 2053169689Skan { 2054169689Skan /* Declaring one or more declarators or un-named bit-fields. */ 2055169689Skan struct c_declarator *declarator; 2056169689Skan bool dummy = false; 2057169689Skan if (c_parser_next_token_is (parser, CPP_COLON)) 2058169689Skan declarator = build_id_declarator (NULL_TREE); 2059169689Skan else 2060169689Skan declarator = c_parser_declarator (parser, specs->type_seen_p, 2061169689Skan C_DTR_NORMAL, &dummy); 2062169689Skan if (declarator == NULL) 2063169689Skan { 2064169689Skan c_parser_skip_to_end_of_block_or_statement (parser); 2065169689Skan break; 2066169689Skan } 2067169689Skan if (c_parser_next_token_is (parser, CPP_COLON) 2068169689Skan || c_parser_next_token_is (parser, CPP_COMMA) 2069169689Skan || c_parser_next_token_is (parser, CPP_SEMICOLON) 2070169689Skan || c_parser_next_token_is (parser, CPP_CLOSE_BRACE) 2071169689Skan || c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE)) 2072169689Skan { 2073169689Skan tree postfix_attrs = NULL_TREE; 2074169689Skan tree width = NULL_TREE; 2075169689Skan tree d; 2076169689Skan if (c_parser_next_token_is (parser, CPP_COLON)) 2077169689Skan { 2078169689Skan c_parser_consume_token (parser); 2079169689Skan width = c_parser_expr_no_commas (parser, NULL).value; 2080169689Skan } 2081169689Skan if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE)) 2082169689Skan postfix_attrs = c_parser_attributes (parser); 2083169689Skan d = grokfield (declarator, specs, width); 2084169689Skan decl_attributes (&d, chainon (postfix_attrs, 2085169689Skan all_prefix_attrs), 0); 2086169689Skan TREE_CHAIN (d) = decls; 2087169689Skan decls = d; 2088169689Skan if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE)) 2089169689Skan all_prefix_attrs = chainon (c_parser_attributes (parser), 2090169689Skan prefix_attrs); 2091169689Skan else 2092169689Skan all_prefix_attrs = prefix_attrs; 2093169689Skan if (c_parser_next_token_is (parser, CPP_COMMA)) 2094169689Skan c_parser_consume_token (parser); 2095169689Skan else if (c_parser_next_token_is (parser, CPP_SEMICOLON) 2096169689Skan || c_parser_next_token_is (parser, CPP_CLOSE_BRACE)) 2097169689Skan { 2098169689Skan /* Semicolon consumed in caller. */ 2099169689Skan break; 2100169689Skan } 2101169689Skan else 2102169689Skan { 2103169689Skan c_parser_error (parser, "expected %<,%>, %<;%> or %<}%>"); 2104169689Skan break; 2105169689Skan } 2106169689Skan } 2107169689Skan else 2108169689Skan { 2109169689Skan c_parser_error (parser, 2110169689Skan "expected %<:%>, %<,%>, %<;%>, %<}%> or " 2111169689Skan "%<__attribute__%>"); 2112169689Skan break; 2113169689Skan } 2114169689Skan } 2115169689Skan return decls; 2116169689Skan} 2117169689Skan 2118169689Skan/* Parse a typeof specifier (a GNU extension). 2119169689Skan 2120169689Skan typeof-specifier: 2121169689Skan typeof ( expression ) 2122169689Skan typeof ( type-name ) 2123169689Skan*/ 2124169689Skan 2125169689Skanstatic struct c_typespec 2126169689Skanc_parser_typeof_specifier (c_parser *parser) 2127169689Skan{ 2128169689Skan struct c_typespec ret; 2129169689Skan ret.kind = ctsk_typeof; 2130169689Skan ret.spec = error_mark_node; 2131169689Skan gcc_assert (c_parser_next_token_is_keyword (parser, RID_TYPEOF)); 2132169689Skan c_parser_consume_token (parser); 2133169689Skan skip_evaluation++; 2134169689Skan in_typeof++; 2135169689Skan if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 2136169689Skan { 2137169689Skan skip_evaluation--; 2138169689Skan in_typeof--; 2139169689Skan return ret; 2140169689Skan } 2141169689Skan if (c_parser_next_token_starts_typename (parser)) 2142169689Skan { 2143169689Skan struct c_type_name *type = c_parser_type_name (parser); 2144169689Skan skip_evaluation--; 2145169689Skan in_typeof--; 2146169689Skan if (type != NULL) 2147169689Skan { 2148169689Skan ret.spec = groktypename (type); 2149169689Skan pop_maybe_used (variably_modified_type_p (ret.spec, NULL_TREE)); 2150169689Skan } 2151169689Skan } 2152169689Skan else 2153169689Skan { 2154169689Skan bool was_vm; 2155169689Skan struct c_expr expr = c_parser_expression (parser); 2156169689Skan skip_evaluation--; 2157169689Skan in_typeof--; 2158169689Skan if (TREE_CODE (expr.value) == COMPONENT_REF 2159169689Skan && DECL_C_BIT_FIELD (TREE_OPERAND (expr.value, 1))) 2160169689Skan error ("%<typeof%> applied to a bit-field"); 2161169689Skan ret.spec = TREE_TYPE (expr.value); 2162169689Skan was_vm = variably_modified_type_p (ret.spec, NULL_TREE); 2163169689Skan /* This should be returned with the type so that when the type 2164169689Skan is evaluated, this can be evaluated. For now, we avoid 2165169689Skan evaluation when the context might. */ 2166169689Skan if (!skip_evaluation && was_vm) 2167169689Skan { 2168169689Skan tree e = expr.value; 2169169689Skan 2170169689Skan /* If the expression is not of a type to which we cannot assign a line 2171169689Skan number, wrap the thing in a no-op NOP_EXPR. */ 2172169689Skan if (DECL_P (e) || CONSTANT_CLASS_P (e)) 2173169689Skan e = build1 (NOP_EXPR, void_type_node, e); 2174169689Skan 2175169689Skan if (EXPR_P (e)) 2176169689Skan SET_EXPR_LOCATION (e, input_location); 2177169689Skan 2178169689Skan add_stmt (e); 2179169689Skan } 2180169689Skan pop_maybe_used (was_vm); 2181169689Skan } 2182169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>"); 2183169689Skan return ret; 2184169689Skan} 2185169689Skan 2186169689Skan/* Parse a declarator, possibly an abstract declarator (C90 6.5.4, 2187169689Skan 6.5.5, C99 6.7.5, 6.7.6). If TYPE_SEEN_P then a typedef name may 2188169689Skan be redeclared; otherwise it may not. KIND indicates which kind of 2189169689Skan declarator is wanted. Returns a valid declarator except in the 2190169689Skan case of a syntax error in which case NULL is returned. *SEEN_ID is 2191169689Skan set to true if an identifier being declared is seen; this is used 2192169689Skan to diagnose bad forms of abstract array declarators and to 2193169689Skan determine whether an identifier list is syntactically permitted. 2194169689Skan 2195169689Skan declarator: 2196169689Skan pointer[opt] direct-declarator 2197169689Skan 2198169689Skan direct-declarator: 2199169689Skan identifier 2200169689Skan ( attributes[opt] declarator ) 2201169689Skan direct-declarator array-declarator 2202169689Skan direct-declarator ( parameter-type-list ) 2203169689Skan direct-declarator ( identifier-list[opt] ) 2204169689Skan 2205169689Skan pointer: 2206169689Skan * type-qualifier-list[opt] 2207169689Skan * type-qualifier-list[opt] pointer 2208169689Skan 2209169689Skan type-qualifier-list: 2210169689Skan type-qualifier 2211169689Skan attributes 2212169689Skan type-qualifier-list type-qualifier 2213169689Skan type-qualifier-list attributes 2214169689Skan 2215169689Skan parameter-type-list: 2216169689Skan parameter-list 2217169689Skan parameter-list , ... 2218169689Skan 2219169689Skan parameter-list: 2220169689Skan parameter-declaration 2221169689Skan parameter-list , parameter-declaration 2222169689Skan 2223169689Skan parameter-declaration: 2224169689Skan declaration-specifiers declarator attributes[opt] 2225169689Skan declaration-specifiers abstract-declarator[opt] attributes[opt] 2226169689Skan 2227169689Skan identifier-list: 2228169689Skan identifier 2229169689Skan identifier-list , identifier 2230169689Skan 2231169689Skan abstract-declarator: 2232169689Skan pointer 2233169689Skan pointer[opt] direct-abstract-declarator 2234169689Skan 2235169689Skan direct-abstract-declarator: 2236169689Skan ( attributes[opt] abstract-declarator ) 2237169689Skan direct-abstract-declarator[opt] array-declarator 2238169689Skan direct-abstract-declarator[opt] ( parameter-type-list[opt] ) 2239169689Skan 2240169689Skan GNU extensions: 2241169689Skan 2242169689Skan direct-declarator: 2243169689Skan direct-declarator ( parameter-forward-declarations 2244169689Skan parameter-type-list[opt] ) 2245169689Skan 2246169689Skan direct-abstract-declarator: 2247169689Skan direct-abstract-declarator[opt] ( parameter-forward-declarations 2248169689Skan parameter-type-list[opt] ) 2249169689Skan 2250169689Skan parameter-forward-declarations: 2251169689Skan parameter-list ; 2252169689Skan parameter-forward-declarations parameter-list ; 2253169689Skan 2254169689Skan The uses of attributes shown above are GNU extensions. 2255169689Skan 2256169689Skan Some forms of array declarator are not included in C99 in the 2257169689Skan syntax for abstract declarators; these are disallowed elsewhere. 2258169689Skan This may be a defect (DR#289). 2259169689Skan 2260169689Skan This function also accepts an omitted abstract declarator as being 2261169689Skan an abstract declarator, although not part of the formal syntax. */ 2262169689Skan 2263169689Skanstatic struct c_declarator * 2264169689Skanc_parser_declarator (c_parser *parser, bool type_seen_p, c_dtr_syn kind, 2265169689Skan bool *seen_id) 2266169689Skan{ 2267169689Skan /* Parse any initial pointer part. */ 2268169689Skan if (c_parser_next_token_is (parser, CPP_MULT)) 2269169689Skan { 2270169689Skan struct c_declspecs *quals_attrs = build_null_declspecs (); 2271169689Skan struct c_declarator *inner; 2272169689Skan c_parser_consume_token (parser); 2273169689Skan c_parser_declspecs (parser, quals_attrs, false, false, true); 2274169689Skan inner = c_parser_declarator (parser, type_seen_p, kind, seen_id); 2275169689Skan if (inner == NULL) 2276169689Skan return NULL; 2277169689Skan else 2278169689Skan return make_pointer_declarator (quals_attrs, inner); 2279169689Skan } 2280169689Skan /* Now we have a direct declarator, direct abstract declarator or 2281169689Skan nothing (which counts as a direct abstract declarator here). */ 2282169689Skan return c_parser_direct_declarator (parser, type_seen_p, kind, seen_id); 2283169689Skan} 2284169689Skan 2285169689Skan/* Parse a direct declarator or direct abstract declarator; arguments 2286169689Skan as c_parser_declarator. */ 2287169689Skan 2288169689Skanstatic struct c_declarator * 2289169689Skanc_parser_direct_declarator (c_parser *parser, bool type_seen_p, c_dtr_syn kind, 2290169689Skan bool *seen_id) 2291169689Skan{ 2292169689Skan /* The direct declarator must start with an identifier (possibly 2293169689Skan omitted) or a parenthesized declarator (possibly abstract). In 2294169689Skan an ordinary declarator, initial parentheses must start a 2295169689Skan parenthesized declarator. In an abstract declarator or parameter 2296169689Skan declarator, they could start a parenthesized declarator or a 2297169689Skan parameter list. To tell which, the open parenthesis and any 2298169689Skan following attributes must be read. If a declaration specifier 2299169689Skan follows, then it is a parameter list; if the specifier is a 2300169689Skan typedef name, there might be an ambiguity about redeclaring it, 2301169689Skan which is resolved in the direction of treating it as a typedef 2302169689Skan name. If a close parenthesis follows, it is also an empty 2303169689Skan parameter list, as the syntax does not permit empty abstract 2304169689Skan declarators. Otherwise, it is a parenthesized declarator (in 2305169689Skan which case the analysis may be repeated inside it, recursively). 2306169689Skan 2307169689Skan ??? There is an ambiguity in a parameter declaration "int 2308169689Skan (__attribute__((foo)) x)", where x is not a typedef name: it 2309169689Skan could be an abstract declarator for a function, or declare x with 2310169689Skan parentheses. The proper resolution of this ambiguity needs 2311169689Skan documenting. At present we follow an accident of the old 2312169689Skan parser's implementation, whereby the first parameter must have 2313169689Skan some declaration specifiers other than just attributes. Thus as 2314169689Skan a parameter declaration it is treated as a parenthesized 2315169689Skan parameter named x, and as an abstract declarator it is 2316169689Skan rejected. 2317169689Skan 2318169689Skan ??? Also following the old parser, attributes inside an empty 2319169689Skan parameter list are ignored, making it a list not yielding a 2320169689Skan prototype, rather than giving an error or making it have one 2321169689Skan parameter with implicit type int. 2322169689Skan 2323169689Skan ??? Also following the old parser, typedef names may be 2324169689Skan redeclared in declarators, but not Objective-C class names. */ 2325169689Skan 2326169689Skan if (kind != C_DTR_ABSTRACT 2327169689Skan && c_parser_next_token_is (parser, CPP_NAME) 2328169689Skan && ((type_seen_p 2329169689Skan && c_parser_peek_token (parser)->id_kind == C_ID_TYPENAME) 2330169689Skan || c_parser_peek_token (parser)->id_kind == C_ID_ID)) 2331169689Skan { 2332169689Skan struct c_declarator *inner 2333169689Skan = build_id_declarator (c_parser_peek_token (parser)->value); 2334169689Skan *seen_id = true; 2335169689Skan inner->id_loc = c_parser_peek_token (parser)->location; 2336169689Skan c_parser_consume_token (parser); 2337169689Skan return c_parser_direct_declarator_inner (parser, *seen_id, inner); 2338169689Skan } 2339169689Skan 2340169689Skan if (kind != C_DTR_NORMAL 2341169689Skan && c_parser_next_token_is (parser, CPP_OPEN_SQUARE)) 2342169689Skan { 2343169689Skan struct c_declarator *inner = build_id_declarator (NULL_TREE); 2344169689Skan return c_parser_direct_declarator_inner (parser, *seen_id, inner); 2345169689Skan } 2346169689Skan 2347169689Skan /* Either we are at the end of an abstract declarator, or we have 2348169689Skan parentheses. */ 2349169689Skan 2350169689Skan if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)) 2351169689Skan { 2352169689Skan tree attrs; 2353169689Skan struct c_declarator *inner; 2354169689Skan c_parser_consume_token (parser); 2355169689Skan attrs = c_parser_attributes (parser); 2356169689Skan if (kind != C_DTR_NORMAL 2357169689Skan && (c_parser_next_token_starts_declspecs (parser) 2358169689Skan || c_parser_next_token_is (parser, CPP_CLOSE_PAREN))) 2359169689Skan { 2360169689Skan struct c_arg_info *args 2361169689Skan = c_parser_parms_declarator (parser, kind == C_DTR_NORMAL, 2362169689Skan attrs); 2363169689Skan if (args == NULL) 2364169689Skan return NULL; 2365169689Skan else 2366169689Skan { 2367169689Skan inner 2368169689Skan = build_function_declarator (args, 2369169689Skan build_id_declarator (NULL_TREE)); 2370169689Skan return c_parser_direct_declarator_inner (parser, *seen_id, 2371169689Skan inner); 2372169689Skan } 2373169689Skan } 2374169689Skan /* A parenthesized declarator. */ 2375169689Skan inner = c_parser_declarator (parser, type_seen_p, kind, seen_id); 2376169689Skan if (inner != NULL && attrs != NULL) 2377169689Skan inner = build_attrs_declarator (attrs, inner); 2378169689Skan if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) 2379169689Skan { 2380169689Skan c_parser_consume_token (parser); 2381169689Skan if (inner == NULL) 2382169689Skan return NULL; 2383169689Skan else 2384169689Skan return c_parser_direct_declarator_inner (parser, *seen_id, inner); 2385169689Skan } 2386169689Skan else 2387169689Skan { 2388169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 2389169689Skan "expected %<)%>"); 2390169689Skan return NULL; 2391169689Skan } 2392169689Skan } 2393169689Skan else 2394169689Skan { 2395169689Skan if (kind == C_DTR_NORMAL) 2396169689Skan { 2397169689Skan c_parser_error (parser, "expected identifier or %<(%>"); 2398169689Skan return NULL; 2399169689Skan } 2400169689Skan else 2401169689Skan return build_id_declarator (NULL_TREE); 2402169689Skan } 2403169689Skan} 2404169689Skan 2405169689Skan/* Parse part of a direct declarator or direct abstract declarator, 2406169689Skan given that some (in INNER) has already been parsed; ID_PRESENT is 2407169689Skan true if an identifier is present, false for an abstract 2408169689Skan declarator. */ 2409169689Skan 2410169689Skanstatic struct c_declarator * 2411169689Skanc_parser_direct_declarator_inner (c_parser *parser, bool id_present, 2412169689Skan struct c_declarator *inner) 2413169689Skan{ 2414169689Skan /* Parse a sequence of array declarators and parameter lists. */ 2415169689Skan if (c_parser_next_token_is (parser, CPP_OPEN_SQUARE)) 2416169689Skan { 2417169689Skan struct c_declarator *declarator; 2418169689Skan struct c_declspecs *quals_attrs = build_null_declspecs (); 2419169689Skan bool static_seen; 2420169689Skan bool star_seen; 2421169689Skan tree dimen; 2422169689Skan c_parser_consume_token (parser); 2423169689Skan c_parser_declspecs (parser, quals_attrs, false, false, true); 2424169689Skan static_seen = c_parser_next_token_is_keyword (parser, RID_STATIC); 2425169689Skan if (static_seen) 2426169689Skan c_parser_consume_token (parser); 2427169689Skan if (static_seen && !quals_attrs->declspecs_seen_p) 2428169689Skan c_parser_declspecs (parser, quals_attrs, false, false, true); 2429169689Skan if (!quals_attrs->declspecs_seen_p) 2430169689Skan quals_attrs = NULL; 2431169689Skan /* If "static" is present, there must be an array dimension. 2432169689Skan Otherwise, there may be a dimension, "*", or no 2433169689Skan dimension. */ 2434169689Skan if (static_seen) 2435169689Skan { 2436169689Skan star_seen = false; 2437169689Skan dimen = c_parser_expr_no_commas (parser, NULL).value; 2438169689Skan } 2439169689Skan else 2440169689Skan { 2441169689Skan if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE)) 2442169689Skan { 2443169689Skan dimen = NULL_TREE; 2444169689Skan star_seen = false; 2445169689Skan } 2446169689Skan else if (c_parser_next_token_is (parser, CPP_MULT)) 2447169689Skan { 2448169689Skan if (c_parser_peek_2nd_token (parser)->type == CPP_CLOSE_SQUARE) 2449169689Skan { 2450169689Skan dimen = NULL_TREE; 2451169689Skan star_seen = true; 2452169689Skan c_parser_consume_token (parser); 2453169689Skan } 2454169689Skan else 2455169689Skan { 2456169689Skan star_seen = false; 2457169689Skan dimen = c_parser_expr_no_commas (parser, NULL).value; 2458169689Skan } 2459169689Skan } 2460169689Skan else 2461169689Skan { 2462169689Skan star_seen = false; 2463169689Skan dimen = c_parser_expr_no_commas (parser, NULL).value; 2464169689Skan } 2465169689Skan } 2466169689Skan if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE)) 2467169689Skan c_parser_consume_token (parser); 2468169689Skan else 2469169689Skan { 2470169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, 2471169689Skan "expected %<]%>"); 2472169689Skan return NULL; 2473169689Skan } 2474169689Skan declarator = build_array_declarator (dimen, quals_attrs, static_seen, 2475169689Skan star_seen); 2476169689Skan if (declarator == NULL) 2477169689Skan return NULL; 2478169689Skan inner = set_array_declarator_inner (declarator, inner, !id_present); 2479169689Skan return c_parser_direct_declarator_inner (parser, id_present, inner); 2480169689Skan } 2481169689Skan else if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)) 2482169689Skan { 2483169689Skan tree attrs; 2484169689Skan struct c_arg_info *args; 2485169689Skan c_parser_consume_token (parser); 2486169689Skan attrs = c_parser_attributes (parser); 2487169689Skan args = c_parser_parms_declarator (parser, id_present, attrs); 2488169689Skan if (args == NULL) 2489169689Skan return NULL; 2490169689Skan else 2491169689Skan { 2492169689Skan inner = build_function_declarator (args, inner); 2493169689Skan return c_parser_direct_declarator_inner (parser, id_present, inner); 2494169689Skan } 2495169689Skan } 2496169689Skan return inner; 2497169689Skan} 2498169689Skan 2499169689Skan/* Parse a parameter list or identifier list, including the closing 2500169689Skan parenthesis but not the opening one. ATTRS are the attributes at 2501169689Skan the start of the list. ID_LIST_OK is true if an identifier list is 2502169689Skan acceptable; such a list must not have attributes at the start. */ 2503169689Skan 2504169689Skanstatic struct c_arg_info * 2505169689Skanc_parser_parms_declarator (c_parser *parser, bool id_list_ok, tree attrs) 2506169689Skan{ 2507169689Skan push_scope (); 2508169689Skan declare_parm_level (); 2509169689Skan /* If the list starts with an identifier, it is an identifier list. 2510169689Skan Otherwise, it is either a prototype list or an empty list. */ 2511169689Skan if (id_list_ok 2512169689Skan && !attrs 2513169689Skan && c_parser_next_token_is (parser, CPP_NAME) 2514169689Skan && c_parser_peek_token (parser)->id_kind == C_ID_ID) 2515169689Skan { 2516169689Skan tree list = NULL_TREE, *nextp = &list; 2517169689Skan while (c_parser_next_token_is (parser, CPP_NAME) 2518169689Skan && c_parser_peek_token (parser)->id_kind == C_ID_ID) 2519169689Skan { 2520169689Skan *nextp = build_tree_list (NULL_TREE, 2521169689Skan c_parser_peek_token (parser)->value); 2522169689Skan nextp = & TREE_CHAIN (*nextp); 2523169689Skan c_parser_consume_token (parser); 2524169689Skan if (c_parser_next_token_is_not (parser, CPP_COMMA)) 2525169689Skan break; 2526169689Skan c_parser_consume_token (parser); 2527169689Skan if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) 2528169689Skan { 2529169689Skan c_parser_error (parser, "expected identifier"); 2530169689Skan break; 2531169689Skan } 2532169689Skan } 2533169689Skan if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) 2534169689Skan { 2535169689Skan struct c_arg_info *ret = XOBNEW (&parser_obstack, struct c_arg_info); 2536169689Skan ret->parms = 0; 2537169689Skan ret->tags = 0; 2538169689Skan ret->types = list; 2539169689Skan ret->others = 0; 2540169689Skan ret->pending_sizes = 0; 2541169689Skan ret->had_vla_unspec = 0; 2542169689Skan c_parser_consume_token (parser); 2543169689Skan pop_scope (); 2544169689Skan return ret; 2545169689Skan } 2546169689Skan else 2547169689Skan { 2548169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 2549169689Skan "expected %<)%>"); 2550169689Skan pop_scope (); 2551169689Skan return NULL; 2552169689Skan } 2553169689Skan } 2554169689Skan else 2555169689Skan { 2556169689Skan struct c_arg_info *ret = c_parser_parms_list_declarator (parser, attrs); 2557169689Skan pop_scope (); 2558169689Skan return ret; 2559169689Skan } 2560169689Skan} 2561169689Skan 2562169689Skan/* Parse a parameter list (possibly empty), including the closing 2563169689Skan parenthesis but not the opening one. ATTRS are the attributes at 2564169689Skan the start of the list. */ 2565169689Skan 2566169689Skanstatic struct c_arg_info * 2567169689Skanc_parser_parms_list_declarator (c_parser *parser, tree attrs) 2568169689Skan{ 2569169689Skan bool good_parm = false; 2570169689Skan /* ??? Following the old parser, forward parameter declarations may 2571169689Skan use abstract declarators, and if no real parameter declarations 2572169689Skan follow the forward declarations then this is not diagnosed. Also 2573169689Skan note as above that attributes are ignored as the only contents of 2574169689Skan the parentheses, or as the only contents after forward 2575169689Skan declarations. */ 2576169689Skan if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) 2577169689Skan { 2578169689Skan struct c_arg_info *ret = XOBNEW (&parser_obstack, struct c_arg_info); 2579169689Skan ret->parms = 0; 2580169689Skan ret->tags = 0; 2581169689Skan ret->types = 0; 2582169689Skan ret->others = 0; 2583169689Skan ret->pending_sizes = 0; 2584169689Skan ret->had_vla_unspec = 0; 2585169689Skan c_parser_consume_token (parser); 2586169689Skan return ret; 2587169689Skan } 2588169689Skan if (c_parser_next_token_is (parser, CPP_ELLIPSIS)) 2589169689Skan { 2590169689Skan struct c_arg_info *ret = XOBNEW (&parser_obstack, struct c_arg_info); 2591169689Skan ret->parms = 0; 2592169689Skan ret->tags = 0; 2593169689Skan ret->others = 0; 2594169689Skan ret->pending_sizes = 0; 2595169689Skan ret->had_vla_unspec = 0; 2596169689Skan /* Suppress -Wold-style-definition for this case. */ 2597169689Skan ret->types = error_mark_node; 2598169689Skan error ("ISO C requires a named argument before %<...%>"); 2599169689Skan c_parser_consume_token (parser); 2600169689Skan if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) 2601169689Skan { 2602169689Skan c_parser_consume_token (parser); 2603169689Skan return ret; 2604169689Skan } 2605169689Skan else 2606169689Skan { 2607169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 2608169689Skan "expected %<)%>"); 2609169689Skan return NULL; 2610169689Skan } 2611169689Skan } 2612169689Skan /* Nonempty list of parameters, either terminated with semicolon 2613169689Skan (forward declarations; recurse) or with close parenthesis (normal 2614169689Skan function) or with ", ... )" (variadic function). */ 2615169689Skan while (true) 2616169689Skan { 2617169689Skan /* Parse a parameter. */ 2618169689Skan struct c_parm *parm = c_parser_parameter_declaration (parser, attrs); 2619169689Skan attrs = NULL_TREE; 2620169689Skan if (parm != NULL) 2621169689Skan { 2622169689Skan good_parm = true; 2623169689Skan push_parm_decl (parm); 2624169689Skan } 2625169689Skan if (c_parser_next_token_is (parser, CPP_SEMICOLON)) 2626169689Skan { 2627169689Skan tree new_attrs; 2628169689Skan c_parser_consume_token (parser); 2629169689Skan mark_forward_parm_decls (); 2630169689Skan new_attrs = c_parser_attributes (parser); 2631169689Skan return c_parser_parms_list_declarator (parser, new_attrs); 2632169689Skan } 2633169689Skan if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) 2634169689Skan { 2635169689Skan c_parser_consume_token (parser); 2636169689Skan if (good_parm) 2637169689Skan return get_parm_info (false); 2638169689Skan else 2639169689Skan { 2640169689Skan struct c_arg_info *ret 2641169689Skan = XOBNEW (&parser_obstack, struct c_arg_info); 2642169689Skan ret->parms = 0; 2643169689Skan ret->tags = 0; 2644169689Skan ret->types = 0; 2645169689Skan ret->others = 0; 2646169689Skan ret->pending_sizes = 0; 2647169689Skan ret->had_vla_unspec = 0; 2648169689Skan return ret; 2649169689Skan } 2650169689Skan } 2651169689Skan if (!c_parser_require (parser, CPP_COMMA, 2652169689Skan "expected %<;%>, %<,%> or %<)%>")) 2653169689Skan { 2654169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); 2655169689Skan return NULL; 2656169689Skan } 2657169689Skan if (c_parser_next_token_is (parser, CPP_ELLIPSIS)) 2658169689Skan { 2659169689Skan c_parser_consume_token (parser); 2660169689Skan if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) 2661169689Skan { 2662169689Skan c_parser_consume_token (parser); 2663169689Skan if (good_parm) 2664169689Skan return get_parm_info (true); 2665169689Skan else 2666169689Skan { 2667169689Skan struct c_arg_info *ret 2668169689Skan = XOBNEW (&parser_obstack, struct c_arg_info); 2669169689Skan ret->parms = 0; 2670169689Skan ret->tags = 0; 2671169689Skan ret->types = 0; 2672169689Skan ret->others = 0; 2673169689Skan ret->pending_sizes = 0; 2674169689Skan ret->had_vla_unspec = 0; 2675169689Skan return ret; 2676169689Skan } 2677169689Skan } 2678169689Skan else 2679169689Skan { 2680169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 2681169689Skan "expected %<)%>"); 2682169689Skan return NULL; 2683169689Skan } 2684169689Skan } 2685169689Skan } 2686169689Skan} 2687169689Skan 2688169689Skan/* Parse a parameter declaration. ATTRS are the attributes at the 2689169689Skan start of the declaration if it is the first parameter. */ 2690169689Skan 2691169689Skanstatic struct c_parm * 2692169689Skanc_parser_parameter_declaration (c_parser *parser, tree attrs) 2693169689Skan{ 2694169689Skan struct c_declspecs *specs; 2695169689Skan struct c_declarator *declarator; 2696169689Skan tree prefix_attrs; 2697169689Skan tree postfix_attrs = NULL_TREE; 2698169689Skan bool dummy = false; 2699169689Skan if (!c_parser_next_token_starts_declspecs (parser)) 2700169689Skan { 2701169689Skan /* ??? In some Objective-C cases '...' isn't applicable so there 2702169689Skan should be a different message. */ 2703169689Skan c_parser_error (parser, 2704169689Skan "expected declaration specifiers or %<...%>"); 2705169689Skan c_parser_skip_to_end_of_parameter (parser); 2706169689Skan return NULL; 2707169689Skan } 2708169689Skan specs = build_null_declspecs (); 2709169689Skan if (attrs) 2710169689Skan { 2711169689Skan declspecs_add_attrs (specs, attrs); 2712169689Skan attrs = NULL_TREE; 2713169689Skan } 2714169689Skan c_parser_declspecs (parser, specs, true, true, true); 2715169689Skan finish_declspecs (specs); 2716169689Skan pending_xref_error (); 2717169689Skan prefix_attrs = specs->attrs; 2718169689Skan specs->attrs = NULL_TREE; 2719169689Skan declarator = c_parser_declarator (parser, specs->type_seen_p, 2720169689Skan C_DTR_PARM, &dummy); 2721169689Skan if (declarator == NULL) 2722169689Skan { 2723169689Skan c_parser_skip_until_found (parser, CPP_COMMA, NULL); 2724169689Skan return NULL; 2725169689Skan } 2726169689Skan if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE)) 2727169689Skan postfix_attrs = c_parser_attributes (parser); 2728169689Skan return build_c_parm (specs, chainon (postfix_attrs, prefix_attrs), 2729169689Skan declarator); 2730169689Skan} 2731169689Skan 2732169689Skan/* Parse a string literal in an asm expression. It should not be 2733169689Skan translated, and wide string literals are an error although 2734169689Skan permitted by the syntax. This is a GNU extension. 2735169689Skan 2736169689Skan asm-string-literal: 2737169689Skan string-literal 2738169689Skan 2739169689Skan ??? At present, following the old parser, the caller needs to have 2740169689Skan set c_lex_string_translate to 0. It would be better to follow the 2741169689Skan C++ parser rather than using the c_lex_string_translate kludge. */ 2742169689Skan 2743169689Skanstatic tree 2744169689Skanc_parser_asm_string_literal (c_parser *parser) 2745169689Skan{ 2746169689Skan tree str; 2747169689Skan if (c_parser_next_token_is (parser, CPP_STRING)) 2748169689Skan { 2749169689Skan str = c_parser_peek_token (parser)->value; 2750169689Skan c_parser_consume_token (parser); 2751169689Skan } 2752169689Skan else if (c_parser_next_token_is (parser, CPP_WSTRING)) 2753169689Skan { 2754169689Skan error ("wide string literal in %<asm%>"); 2755169689Skan str = build_string (1, ""); 2756169689Skan c_parser_consume_token (parser); 2757169689Skan } 2758169689Skan else 2759169689Skan { 2760169689Skan c_parser_error (parser, "expected string literal"); 2761169689Skan str = NULL_TREE; 2762169689Skan } 2763169689Skan return str; 2764169689Skan} 2765169689Skan 2766169689Skan/* Parse a simple asm expression. This is used in restricted 2767169689Skan contexts, where a full expression with inputs and outputs does not 2768169689Skan make sense. This is a GNU extension. 2769169689Skan 2770169689Skan simple-asm-expr: 2771169689Skan asm ( asm-string-literal ) 2772169689Skan*/ 2773169689Skan 2774169689Skanstatic tree 2775169689Skanc_parser_simple_asm_expr (c_parser *parser) 2776169689Skan{ 2777169689Skan tree str; 2778169689Skan gcc_assert (c_parser_next_token_is_keyword (parser, RID_ASM)); 2779169689Skan /* ??? Follow the C++ parser rather than using the 2780169689Skan c_lex_string_translate kludge. */ 2781169689Skan c_lex_string_translate = 0; 2782169689Skan c_parser_consume_token (parser); 2783169689Skan if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 2784169689Skan { 2785169689Skan c_lex_string_translate = 1; 2786169689Skan return NULL_TREE; 2787169689Skan } 2788169689Skan str = c_parser_asm_string_literal (parser); 2789169689Skan c_lex_string_translate = 1; 2790169689Skan if (!c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>")) 2791169689Skan { 2792169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); 2793169689Skan return NULL_TREE; 2794169689Skan } 2795169689Skan return str; 2796169689Skan} 2797169689Skan 2798169689Skan/* Parse (possibly empty) attributes. This is a GNU extension. 2799169689Skan 2800169689Skan attributes: 2801169689Skan empty 2802169689Skan attributes attribute 2803169689Skan 2804169689Skan attribute: 2805169689Skan __attribute__ ( ( attribute-list ) ) 2806169689Skan 2807169689Skan attribute-list: 2808169689Skan attrib 2809169689Skan attribute_list , attrib 2810169689Skan 2811169689Skan attrib: 2812169689Skan empty 2813169689Skan any-word 2814169689Skan any-word ( identifier ) 2815169689Skan any-word ( identifier , nonempty-expr-list ) 2816169689Skan any-word ( expr-list ) 2817169689Skan 2818169689Skan where the "identifier" must not be declared as a type, and 2819169689Skan "any-word" may be any identifier (including one declared as a 2820169689Skan type), a reserved word storage class specifier, type specifier or 2821169689Skan type qualifier. ??? This still leaves out most reserved keywords 2822169689Skan (following the old parser), shouldn't we include them, and why not 2823169689Skan allow identifiers declared as types to start the arguments? */ 2824169689Skan 2825169689Skanstatic tree 2826169689Skanc_parser_attributes (c_parser *parser) 2827169689Skan{ 2828169689Skan tree attrs = NULL_TREE; 2829169689Skan while (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE)) 2830169689Skan { 2831169689Skan /* ??? Follow the C++ parser rather than using the 2832169689Skan c_lex_string_translate kludge. */ 2833169689Skan c_lex_string_translate = 0; 2834169689Skan c_parser_consume_token (parser); 2835169689Skan if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 2836169689Skan { 2837169689Skan c_lex_string_translate = 1; 2838169689Skan return attrs; 2839169689Skan } 2840169689Skan if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 2841169689Skan { 2842169689Skan c_lex_string_translate = 1; 2843169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); 2844169689Skan return attrs; 2845169689Skan } 2846169689Skan /* Parse the attribute list. */ 2847169689Skan while (c_parser_next_token_is (parser, CPP_COMMA) 2848169689Skan || c_parser_next_token_is (parser, CPP_NAME) 2849169689Skan || c_parser_next_token_is (parser, CPP_KEYWORD)) 2850169689Skan { 2851169689Skan tree attr, attr_name, attr_args; 2852169689Skan if (c_parser_next_token_is (parser, CPP_COMMA)) 2853169689Skan { 2854169689Skan c_parser_consume_token (parser); 2855169689Skan continue; 2856169689Skan } 2857169689Skan if (c_parser_next_token_is (parser, CPP_KEYWORD)) 2858169689Skan { 2859169689Skan /* ??? See comment above about what keywords are 2860169689Skan accepted here. */ 2861169689Skan bool ok; 2862169689Skan switch (c_parser_peek_token (parser)->keyword) 2863169689Skan { 2864169689Skan case RID_STATIC: 2865169689Skan case RID_UNSIGNED: 2866169689Skan case RID_LONG: 2867169689Skan case RID_CONST: 2868169689Skan case RID_EXTERN: 2869169689Skan case RID_REGISTER: 2870169689Skan case RID_TYPEDEF: 2871169689Skan case RID_SHORT: 2872169689Skan case RID_INLINE: 2873169689Skan case RID_VOLATILE: 2874169689Skan case RID_SIGNED: 2875169689Skan case RID_AUTO: 2876169689Skan case RID_RESTRICT: 2877169689Skan case RID_COMPLEX: 2878169689Skan case RID_THREAD: 2879169689Skan case RID_INT: 2880169689Skan case RID_CHAR: 2881169689Skan case RID_FLOAT: 2882169689Skan case RID_DOUBLE: 2883169689Skan case RID_VOID: 2884169689Skan case RID_DFLOAT32: 2885169689Skan case RID_DFLOAT64: 2886169689Skan case RID_DFLOAT128: 2887169689Skan case RID_BOOL: 2888169689Skan ok = true; 2889169689Skan break; 2890169689Skan default: 2891169689Skan ok = false; 2892169689Skan break; 2893169689Skan } 2894169689Skan if (!ok) 2895169689Skan break; 2896169689Skan } 2897169689Skan attr_name = c_parser_peek_token (parser)->value; 2898169689Skan c_parser_consume_token (parser); 2899169689Skan if (c_parser_next_token_is_not (parser, CPP_OPEN_PAREN)) 2900169689Skan { 2901169689Skan attr = build_tree_list (attr_name, NULL_TREE); 2902169689Skan attrs = chainon (attrs, attr); 2903169689Skan continue; 2904169689Skan } 2905169689Skan c_parser_consume_token (parser); 2906169689Skan /* Parse the attribute contents. If they start with an 2907169689Skan identifier which is followed by a comma or close 2908169689Skan parenthesis, then the arguments start with that 2909169689Skan identifier; otherwise they are an expression list. */ 2910169689Skan if (c_parser_next_token_is (parser, CPP_NAME) 2911169689Skan && c_parser_peek_token (parser)->id_kind == C_ID_ID 2912169689Skan && ((c_parser_peek_2nd_token (parser)->type == CPP_COMMA) 2913169689Skan || (c_parser_peek_2nd_token (parser)->type 2914169689Skan == CPP_CLOSE_PAREN))) 2915169689Skan { 2916169689Skan tree arg1 = c_parser_peek_token (parser)->value; 2917169689Skan c_parser_consume_token (parser); 2918169689Skan if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) 2919169689Skan attr_args = build_tree_list (NULL_TREE, arg1); 2920169689Skan else 2921169689Skan { 2922169689Skan c_parser_consume_token (parser); 2923169689Skan attr_args = tree_cons (NULL_TREE, arg1, 2924169689Skan c_parser_expr_list (parser, false)); 2925169689Skan } 2926169689Skan } 2927169689Skan else 2928169689Skan { 2929169689Skan if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) 2930169689Skan attr_args = NULL_TREE; 2931169689Skan else 2932169689Skan attr_args = c_parser_expr_list (parser, false); 2933169689Skan } 2934169689Skan attr = build_tree_list (attr_name, attr_args); 2935169689Skan if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) 2936169689Skan c_parser_consume_token (parser); 2937169689Skan else 2938169689Skan { 2939169689Skan c_lex_string_translate = 1; 2940169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 2941169689Skan "expected %<)%>"); 2942169689Skan return attrs; 2943169689Skan } 2944169689Skan attrs = chainon (attrs, attr); 2945169689Skan } 2946169689Skan if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) 2947169689Skan c_parser_consume_token (parser); 2948169689Skan else 2949169689Skan { 2950169689Skan c_lex_string_translate = 1; 2951169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 2952169689Skan "expected %<)%>"); 2953169689Skan return attrs; 2954169689Skan } 2955169689Skan if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) 2956169689Skan c_parser_consume_token (parser); 2957169689Skan else 2958169689Skan { 2959169689Skan c_lex_string_translate = 1; 2960169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 2961169689Skan "expected %<)%>"); 2962169689Skan return attrs; 2963169689Skan } 2964169689Skan c_lex_string_translate = 1; 2965169689Skan } 2966169689Skan return attrs; 2967169689Skan} 2968169689Skan 2969169689Skan/* Parse a type name (C90 6.5.5, C99 6.7.6). 2970169689Skan 2971169689Skan type-name: 2972169689Skan specifier-qualifier-list abstract-declarator[opt] 2973169689Skan*/ 2974169689Skan 2975169689Skanstatic struct c_type_name * 2976169689Skanc_parser_type_name (c_parser *parser) 2977169689Skan{ 2978169689Skan struct c_declspecs *specs = build_null_declspecs (); 2979169689Skan struct c_declarator *declarator; 2980169689Skan struct c_type_name *ret; 2981169689Skan bool dummy = false; 2982169689Skan c_parser_declspecs (parser, specs, false, true, true); 2983169689Skan if (!specs->declspecs_seen_p) 2984169689Skan { 2985169689Skan c_parser_error (parser, "expected specifier-qualifier-list"); 2986169689Skan return NULL; 2987169689Skan } 2988169689Skan pending_xref_error (); 2989169689Skan finish_declspecs (specs); 2990169689Skan declarator = c_parser_declarator (parser, specs->type_seen_p, 2991169689Skan C_DTR_ABSTRACT, &dummy); 2992169689Skan if (declarator == NULL) 2993169689Skan return NULL; 2994169689Skan ret = XOBNEW (&parser_obstack, struct c_type_name); 2995169689Skan ret->specs = specs; 2996169689Skan ret->declarator = declarator; 2997169689Skan return ret; 2998169689Skan} 2999169689Skan 3000169689Skan/* Parse an initializer (C90 6.5.7, C99 6.7.8). 3001169689Skan 3002169689Skan initializer: 3003169689Skan assignment-expression 3004169689Skan { initializer-list } 3005169689Skan { initializer-list , } 3006169689Skan 3007169689Skan initializer-list: 3008169689Skan designation[opt] initializer 3009169689Skan initializer-list , designation[opt] initializer 3010169689Skan 3011169689Skan designation: 3012169689Skan designator-list = 3013169689Skan 3014169689Skan designator-list: 3015169689Skan designator 3016169689Skan designator-list designator 3017169689Skan 3018169689Skan designator: 3019169689Skan array-designator 3020169689Skan . identifier 3021169689Skan 3022169689Skan array-designator: 3023169689Skan [ constant-expression ] 3024169689Skan 3025169689Skan GNU extensions: 3026169689Skan 3027169689Skan initializer: 3028169689Skan { } 3029169689Skan 3030169689Skan designation: 3031169689Skan array-designator 3032169689Skan identifier : 3033169689Skan 3034169689Skan array-designator: 3035169689Skan [ constant-expression ... constant-expression ] 3036169689Skan 3037169689Skan Any expression without commas is accepted in the syntax for the 3038169689Skan constant-expressions, with non-constant expressions rejected later. 3039169689Skan 3040169689Skan This function is only used for top-level initializers; for nested 3041169689Skan ones, see c_parser_initval. */ 3042169689Skan 3043169689Skanstatic struct c_expr 3044169689Skanc_parser_initializer (c_parser *parser) 3045169689Skan{ 3046169689Skan if (c_parser_next_token_is (parser, CPP_OPEN_BRACE)) 3047169689Skan return c_parser_braced_init (parser, NULL_TREE, false); 3048169689Skan else 3049169689Skan { 3050169689Skan struct c_expr ret; 3051169689Skan ret = c_parser_expr_no_commas (parser, NULL); 3052169689Skan if (TREE_CODE (ret.value) != STRING_CST 3053169689Skan && TREE_CODE (ret.value) != COMPOUND_LITERAL_EXPR) 3054169689Skan ret = default_function_array_conversion (ret); 3055169689Skan return ret; 3056169689Skan } 3057169689Skan} 3058169689Skan 3059169689Skan/* Parse a braced initializer list. TYPE is the type specified for a 3060169689Skan compound literal, and NULL_TREE for other initializers and for 3061169689Skan nested braced lists. NESTED_P is true for nested braced lists, 3062169689Skan false for the list of a compound literal or the list that is the 3063169689Skan top-level initializer in a declaration. */ 3064169689Skan 3065169689Skanstatic struct c_expr 3066169689Skanc_parser_braced_init (c_parser *parser, tree type, bool nested_p) 3067169689Skan{ 3068169689Skan gcc_assert (c_parser_next_token_is (parser, CPP_OPEN_BRACE)); 3069169689Skan c_parser_consume_token (parser); 3070169689Skan if (nested_p) 3071169689Skan push_init_level (0); 3072169689Skan else 3073169689Skan really_start_incremental_init (type); 3074169689Skan if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE)) 3075169689Skan { 3076169689Skan if (pedantic) 3077169689Skan pedwarn ("ISO C forbids empty initializer braces"); 3078169689Skan } 3079169689Skan else 3080169689Skan { 3081169689Skan /* Parse a non-empty initializer list, possibly with a trailing 3082169689Skan comma. */ 3083169689Skan while (true) 3084169689Skan { 3085169689Skan c_parser_initelt (parser); 3086169689Skan if (parser->error) 3087169689Skan break; 3088169689Skan if (c_parser_next_token_is (parser, CPP_COMMA)) 3089169689Skan c_parser_consume_token (parser); 3090169689Skan else 3091169689Skan break; 3092169689Skan if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE)) 3093169689Skan break; 3094169689Skan } 3095169689Skan } 3096169689Skan if (c_parser_next_token_is_not (parser, CPP_CLOSE_BRACE)) 3097169689Skan { 3098169689Skan struct c_expr ret; 3099169689Skan ret.value = error_mark_node; 3100169689Skan ret.original_code = ERROR_MARK; 3101169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, "expected %<}%>"); 3102169689Skan return ret; 3103169689Skan } 3104169689Skan c_parser_consume_token (parser); 3105169689Skan return pop_init_level (0); 3106169689Skan} 3107169689Skan 3108169689Skan/* Parse a nested initializer, including designators. */ 3109169689Skan 3110169689Skanstatic void 3111169689Skanc_parser_initelt (c_parser *parser) 3112169689Skan{ 3113169689Skan /* Parse any designator or designator list. A single array 3114169689Skan designator may have the subsequent "=" omitted in GNU C, but a 3115169689Skan longer list or a structure member designator may not. */ 3116169689Skan if (c_parser_next_token_is (parser, CPP_NAME) 3117169689Skan && c_parser_peek_2nd_token (parser)->type == CPP_COLON) 3118169689Skan { 3119169689Skan /* Old-style structure member designator. */ 3120169689Skan set_init_label (c_parser_peek_token (parser)->value); 3121169689Skan if (pedantic) 3122169689Skan pedwarn ("obsolete use of designated initializer with %<:%>"); 3123169689Skan c_parser_consume_token (parser); 3124169689Skan c_parser_consume_token (parser); 3125169689Skan } 3126169689Skan else 3127169689Skan { 3128169689Skan /* des_seen is 0 if there have been no designators, 1 if there 3129169689Skan has been a single array designator and 2 otherwise. */ 3130169689Skan int des_seen = 0; 3131169689Skan while (c_parser_next_token_is (parser, CPP_OPEN_SQUARE) 3132169689Skan || c_parser_next_token_is (parser, CPP_DOT)) 3133169689Skan { 3134169689Skan int des_prev = des_seen; 3135169689Skan if (des_seen < 2) 3136169689Skan des_seen++; 3137169689Skan if (c_parser_next_token_is (parser, CPP_DOT)) 3138169689Skan { 3139169689Skan des_seen = 2; 3140169689Skan c_parser_consume_token (parser); 3141169689Skan if (c_parser_next_token_is (parser, CPP_NAME)) 3142169689Skan { 3143169689Skan set_init_label (c_parser_peek_token (parser)->value); 3144169689Skan c_parser_consume_token (parser); 3145169689Skan } 3146169689Skan else 3147169689Skan { 3148169689Skan struct c_expr init; 3149169689Skan init.value = error_mark_node; 3150169689Skan init.original_code = ERROR_MARK; 3151169689Skan c_parser_error (parser, "expected identifier"); 3152169689Skan c_parser_skip_until_found (parser, CPP_COMMA, NULL); 3153169689Skan process_init_element (init); 3154169689Skan return; 3155169689Skan } 3156169689Skan } 3157169689Skan else 3158169689Skan { 3159169689Skan tree first, second; 3160169689Skan /* ??? Following the old parser, [ objc-receiver 3161169689Skan objc-message-args ] is accepted as an initializer, 3162169689Skan being distinguished from a designator by what follows 3163169689Skan the first assignment expression inside the square 3164169689Skan brackets, but after a first array designator a 3165169689Skan subsequent square bracket is for Objective-C taken to 3166169689Skan start an expression, using the obsolete form of 3167169689Skan designated initializer without '=', rather than 3168169689Skan possibly being a second level of designation: in LALR 3169169689Skan terms, the '[' is shifted rather than reducing 3170169689Skan designator to designator-list. */ 3171169689Skan if (des_prev == 1 && c_dialect_objc ()) 3172169689Skan { 3173169689Skan des_seen = des_prev; 3174169689Skan break; 3175169689Skan } 3176169689Skan if (des_prev == 0 && c_dialect_objc ()) 3177169689Skan { 3178169689Skan /* This might be an array designator or an 3179169689Skan Objective-C message expression. If the former, 3180169689Skan continue parsing here; if the latter, parse the 3181169689Skan remainder of the initializer given the starting 3182169689Skan primary-expression. ??? It might make sense to 3183169689Skan distinguish when des_prev == 1 as well; see 3184169689Skan previous comment. */ 3185169689Skan tree rec, args; 3186169689Skan struct c_expr mexpr; 3187169689Skan c_parser_consume_token (parser); 3188169689Skan if (c_parser_peek_token (parser)->type == CPP_NAME 3189169689Skan && ((c_parser_peek_token (parser)->id_kind 3190169689Skan == C_ID_TYPENAME) 3191169689Skan || (c_parser_peek_token (parser)->id_kind 3192169689Skan == C_ID_CLASSNAME))) 3193169689Skan { 3194169689Skan /* Type name receiver. */ 3195169689Skan tree id = c_parser_peek_token (parser)->value; 3196169689Skan c_parser_consume_token (parser); 3197169689Skan rec = objc_get_class_reference (id); 3198169689Skan goto parse_message_args; 3199169689Skan } 3200169689Skan first = c_parser_expr_no_commas (parser, NULL).value; 3201169689Skan if (c_parser_next_token_is (parser, CPP_ELLIPSIS) 3202169689Skan || c_parser_next_token_is (parser, CPP_CLOSE_SQUARE)) 3203169689Skan goto array_desig_after_first; 3204169689Skan /* Expression receiver. So far only one part 3205169689Skan without commas has been parsed; there might be 3206169689Skan more of the expression. */ 3207169689Skan rec = first; 3208169689Skan while (c_parser_next_token_is (parser, CPP_COMMA)) 3209169689Skan { 3210169689Skan struct c_expr next; 3211169689Skan c_parser_consume_token (parser); 3212169689Skan next = c_parser_expr_no_commas (parser, NULL); 3213169689Skan next = default_function_array_conversion (next); 3214169689Skan rec = build_compound_expr (rec, next.value); 3215169689Skan } 3216169689Skan parse_message_args: 3217169689Skan /* Now parse the objc-message-args. */ 3218169689Skan args = c_parser_objc_message_args (parser); 3219169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, 3220169689Skan "expected %<]%>"); 3221169689Skan mexpr.value 3222169689Skan = objc_build_message_expr (build_tree_list (rec, args)); 3223169689Skan mexpr.original_code = ERROR_MARK; 3224169689Skan /* Now parse and process the remainder of the 3225169689Skan initializer, starting with this message 3226169689Skan expression as a primary-expression. */ 3227169689Skan c_parser_initval (parser, &mexpr); 3228169689Skan return; 3229169689Skan } 3230169689Skan c_parser_consume_token (parser); 3231169689Skan first = c_parser_expr_no_commas (parser, NULL).value; 3232169689Skan array_desig_after_first: 3233169689Skan if (c_parser_next_token_is (parser, CPP_ELLIPSIS)) 3234169689Skan { 3235169689Skan c_parser_consume_token (parser); 3236169689Skan second = c_parser_expr_no_commas (parser, NULL).value; 3237169689Skan } 3238169689Skan else 3239169689Skan second = NULL_TREE; 3240169689Skan if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE)) 3241169689Skan { 3242169689Skan c_parser_consume_token (parser); 3243169689Skan set_init_index (first, second); 3244169689Skan if (pedantic && second) 3245169689Skan pedwarn ("ISO C forbids specifying range of " 3246169689Skan "elements to initialize"); 3247169689Skan } 3248169689Skan else 3249169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, 3250169689Skan "expected %<]%>"); 3251169689Skan } 3252169689Skan } 3253169689Skan if (des_seen >= 1) 3254169689Skan { 3255169689Skan if (c_parser_next_token_is (parser, CPP_EQ)) 3256169689Skan { 3257169689Skan if (pedantic && !flag_isoc99) 3258169689Skan pedwarn ("ISO C90 forbids specifying subobject to initialize"); 3259169689Skan c_parser_consume_token (parser); 3260169689Skan } 3261169689Skan else 3262169689Skan { 3263169689Skan if (des_seen == 1) 3264169689Skan { 3265169689Skan if (pedantic) 3266169689Skan pedwarn ("obsolete use of designated initializer " 3267169689Skan "without %<=%>"); 3268169689Skan } 3269169689Skan else 3270169689Skan { 3271169689Skan struct c_expr init; 3272169689Skan init.value = error_mark_node; 3273169689Skan init.original_code = ERROR_MARK; 3274169689Skan c_parser_error (parser, "expected %<=%>"); 3275169689Skan c_parser_skip_until_found (parser, CPP_COMMA, NULL); 3276169689Skan process_init_element (init); 3277169689Skan return; 3278169689Skan } 3279169689Skan } 3280169689Skan } 3281169689Skan } 3282169689Skan c_parser_initval (parser, NULL); 3283169689Skan} 3284169689Skan 3285169689Skan/* Parse a nested initializer; as c_parser_initializer but parses 3286169689Skan initializers within braced lists, after any designators have been 3287169689Skan applied. If AFTER is not NULL then it is an Objective-C message 3288169689Skan expression which is the primary-expression starting the 3289169689Skan initializer. */ 3290169689Skan 3291169689Skanstatic void 3292169689Skanc_parser_initval (c_parser *parser, struct c_expr *after) 3293169689Skan{ 3294169689Skan struct c_expr init; 3295169689Skan gcc_assert (!after || c_dialect_objc ()); 3296169689Skan if (c_parser_next_token_is (parser, CPP_OPEN_BRACE) && !after) 3297169689Skan init = c_parser_braced_init (parser, NULL_TREE, true); 3298169689Skan else 3299169689Skan { 3300169689Skan init = c_parser_expr_no_commas (parser, after); 3301169689Skan if (init.value != NULL_TREE 3302169689Skan && TREE_CODE (init.value) != STRING_CST 3303169689Skan && TREE_CODE (init.value) != COMPOUND_LITERAL_EXPR) 3304169689Skan init = default_function_array_conversion (init); 3305169689Skan } 3306169689Skan process_init_element (init); 3307169689Skan} 3308169689Skan 3309169689Skan/* Parse a compound statement (possibly a function body) (C90 6.6.2, 3310169689Skan C99 6.8.2). 3311169689Skan 3312169689Skan compound-statement: 3313169689Skan { block-item-list[opt] } 3314169689Skan { label-declarations block-item-list } 3315169689Skan 3316169689Skan block-item-list: 3317169689Skan block-item 3318169689Skan block-item-list block-item 3319169689Skan 3320169689Skan block-item: 3321169689Skan nested-declaration 3322169689Skan statement 3323169689Skan 3324169689Skan nested-declaration: 3325169689Skan declaration 3326169689Skan 3327169689Skan GNU extensions: 3328169689Skan 3329169689Skan compound-statement: 3330169689Skan { label-declarations block-item-list } 3331169689Skan 3332169689Skan nested-declaration: 3333169689Skan __extension__ nested-declaration 3334169689Skan nested-function-definition 3335169689Skan 3336169689Skan label-declarations: 3337169689Skan label-declaration 3338169689Skan label-declarations label-declaration 3339169689Skan 3340169689Skan label-declaration: 3341169689Skan __label__ identifier-list ; 3342169689Skan 3343169689Skan Allowing the mixing of declarations and code is new in C99. The 3344169689Skan GNU syntax also permits (not shown above) labels at the end of 3345169689Skan compound statements, which yield an error. We don't allow labels 3346169689Skan on declarations; this might seem like a natural extension, but 3347169689Skan there would be a conflict between attributes on the label and 3348169689Skan prefix attributes on the declaration. ??? The syntax follows the 3349169689Skan old parser in requiring something after label declarations. 3350169689Skan Although they are erroneous if the labels declared aren't defined, 3351169689Skan is it useful for the syntax to be this way? 3352169689Skan 3353169689Skan OpenMP: 3354169689Skan 3355169689Skan block-item: 3356169689Skan openmp-directive 3357169689Skan 3358169689Skan openmp-directive: 3359169689Skan barrier-directive 3360169689Skan flush-directive */ 3361169689Skan 3362169689Skanstatic tree 3363169689Skanc_parser_compound_statement (c_parser *parser) 3364169689Skan{ 3365169689Skan tree stmt; 3366169689Skan if (!c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>")) 3367169689Skan return error_mark_node; 3368169689Skan stmt = c_begin_compound_stmt (true); 3369169689Skan c_parser_compound_statement_nostart (parser); 3370169689Skan return c_end_compound_stmt (stmt, true); 3371169689Skan} 3372169689Skan 3373169689Skan/* Parse a compound statement except for the opening brace. This is 3374169689Skan used for parsing both compound statements and statement expressions 3375169689Skan (which follow different paths to handling the opening). */ 3376169689Skan 3377169689Skanstatic void 3378169689Skanc_parser_compound_statement_nostart (c_parser *parser) 3379169689Skan{ 3380169689Skan bool last_stmt = false; 3381169689Skan bool last_label = false; 3382169689Skan if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE)) 3383169689Skan { 3384169689Skan c_parser_consume_token (parser); 3385169689Skan return; 3386169689Skan } 3387169689Skan if (c_parser_next_token_is_keyword (parser, RID_LABEL)) 3388169689Skan { 3389169689Skan /* Read zero or more forward-declarations for labels that nested 3390169689Skan functions can jump to. */ 3391169689Skan while (c_parser_next_token_is_keyword (parser, RID_LABEL)) 3392169689Skan { 3393169689Skan c_parser_consume_token (parser); 3394169689Skan /* Any identifiers, including those declared as type names, 3395169689Skan are OK here. */ 3396169689Skan while (true) 3397169689Skan { 3398169689Skan tree label; 3399169689Skan if (c_parser_next_token_is_not (parser, CPP_NAME)) 3400169689Skan { 3401169689Skan c_parser_error (parser, "expected identifier"); 3402169689Skan break; 3403169689Skan } 3404169689Skan label 3405169689Skan = declare_label (c_parser_peek_token (parser)->value); 3406169689Skan C_DECLARED_LABEL_FLAG (label) = 1; 3407169689Skan add_stmt (build_stmt (DECL_EXPR, label)); 3408169689Skan c_parser_consume_token (parser); 3409169689Skan if (c_parser_next_token_is (parser, CPP_COMMA)) 3410169689Skan c_parser_consume_token (parser); 3411169689Skan else 3412169689Skan break; 3413169689Skan } 3414169689Skan c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>"); 3415169689Skan } 3416169689Skan /* ??? Locating this diagnostic on the token after the 3417169689Skan declarations end follows the old parser, but it might be 3418169689Skan better to locate it where the declarations start instead. */ 3419169689Skan if (pedantic) 3420169689Skan pedwarn ("ISO C forbids label declarations"); 3421169689Skan } 3422169689Skan /* We must now have at least one statement, label or declaration. */ 3423169689Skan if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE)) 3424169689Skan { 3425169689Skan c_parser_error (parser, "expected declaration or statement"); 3426169689Skan c_parser_consume_token (parser); 3427169689Skan return; 3428169689Skan } 3429169689Skan while (c_parser_next_token_is_not (parser, CPP_CLOSE_BRACE)) 3430169689Skan { 3431169689Skan location_t loc = c_parser_peek_token (parser)->location; 3432169689Skan if (c_parser_next_token_is_keyword (parser, RID_CASE) 3433169689Skan || c_parser_next_token_is_keyword (parser, RID_DEFAULT) 3434169689Skan || (c_parser_next_token_is (parser, CPP_NAME) 3435169689Skan && c_parser_peek_2nd_token (parser)->type == CPP_COLON)) 3436169689Skan { 3437169689Skan last_label = true; 3438169689Skan last_stmt = false; 3439169689Skan c_parser_label (parser); 3440169689Skan } 3441169689Skan else if (!last_label 3442169689Skan && c_parser_next_token_starts_declspecs (parser)) 3443169689Skan { 3444169689Skan last_label = false; 3445169689Skan c_parser_declaration_or_fndef (parser, true, true, true, true); 3446169689Skan if (last_stmt 3447169689Skan && ((pedantic && !flag_isoc99) 3448169689Skan || warn_declaration_after_statement)) 3449169689Skan pedwarn_c90 ("%HISO C90 forbids mixed declarations and code", 3450169689Skan &loc); 3451169689Skan last_stmt = false; 3452169689Skan } 3453169689Skan else if (!last_label 3454169689Skan && c_parser_next_token_is_keyword (parser, RID_EXTENSION)) 3455169689Skan { 3456169689Skan /* __extension__ can start a declaration, but is also an 3457169689Skan unary operator that can start an expression. Consume all 3458169689Skan but the last of a possible series of __extension__ to 3459169689Skan determine which. */ 3460169689Skan while (c_parser_peek_2nd_token (parser)->type == CPP_KEYWORD 3461169689Skan && (c_parser_peek_2nd_token (parser)->keyword 3462169689Skan == RID_EXTENSION)) 3463169689Skan c_parser_consume_token (parser); 3464169689Skan if (c_token_starts_declspecs (c_parser_peek_2nd_token (parser))) 3465169689Skan { 3466169689Skan int ext; 3467169689Skan ext = disable_extension_diagnostics (); 3468169689Skan c_parser_consume_token (parser); 3469169689Skan last_label = false; 3470169689Skan c_parser_declaration_or_fndef (parser, true, true, true, true); 3471169689Skan /* Following the old parser, __extension__ does not 3472169689Skan disable this diagnostic. */ 3473169689Skan restore_extension_diagnostics (ext); 3474169689Skan if (last_stmt 3475169689Skan && ((pedantic && !flag_isoc99) 3476169689Skan || warn_declaration_after_statement)) 3477169689Skan pedwarn_c90 ("%HISO C90 forbids mixed declarations and code", 3478169689Skan &loc); 3479169689Skan last_stmt = false; 3480169689Skan } 3481169689Skan else 3482169689Skan goto statement; 3483169689Skan } 3484169689Skan else if (c_parser_next_token_is (parser, CPP_PRAGMA)) 3485169689Skan { 3486169689Skan /* External pragmas, and some omp pragmas, are not associated 3487169689Skan with regular c code, and so are not to be considered statements 3488169689Skan syntactically. This ensures that the user doesn't put them 3489169689Skan places that would turn into syntax errors if the directive 3490169689Skan were ignored. */ 3491169689Skan if (c_parser_pragma (parser, pragma_compound)) 3492169689Skan last_label = false, last_stmt = true; 3493169689Skan } 3494169689Skan else if (c_parser_next_token_is (parser, CPP_EOF)) 3495169689Skan { 3496169689Skan c_parser_error (parser, "expected declaration or statement"); 3497169689Skan return; 3498169689Skan } 3499169689Skan else 3500169689Skan { 3501169689Skan statement: 3502169689Skan last_label = false; 3503169689Skan last_stmt = true; 3504169689Skan c_parser_statement_after_labels (parser); 3505169689Skan } 3506169689Skan 3507169689Skan parser->error = false; 3508169689Skan } 3509169689Skan if (last_label) 3510169689Skan error ("label at end of compound statement"); 3511169689Skan c_parser_consume_token (parser); 3512169689Skan} 3513169689Skan 3514169689Skan/* Parse a label (C90 6.6.1, C99 6.8.1). 3515169689Skan 3516169689Skan label: 3517169689Skan identifier : attributes[opt] 3518169689Skan case constant-expression : 3519169689Skan default : 3520169689Skan 3521169689Skan GNU extensions: 3522169689Skan 3523169689Skan label: 3524169689Skan case constant-expression ... constant-expression : 3525169689Skan 3526169689Skan The use of attributes on labels is a GNU extension. The syntax in 3527169689Skan GNU C accepts any expressions without commas, non-constant 3528169689Skan expressions being rejected later. */ 3529169689Skan 3530169689Skanstatic void 3531169689Skanc_parser_label (c_parser *parser) 3532169689Skan{ 3533169689Skan location_t loc1 = c_parser_peek_token (parser)->location; 3534169689Skan tree label = NULL_TREE; 3535169689Skan if (c_parser_next_token_is_keyword (parser, RID_CASE)) 3536169689Skan { 3537169689Skan tree exp1, exp2; 3538169689Skan c_parser_consume_token (parser); 3539169689Skan exp1 = c_parser_expr_no_commas (parser, NULL).value; 3540169689Skan if (c_parser_next_token_is (parser, CPP_COLON)) 3541169689Skan { 3542169689Skan c_parser_consume_token (parser); 3543169689Skan label = do_case (exp1, NULL_TREE); 3544169689Skan } 3545169689Skan else if (c_parser_next_token_is (parser, CPP_ELLIPSIS)) 3546169689Skan { 3547169689Skan c_parser_consume_token (parser); 3548169689Skan exp2 = c_parser_expr_no_commas (parser, NULL).value; 3549169689Skan if (c_parser_require (parser, CPP_COLON, "expected %<:%>")) 3550169689Skan label = do_case (exp1, exp2); 3551169689Skan } 3552169689Skan else 3553169689Skan c_parser_error (parser, "expected %<:%> or %<...%>"); 3554169689Skan } 3555169689Skan else if (c_parser_next_token_is_keyword (parser, RID_DEFAULT)) 3556169689Skan { 3557169689Skan c_parser_consume_token (parser); 3558169689Skan if (c_parser_require (parser, CPP_COLON, "expected %<:%>")) 3559169689Skan label = do_case (NULL_TREE, NULL_TREE); 3560169689Skan } 3561169689Skan else 3562169689Skan { 3563169689Skan tree name = c_parser_peek_token (parser)->value; 3564169689Skan tree tlab; 3565169689Skan location_t loc2; 3566169689Skan tree attrs; 3567169689Skan gcc_assert (c_parser_next_token_is (parser, CPP_NAME)); 3568169689Skan c_parser_consume_token (parser); 3569169689Skan gcc_assert (c_parser_next_token_is (parser, CPP_COLON)); 3570169689Skan loc2 = c_parser_peek_token (parser)->location; 3571169689Skan c_parser_consume_token (parser); 3572169689Skan attrs = c_parser_attributes (parser); 3573169689Skan tlab = define_label (loc2, name); 3574169689Skan if (tlab) 3575169689Skan { 3576169689Skan decl_attributes (&tlab, attrs, 0); 3577169689Skan label = add_stmt (build_stmt (LABEL_EXPR, tlab)); 3578169689Skan } 3579169689Skan } 3580169689Skan if (label) 3581169689Skan SET_EXPR_LOCATION (label, loc1); 3582169689Skan} 3583169689Skan 3584169689Skan/* Parse a statement (C90 6.6, C99 6.8). 3585169689Skan 3586169689Skan statement: 3587169689Skan labeled-statement 3588169689Skan compound-statement 3589169689Skan expression-statement 3590169689Skan selection-statement 3591169689Skan iteration-statement 3592169689Skan jump-statement 3593169689Skan 3594169689Skan labeled-statement: 3595169689Skan label statement 3596169689Skan 3597169689Skan expression-statement: 3598169689Skan expression[opt] ; 3599169689Skan 3600169689Skan selection-statement: 3601169689Skan if-statement 3602169689Skan switch-statement 3603169689Skan 3604169689Skan iteration-statement: 3605169689Skan while-statement 3606169689Skan do-statement 3607169689Skan for-statement 3608169689Skan 3609169689Skan jump-statement: 3610169689Skan goto identifier ; 3611169689Skan continue ; 3612169689Skan break ; 3613169689Skan return expression[opt] ; 3614169689Skan 3615169689Skan GNU extensions: 3616169689Skan 3617169689Skan statement: 3618169689Skan asm-statement 3619169689Skan 3620169689Skan jump-statement: 3621169689Skan goto * expression ; 3622169689Skan 3623169689Skan Objective-C: 3624169689Skan 3625169689Skan statement: 3626169689Skan objc-throw-statement 3627169689Skan objc-try-catch-statement 3628169689Skan objc-synchronized-statement 3629169689Skan 3630169689Skan objc-throw-statement: 3631169689Skan @throw expression ; 3632169689Skan @throw ; 3633169689Skan 3634169689Skan OpenMP: 3635169689Skan 3636169689Skan statement: 3637169689Skan openmp-construct 3638169689Skan 3639169689Skan openmp-construct: 3640169689Skan parallel-construct 3641169689Skan for-construct 3642169689Skan sections-construct 3643169689Skan single-construct 3644169689Skan parallel-for-construct 3645169689Skan parallel-sections-construct 3646169689Skan master-construct 3647169689Skan critical-construct 3648169689Skan atomic-construct 3649169689Skan ordered-construct 3650169689Skan 3651169689Skan parallel-construct: 3652169689Skan parallel-directive structured-block 3653169689Skan 3654169689Skan for-construct: 3655169689Skan for-directive iteration-statement 3656169689Skan 3657169689Skan sections-construct: 3658169689Skan sections-directive section-scope 3659169689Skan 3660169689Skan single-construct: 3661169689Skan single-directive structured-block 3662169689Skan 3663169689Skan parallel-for-construct: 3664169689Skan parallel-for-directive iteration-statement 3665169689Skan 3666169689Skan parallel-sections-construct: 3667169689Skan parallel-sections-directive section-scope 3668169689Skan 3669169689Skan master-construct: 3670169689Skan master-directive structured-block 3671169689Skan 3672169689Skan critical-construct: 3673169689Skan critical-directive structured-block 3674169689Skan 3675169689Skan atomic-construct: 3676169689Skan atomic-directive expression-statement 3677169689Skan 3678169689Skan ordered-construct: 3679169689Skan ordered-directive structured-block */ 3680169689Skan 3681169689Skanstatic void 3682169689Skanc_parser_statement (c_parser *parser) 3683169689Skan{ 3684169689Skan while (c_parser_next_token_is_keyword (parser, RID_CASE) 3685169689Skan || c_parser_next_token_is_keyword (parser, RID_DEFAULT) 3686169689Skan || (c_parser_next_token_is (parser, CPP_NAME) 3687169689Skan && c_parser_peek_2nd_token (parser)->type == CPP_COLON)) 3688169689Skan c_parser_label (parser); 3689169689Skan c_parser_statement_after_labels (parser); 3690169689Skan} 3691169689Skan 3692169689Skan/* Parse a statement, other than a labeled statement. */ 3693169689Skan 3694169689Skanstatic void 3695169689Skanc_parser_statement_after_labels (c_parser *parser) 3696169689Skan{ 3697169689Skan location_t loc = c_parser_peek_token (parser)->location; 3698169689Skan tree stmt = NULL_TREE; 3699169689Skan switch (c_parser_peek_token (parser)->type) 3700169689Skan { 3701169689Skan case CPP_OPEN_BRACE: 3702169689Skan add_stmt (c_parser_compound_statement (parser)); 3703169689Skan break; 3704169689Skan case CPP_KEYWORD: 3705169689Skan switch (c_parser_peek_token (parser)->keyword) 3706169689Skan { 3707169689Skan case RID_IF: 3708169689Skan c_parser_if_statement (parser); 3709169689Skan break; 3710169689Skan case RID_SWITCH: 3711169689Skan c_parser_switch_statement (parser); 3712169689Skan break; 3713169689Skan case RID_WHILE: 3714169689Skan c_parser_while_statement (parser); 3715169689Skan break; 3716169689Skan case RID_DO: 3717169689Skan c_parser_do_statement (parser); 3718169689Skan break; 3719169689Skan case RID_FOR: 3720169689Skan c_parser_for_statement (parser); 3721169689Skan break; 3722169689Skan case RID_GOTO: 3723169689Skan c_parser_consume_token (parser); 3724169689Skan if (c_parser_next_token_is (parser, CPP_NAME)) 3725169689Skan { 3726169689Skan stmt = c_finish_goto_label (c_parser_peek_token (parser)->value); 3727169689Skan c_parser_consume_token (parser); 3728169689Skan } 3729169689Skan else if (c_parser_next_token_is (parser, CPP_MULT)) 3730169689Skan { 3731169689Skan c_parser_consume_token (parser); 3732169689Skan stmt = c_finish_goto_ptr (c_parser_expression (parser).value); 3733169689Skan } 3734169689Skan else 3735169689Skan c_parser_error (parser, "expected identifier or %<*%>"); 3736169689Skan goto expect_semicolon; 3737169689Skan case RID_CONTINUE: 3738169689Skan c_parser_consume_token (parser); 3739169689Skan stmt = c_finish_bc_stmt (&c_cont_label, false); 3740169689Skan goto expect_semicolon; 3741169689Skan case RID_BREAK: 3742169689Skan c_parser_consume_token (parser); 3743169689Skan stmt = c_finish_bc_stmt (&c_break_label, true); 3744169689Skan goto expect_semicolon; 3745169689Skan case RID_RETURN: 3746169689Skan c_parser_consume_token (parser); 3747169689Skan if (c_parser_next_token_is (parser, CPP_SEMICOLON)) 3748169689Skan { 3749169689Skan stmt = c_finish_return (NULL_TREE); 3750169689Skan c_parser_consume_token (parser); 3751169689Skan } 3752169689Skan else 3753169689Skan { 3754169689Skan stmt = c_finish_return (c_parser_expression_conv (parser).value); 3755169689Skan goto expect_semicolon; 3756169689Skan } 3757169689Skan break; 3758169689Skan case RID_ASM: 3759169689Skan stmt = c_parser_asm_statement (parser); 3760169689Skan break; 3761169689Skan case RID_AT_THROW: 3762169689Skan gcc_assert (c_dialect_objc ()); 3763169689Skan c_parser_consume_token (parser); 3764169689Skan if (c_parser_next_token_is (parser, CPP_SEMICOLON)) 3765169689Skan { 3766169689Skan stmt = objc_build_throw_stmt (NULL_TREE); 3767169689Skan c_parser_consume_token (parser); 3768169689Skan } 3769169689Skan else 3770169689Skan { 3771169689Skan stmt 3772169689Skan = objc_build_throw_stmt (c_parser_expression (parser).value); 3773169689Skan goto expect_semicolon; 3774169689Skan } 3775169689Skan break; 3776169689Skan case RID_AT_TRY: 3777169689Skan gcc_assert (c_dialect_objc ()); 3778169689Skan c_parser_objc_try_catch_statement (parser); 3779169689Skan break; 3780169689Skan case RID_AT_SYNCHRONIZED: 3781169689Skan gcc_assert (c_dialect_objc ()); 3782169689Skan c_parser_objc_synchronized_statement (parser); 3783169689Skan break; 3784169689Skan default: 3785169689Skan goto expr_stmt; 3786169689Skan } 3787169689Skan break; 3788169689Skan case CPP_SEMICOLON: 3789169689Skan c_parser_consume_token (parser); 3790169689Skan break; 3791169689Skan case CPP_CLOSE_PAREN: 3792169689Skan case CPP_CLOSE_SQUARE: 3793169689Skan /* Avoid infinite loop in error recovery: 3794169689Skan c_parser_skip_until_found stops at a closing nesting 3795169689Skan delimiter without consuming it, but here we need to consume 3796169689Skan it to proceed further. */ 3797169689Skan c_parser_error (parser, "expected statement"); 3798169689Skan c_parser_consume_token (parser); 3799169689Skan break; 3800169689Skan case CPP_PRAGMA: 3801169689Skan c_parser_pragma (parser, pragma_stmt); 3802169689Skan break; 3803169689Skan default: 3804169689Skan expr_stmt: 3805169689Skan stmt = c_finish_expr_stmt (c_parser_expression_conv (parser).value); 3806169689Skan expect_semicolon: 3807169689Skan c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>"); 3808169689Skan break; 3809169689Skan } 3810169689Skan /* Two cases cannot and do not have line numbers associated: If stmt 3811169689Skan is degenerate, such as "2;", then stmt is an INTEGER_CST, which 3812169689Skan cannot hold line numbers. But that's OK because the statement 3813169689Skan will either be changed to a MODIFY_EXPR during gimplification of 3814169689Skan the statement expr, or discarded. If stmt was compound, but 3815169689Skan without new variables, we will have skipped the creation of a 3816169689Skan BIND and will have a bare STATEMENT_LIST. But that's OK because 3817169689Skan (recursively) all of the component statements should already have 3818169689Skan line numbers assigned. ??? Can we discard no-op statements 3819169689Skan earlier? */ 3820169689Skan if (stmt && EXPR_P (stmt)) 3821169689Skan SET_EXPR_LOCATION (stmt, loc); 3822169689Skan} 3823169689Skan 3824169689Skan/* Parse a parenthesized condition from an if, do or while statement. 3825169689Skan 3826169689Skan condition: 3827169689Skan ( expression ) 3828169689Skan*/ 3829169689Skanstatic tree 3830169689Skanc_parser_paren_condition (c_parser *parser) 3831169689Skan{ 3832169689Skan location_t loc; 3833169689Skan tree cond; 3834169689Skan if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 3835169689Skan return error_mark_node; 3836169689Skan loc = c_parser_peek_token (parser)->location; 3837169689Skan cond = c_objc_common_truthvalue_conversion 3838169689Skan (c_parser_expression_conv (parser).value); 3839169689Skan if (EXPR_P (cond)) 3840169689Skan SET_EXPR_LOCATION (cond, loc); 3841169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>"); 3842169689Skan return cond; 3843169689Skan} 3844169689Skan 3845169689Skan/* Parse a statement which is a block in C99. */ 3846169689Skan 3847169689Skanstatic tree 3848169689Skanc_parser_c99_block_statement (c_parser *parser) 3849169689Skan{ 3850169689Skan tree block = c_begin_compound_stmt (flag_isoc99); 3851169689Skan c_parser_statement (parser); 3852169689Skan return c_end_compound_stmt (block, flag_isoc99); 3853169689Skan} 3854169689Skan 3855169689Skan/* Parse the body of an if statement or the else half thereof. This 3856169689Skan is just parsing a statement but (a) it is a block in C99, (b) we 3857169689Skan track whether the body is an if statement for the sake of 3858169689Skan -Wparentheses warnings, (c) we handle an empty body specially for 3859169689Skan the sake of -Wextra warnings. */ 3860169689Skan 3861169689Skanstatic tree 3862169689Skanc_parser_if_body (c_parser *parser, bool *if_p) 3863169689Skan{ 3864169689Skan tree block = c_begin_compound_stmt (flag_isoc99); 3865169689Skan while (c_parser_next_token_is_keyword (parser, RID_CASE) 3866169689Skan || c_parser_next_token_is_keyword (parser, RID_DEFAULT) 3867169689Skan || (c_parser_next_token_is (parser, CPP_NAME) 3868169689Skan && c_parser_peek_2nd_token (parser)->type == CPP_COLON)) 3869169689Skan c_parser_label (parser); 3870169689Skan *if_p = c_parser_next_token_is_keyword (parser, RID_IF); 3871169689Skan if (extra_warnings && c_parser_next_token_is (parser, CPP_SEMICOLON)) 3872169689Skan add_stmt (build_empty_stmt ()); 3873169689Skan c_parser_statement_after_labels (parser); 3874169689Skan return c_end_compound_stmt (block, flag_isoc99); 3875169689Skan} 3876169689Skan 3877169689Skan/* Parse an if statement (C90 6.6.4, C99 6.8.4). 3878169689Skan 3879169689Skan if-statement: 3880169689Skan if ( expression ) statement 3881169689Skan if ( expression ) statement else statement 3882169689Skan*/ 3883169689Skan 3884169689Skanstatic void 3885169689Skanc_parser_if_statement (c_parser *parser) 3886169689Skan{ 3887169689Skan tree block; 3888169689Skan location_t loc; 3889169689Skan tree cond; 3890169689Skan bool first_if = false, second_if = false; 3891169689Skan tree first_body, second_body; 3892169689Skan gcc_assert (c_parser_next_token_is_keyword (parser, RID_IF)); 3893169689Skan c_parser_consume_token (parser); 3894169689Skan block = c_begin_compound_stmt (flag_isoc99); 3895169689Skan loc = c_parser_peek_token (parser)->location; 3896169689Skan cond = c_parser_paren_condition (parser); 3897169689Skan first_body = c_parser_if_body (parser, &first_if); 3898169689Skan if (c_parser_next_token_is_keyword (parser, RID_ELSE)) 3899169689Skan { 3900169689Skan c_parser_consume_token (parser); 3901169689Skan second_body = c_parser_if_body (parser, &second_if); 3902169689Skan } 3903169689Skan else 3904169689Skan second_body = NULL_TREE; 3905169689Skan c_finish_if_stmt (loc, cond, first_body, second_body, first_if); 3906169689Skan add_stmt (c_end_compound_stmt (block, flag_isoc99)); 3907169689Skan} 3908169689Skan 3909169689Skan/* Parse a switch statement (C90 6.6.4, C99 6.8.4). 3910169689Skan 3911169689Skan switch-statement: 3912169689Skan switch (expression) statement 3913169689Skan*/ 3914169689Skan 3915169689Skanstatic void 3916169689Skanc_parser_switch_statement (c_parser *parser) 3917169689Skan{ 3918169689Skan tree block, expr, body, save_break; 3919169689Skan gcc_assert (c_parser_next_token_is_keyword (parser, RID_SWITCH)); 3920169689Skan c_parser_consume_token (parser); 3921169689Skan block = c_begin_compound_stmt (flag_isoc99); 3922169689Skan if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 3923169689Skan { 3924169689Skan expr = c_parser_expression (parser).value; 3925169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>"); 3926169689Skan } 3927169689Skan else 3928169689Skan expr = error_mark_node; 3929169689Skan c_start_case (expr); 3930169689Skan save_break = c_break_label; 3931169689Skan c_break_label = NULL_TREE; 3932169689Skan body = c_parser_c99_block_statement (parser); 3933169689Skan c_finish_case (body); 3934169689Skan if (c_break_label) 3935169689Skan add_stmt (build1 (LABEL_EXPR, void_type_node, c_break_label)); 3936169689Skan c_break_label = save_break; 3937169689Skan add_stmt (c_end_compound_stmt (block, flag_isoc99)); 3938169689Skan} 3939169689Skan 3940169689Skan/* Parse a while statement (C90 6.6.5, C99 6.8.5). 3941169689Skan 3942169689Skan while-statement: 3943260919Spfg APPLE LOCAL begin for-fsf-4_4 3274130 5295549 3944260919Spfg while attributes (expression) statement 3945260919Spfg 3946260919Spfg The use of attributes is a GNU extension. 3947260919Spfg APPLE LOCAL end for-fsf-4_4 3274130 5295549 3948169689Skan*/ 3949169689Skan 3950169689Skanstatic void 3951169689Skanc_parser_while_statement (c_parser *parser) 3952169689Skan{ 3953260919Spfg/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \ 3954260919Spfg tree block, cond, body, save_break, save_cont, attrs; 3955260919Spfg/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \ 3956169689Skan location_t loc; 3957169689Skan gcc_assert (c_parser_next_token_is_keyword (parser, RID_WHILE)); 3958169689Skan c_parser_consume_token (parser); 3959260919Spfg/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \ 3960260919Spfg attrs = c_parser_attributes (parser); 3961260919Spfg/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \ 3962169689Skan block = c_begin_compound_stmt (flag_isoc99); 3963169689Skan loc = c_parser_peek_token (parser)->location; 3964169689Skan cond = c_parser_paren_condition (parser); 3965169689Skan save_break = c_break_label; 3966169689Skan c_break_label = NULL_TREE; 3967169689Skan save_cont = c_cont_label; 3968169689Skan c_cont_label = NULL_TREE; 3969169689Skan body = c_parser_c99_block_statement (parser); 3970260919Spfg/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \ 3971260919Spfg c_finish_loop (loc, cond, NULL, body, c_break_label, c_cont_label, attrs, 3972260919Spfg true); 3973260919Spfg/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \ 3974169689Skan add_stmt (c_end_compound_stmt (block, flag_isoc99)); 3975169689Skan c_break_label = save_break; 3976169689Skan c_cont_label = save_cont; 3977169689Skan} 3978169689Skan 3979169689Skan/* Parse a do statement (C90 6.6.5, C99 6.8.5). 3980169689Skan 3981169689Skan do-statement: 3982260919Spfg APPLE LOCAL begin for-fsf-4_4 3274130 5295549 3983260919Spfg do attributes statement while ( expression ) ; 3984260919Spfg 3985260919Spfg The use of attributes is a GNU extension. 3986260919Spfg APPLE LOCAL end for-fsf-4_4 3274130 5295549 3987169689Skan*/ 3988169689Skan 3989169689Skanstatic void 3990169689Skanc_parser_do_statement (c_parser *parser) 3991169689Skan{ 3992260919Spfg/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \ 3993260919Spfg tree block, cond, body, save_break, save_cont, new_break, new_cont, attrs; 3994260919Spfg/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \ 3995169689Skan location_t loc; 3996169689Skan gcc_assert (c_parser_next_token_is_keyword (parser, RID_DO)); 3997169689Skan c_parser_consume_token (parser); 3998260919Spfg/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \ 3999260919Spfg attrs = c_parser_attributes (parser); 4000260919Spfg/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \ 4001169689Skan block = c_begin_compound_stmt (flag_isoc99); 4002169689Skan loc = c_parser_peek_token (parser)->location; 4003169689Skan save_break = c_break_label; 4004169689Skan c_break_label = NULL_TREE; 4005169689Skan save_cont = c_cont_label; 4006169689Skan c_cont_label = NULL_TREE; 4007169689Skan body = c_parser_c99_block_statement (parser); 4008169689Skan c_parser_require_keyword (parser, RID_WHILE, "expected %<while%>"); 4009169689Skan new_break = c_break_label; 4010169689Skan c_break_label = save_break; 4011169689Skan new_cont = c_cont_label; 4012169689Skan c_cont_label = save_cont; 4013169689Skan cond = c_parser_paren_condition (parser); 4014169689Skan if (!c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>")) 4015169689Skan c_parser_skip_to_end_of_block_or_statement (parser); 4016260919Spfg/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \ 4017260919Spfg c_finish_loop (loc, cond, NULL, body, new_break, new_cont, attrs, false); 4018260919Spfg/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \ 4019169689Skan add_stmt (c_end_compound_stmt (block, flag_isoc99)); 4020169689Skan} 4021169689Skan 4022169689Skan/* Parse a for statement (C90 6.6.5, C99 6.8.5). 4023169689Skan 4024169689Skan for-statement: 4025260919Spfg APPLE LOCAL begin for-fsf-4_4 3274130 5295549 4026260919Spfg for attributes ( expression[opt] ; expression[opt] ; expression[opt] ) \ 4027260919Spfg statement 4028260919Spfg for attributes ( nested-declaration expression[opt] ; expression[opt] ) \ 4029260919Spfg statement 4030169689Skan 4031169689Skan The form with a declaration is new in C99. 4032169689Skan 4033260919Spfg The use of attributes is a GNU extension. 4034260919Spfg 4035260919Spfg APPLE LOCAL end for-fsf-4_4 3274130 5295549 4036169689Skan ??? In accordance with the old parser, the declaration may be a 4037169689Skan nested function, which is then rejected in check_for_loop_decls, 4038169689Skan but does it make any sense for this to be included in the grammar? 4039169689Skan Note in particular that the nested function does not include a 4040169689Skan trailing ';', whereas the "declaration" production includes one. 4041169689Skan Also, can we reject bad declarations earlier and cheaper than 4042169689Skan check_for_loop_decls? */ 4043169689Skan 4044169689Skanstatic void 4045169689Skanc_parser_for_statement (c_parser *parser) 4046169689Skan{ 4047260919Spfg/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \ 4048260919Spfg tree block, cond, incr, save_break, save_cont, body, attrs; 4049260919Spfg/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \ 4050169689Skan location_t loc; 4051169689Skan gcc_assert (c_parser_next_token_is_keyword (parser, RID_FOR)); 4052169689Skan loc = c_parser_peek_token (parser)->location; 4053169689Skan c_parser_consume_token (parser); 4054260919Spfg/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \ 4055260919Spfg attrs = c_parser_attributes (parser); 4056260919Spfg/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \ 4057169689Skan block = c_begin_compound_stmt (flag_isoc99); 4058169689Skan if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 4059169689Skan { 4060169689Skan /* Parse the initialization declaration or expression. */ 4061169689Skan if (c_parser_next_token_is (parser, CPP_SEMICOLON)) 4062169689Skan { 4063169689Skan c_parser_consume_token (parser); 4064169689Skan c_finish_expr_stmt (NULL_TREE); 4065169689Skan } 4066169689Skan else if (c_parser_next_token_starts_declspecs (parser)) 4067169689Skan { 4068169689Skan c_parser_declaration_or_fndef (parser, true, true, true, true); 4069169689Skan check_for_loop_decls (); 4070169689Skan } 4071169689Skan else if (c_parser_next_token_is_keyword (parser, RID_EXTENSION)) 4072169689Skan { 4073169689Skan /* __extension__ can start a declaration, but is also an 4074169689Skan unary operator that can start an expression. Consume all 4075169689Skan but the last of a possible series of __extension__ to 4076169689Skan determine which. */ 4077169689Skan while (c_parser_peek_2nd_token (parser)->type == CPP_KEYWORD 4078169689Skan && (c_parser_peek_2nd_token (parser)->keyword 4079169689Skan == RID_EXTENSION)) 4080169689Skan c_parser_consume_token (parser); 4081169689Skan if (c_token_starts_declspecs (c_parser_peek_2nd_token (parser))) 4082169689Skan { 4083169689Skan int ext; 4084169689Skan ext = disable_extension_diagnostics (); 4085169689Skan c_parser_consume_token (parser); 4086169689Skan c_parser_declaration_or_fndef (parser, true, true, true, true); 4087169689Skan restore_extension_diagnostics (ext); 4088169689Skan check_for_loop_decls (); 4089169689Skan } 4090169689Skan else 4091169689Skan goto init_expr; 4092169689Skan } 4093169689Skan else 4094169689Skan { 4095169689Skan init_expr: 4096169689Skan c_finish_expr_stmt (c_parser_expression (parser).value); 4097169689Skan c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>"); 4098169689Skan } 4099169689Skan /* Parse the loop condition. */ 4100169689Skan loc = c_parser_peek_token (parser)->location; 4101169689Skan if (c_parser_next_token_is (parser, CPP_SEMICOLON)) 4102169689Skan { 4103169689Skan c_parser_consume_token (parser); 4104169689Skan cond = NULL_TREE; 4105169689Skan } 4106169689Skan else 4107169689Skan { 4108169689Skan tree ocond = c_parser_expression_conv (parser).value; 4109169689Skan cond = c_objc_common_truthvalue_conversion (ocond); 4110169689Skan if (EXPR_P (cond)) 4111169689Skan SET_EXPR_LOCATION (cond, loc); 4112169689Skan c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>"); 4113169689Skan } 4114169689Skan /* Parse the increment expression. */ 4115169689Skan if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) 4116169689Skan incr = c_process_expr_stmt (NULL_TREE); 4117169689Skan else 4118169689Skan incr = c_process_expr_stmt (c_parser_expression (parser).value); 4119169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>"); 4120169689Skan } 4121169689Skan else 4122169689Skan { 4123169689Skan cond = error_mark_node; 4124169689Skan incr = error_mark_node; 4125169689Skan } 4126169689Skan save_break = c_break_label; 4127169689Skan c_break_label = NULL_TREE; 4128169689Skan save_cont = c_cont_label; 4129169689Skan c_cont_label = NULL_TREE; 4130169689Skan body = c_parser_c99_block_statement (parser); 4131260919Spfg/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \ 4132260919Spfg c_finish_loop (loc, cond, incr, body, c_break_label, c_cont_label, attrs, 4133260919Spfg true); 4134260919Spfg/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \ 4135169689Skan add_stmt (c_end_compound_stmt (block, flag_isoc99)); 4136169689Skan c_break_label = save_break; 4137169689Skan c_cont_label = save_cont; 4138169689Skan} 4139169689Skan 4140169689Skan/* Parse an asm statement, a GNU extension. This is a full-blown asm 4141169689Skan statement with inputs, outputs, clobbers, and volatile tag 4142169689Skan allowed. 4143169689Skan 4144169689Skan asm-statement: 4145169689Skan asm type-qualifier[opt] ( asm-argument ) ; 4146169689Skan 4147169689Skan asm-argument: 4148169689Skan asm-string-literal 4149169689Skan asm-string-literal : asm-operands[opt] 4150169689Skan asm-string-literal : asm-operands[opt] : asm-operands[opt] 4151169689Skan asm-string-literal : asm-operands[opt] : asm-operands[opt] : asm-clobbers 4152169689Skan 4153169689Skan Qualifiers other than volatile are accepted in the syntax but 4154169689Skan warned for. */ 4155169689Skan 4156169689Skanstatic tree 4157169689Skanc_parser_asm_statement (c_parser *parser) 4158169689Skan{ 4159169689Skan tree quals, str, outputs, inputs, clobbers, ret; 4160169689Skan bool simple; 4161169689Skan gcc_assert (c_parser_next_token_is_keyword (parser, RID_ASM)); 4162169689Skan c_parser_consume_token (parser); 4163169689Skan if (c_parser_next_token_is_keyword (parser, RID_VOLATILE)) 4164169689Skan { 4165169689Skan quals = c_parser_peek_token (parser)->value; 4166169689Skan c_parser_consume_token (parser); 4167169689Skan } 4168169689Skan else if (c_parser_next_token_is_keyword (parser, RID_CONST) 4169169689Skan || c_parser_next_token_is_keyword (parser, RID_RESTRICT)) 4170169689Skan { 4171169689Skan warning (0, "%E qualifier ignored on asm", 4172169689Skan c_parser_peek_token (parser)->value); 4173169689Skan quals = NULL_TREE; 4174169689Skan c_parser_consume_token (parser); 4175169689Skan } 4176169689Skan else 4177169689Skan quals = NULL_TREE; 4178169689Skan /* ??? Follow the C++ parser rather than using the 4179169689Skan c_lex_string_translate kludge. */ 4180169689Skan c_lex_string_translate = 0; 4181169689Skan if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 4182169689Skan { 4183169689Skan c_lex_string_translate = 1; 4184169689Skan return NULL_TREE; 4185169689Skan } 4186169689Skan str = c_parser_asm_string_literal (parser); 4187169689Skan if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) 4188169689Skan { 4189169689Skan simple = true; 4190169689Skan outputs = NULL_TREE; 4191169689Skan inputs = NULL_TREE; 4192169689Skan clobbers = NULL_TREE; 4193169689Skan goto done_asm; 4194169689Skan } 4195169689Skan if (!c_parser_require (parser, CPP_COLON, "expected %<:%> or %<)%>")) 4196169689Skan { 4197169689Skan c_lex_string_translate = 1; 4198169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); 4199169689Skan return NULL_TREE; 4200169689Skan } 4201169689Skan simple = false; 4202169689Skan /* Parse outputs. */ 4203169689Skan if (c_parser_next_token_is (parser, CPP_COLON) 4204169689Skan || c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) 4205169689Skan outputs = NULL_TREE; 4206169689Skan else 4207169689Skan outputs = c_parser_asm_operands (parser, false); 4208169689Skan if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) 4209169689Skan { 4210169689Skan inputs = NULL_TREE; 4211169689Skan clobbers = NULL_TREE; 4212169689Skan goto done_asm; 4213169689Skan } 4214169689Skan if (!c_parser_require (parser, CPP_COLON, "expected %<:%> or %<)%>")) 4215169689Skan { 4216169689Skan c_lex_string_translate = 1; 4217169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); 4218169689Skan return NULL_TREE; 4219169689Skan } 4220169689Skan /* Parse inputs. */ 4221169689Skan if (c_parser_next_token_is (parser, CPP_COLON) 4222169689Skan || c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) 4223169689Skan inputs = NULL_TREE; 4224169689Skan else 4225169689Skan inputs = c_parser_asm_operands (parser, true); 4226169689Skan if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) 4227169689Skan { 4228169689Skan clobbers = NULL_TREE; 4229169689Skan goto done_asm; 4230169689Skan } 4231169689Skan if (!c_parser_require (parser, CPP_COLON, "expected %<:%> or %<)%>")) 4232169689Skan { 4233169689Skan c_lex_string_translate = 1; 4234169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); 4235169689Skan return NULL_TREE; 4236169689Skan } 4237169689Skan /* Parse clobbers. */ 4238169689Skan clobbers = c_parser_asm_clobbers (parser); 4239169689Skan done_asm: 4240169689Skan c_lex_string_translate = 1; 4241169689Skan if (!c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>")) 4242169689Skan { 4243169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); 4244169689Skan return NULL_TREE; 4245169689Skan } 4246169689Skan if (!c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>")) 4247169689Skan c_parser_skip_to_end_of_block_or_statement (parser); 4248169689Skan ret = build_asm_stmt (quals, build_asm_expr (str, outputs, inputs, 4249169689Skan clobbers, simple)); 4250169689Skan return ret; 4251169689Skan} 4252169689Skan 4253169689Skan/* Parse asm operands, a GNU extension. If CONVERT_P (for inputs but 4254169689Skan not outputs), apply the default conversion of functions and arrays 4255169689Skan to pointers. 4256169689Skan 4257169689Skan asm-operands: 4258169689Skan asm-operand 4259169689Skan asm-operands , asm-operand 4260169689Skan 4261169689Skan asm-operand: 4262169689Skan asm-string-literal ( expression ) 4263169689Skan [ identifier ] asm-string-literal ( expression ) 4264169689Skan*/ 4265169689Skan 4266169689Skanstatic tree 4267169689Skanc_parser_asm_operands (c_parser *parser, bool convert_p) 4268169689Skan{ 4269169689Skan tree list = NULL_TREE; 4270169689Skan while (true) 4271169689Skan { 4272169689Skan tree name, str; 4273169689Skan struct c_expr expr; 4274169689Skan if (c_parser_next_token_is (parser, CPP_OPEN_SQUARE)) 4275169689Skan { 4276169689Skan c_parser_consume_token (parser); 4277169689Skan if (c_parser_next_token_is (parser, CPP_NAME)) 4278169689Skan { 4279169689Skan tree id = c_parser_peek_token (parser)->value; 4280169689Skan c_parser_consume_token (parser); 4281169689Skan name = build_string (IDENTIFIER_LENGTH (id), 4282169689Skan IDENTIFIER_POINTER (id)); 4283169689Skan } 4284169689Skan else 4285169689Skan { 4286169689Skan c_parser_error (parser, "expected identifier"); 4287169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, NULL); 4288169689Skan return NULL_TREE; 4289169689Skan } 4290169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, 4291169689Skan "expected %<]%>"); 4292169689Skan } 4293169689Skan else 4294169689Skan name = NULL_TREE; 4295169689Skan str = c_parser_asm_string_literal (parser); 4296169689Skan if (str == NULL_TREE) 4297169689Skan return NULL_TREE; 4298169689Skan c_lex_string_translate = 1; 4299169689Skan if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 4300169689Skan { 4301169689Skan c_lex_string_translate = 0; 4302169689Skan return NULL_TREE; 4303169689Skan } 4304169689Skan expr = c_parser_expression (parser); 4305169689Skan if (convert_p) 4306169689Skan expr = default_function_array_conversion (expr); 4307169689Skan c_lex_string_translate = 0; 4308169689Skan if (!c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>")) 4309169689Skan { 4310169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); 4311169689Skan return NULL_TREE; 4312169689Skan } 4313169689Skan list = chainon (list, build_tree_list (build_tree_list (name, str), 4314169689Skan expr.value)); 4315169689Skan if (c_parser_next_token_is (parser, CPP_COMMA)) 4316169689Skan c_parser_consume_token (parser); 4317169689Skan else 4318169689Skan break; 4319169689Skan } 4320169689Skan return list; 4321169689Skan} 4322169689Skan 4323169689Skan/* Parse asm clobbers, a GNU extension. 4324169689Skan 4325169689Skan asm-clobbers: 4326169689Skan asm-string-literal 4327169689Skan asm-clobbers , asm-string-literal 4328169689Skan*/ 4329169689Skan 4330169689Skanstatic tree 4331169689Skanc_parser_asm_clobbers (c_parser *parser) 4332169689Skan{ 4333169689Skan tree list = NULL_TREE; 4334169689Skan while (true) 4335169689Skan { 4336169689Skan tree str = c_parser_asm_string_literal (parser); 4337169689Skan if (str) 4338169689Skan list = tree_cons (NULL_TREE, str, list); 4339169689Skan else 4340169689Skan return NULL_TREE; 4341169689Skan if (c_parser_next_token_is (parser, CPP_COMMA)) 4342169689Skan c_parser_consume_token (parser); 4343169689Skan else 4344169689Skan break; 4345169689Skan } 4346169689Skan return list; 4347169689Skan} 4348169689Skan 4349169689Skan/* Parse an expression other than a compound expression; that is, an 4350169689Skan assignment expression (C90 6.3.16, C99 6.5.16). If AFTER is not 4351169689Skan NULL then it is an Objective-C message expression which is the 4352169689Skan primary-expression starting the expression as an initializer. 4353169689Skan 4354169689Skan assignment-expression: 4355169689Skan conditional-expression 4356169689Skan unary-expression assignment-operator assignment-expression 4357169689Skan 4358169689Skan assignment-operator: one of 4359169689Skan = *= /= %= += -= <<= >>= &= ^= |= 4360169689Skan 4361169689Skan In GNU C we accept any conditional expression on the LHS and 4362169689Skan diagnose the invalid lvalue rather than producing a syntax 4363169689Skan error. */ 4364169689Skan 4365169689Skanstatic struct c_expr 4366169689Skanc_parser_expr_no_commas (c_parser *parser, struct c_expr *after) 4367169689Skan{ 4368169689Skan struct c_expr lhs, rhs, ret; 4369169689Skan enum tree_code code; 4370169689Skan gcc_assert (!after || c_dialect_objc ()); 4371169689Skan lhs = c_parser_conditional_expression (parser, after); 4372169689Skan switch (c_parser_peek_token (parser)->type) 4373169689Skan { 4374169689Skan case CPP_EQ: 4375169689Skan code = NOP_EXPR; 4376169689Skan break; 4377169689Skan case CPP_MULT_EQ: 4378169689Skan code = MULT_EXPR; 4379169689Skan break; 4380169689Skan case CPP_DIV_EQ: 4381169689Skan code = TRUNC_DIV_EXPR; 4382169689Skan break; 4383169689Skan case CPP_MOD_EQ: 4384169689Skan code = TRUNC_MOD_EXPR; 4385169689Skan break; 4386169689Skan case CPP_PLUS_EQ: 4387169689Skan code = PLUS_EXPR; 4388169689Skan break; 4389169689Skan case CPP_MINUS_EQ: 4390169689Skan code = MINUS_EXPR; 4391169689Skan break; 4392169689Skan case CPP_LSHIFT_EQ: 4393169689Skan code = LSHIFT_EXPR; 4394169689Skan break; 4395169689Skan case CPP_RSHIFT_EQ: 4396169689Skan code = RSHIFT_EXPR; 4397169689Skan break; 4398169689Skan case CPP_AND_EQ: 4399169689Skan code = BIT_AND_EXPR; 4400169689Skan break; 4401169689Skan case CPP_XOR_EQ: 4402169689Skan code = BIT_XOR_EXPR; 4403169689Skan break; 4404169689Skan case CPP_OR_EQ: 4405169689Skan code = BIT_IOR_EXPR; 4406169689Skan break; 4407169689Skan default: 4408169689Skan return lhs; 4409169689Skan } 4410169689Skan c_parser_consume_token (parser); 4411169689Skan rhs = c_parser_expr_no_commas (parser, NULL); 4412169689Skan rhs = default_function_array_conversion (rhs); 4413169689Skan ret.value = build_modify_expr (lhs.value, code, rhs.value); 4414169689Skan if (code == NOP_EXPR) 4415169689Skan ret.original_code = MODIFY_EXPR; 4416169689Skan else 4417169689Skan { 4418169689Skan TREE_NO_WARNING (ret.value) = 1; 4419169689Skan ret.original_code = ERROR_MARK; 4420169689Skan } 4421169689Skan return ret; 4422169689Skan} 4423169689Skan 4424169689Skan/* Parse a conditional expression (C90 6.3.15, C99 6.5.15). If AFTER 4425169689Skan is not NULL then it is an Objective-C message expression which is 4426169689Skan the primary-expression starting the expression as an initializer. 4427169689Skan 4428169689Skan conditional-expression: 4429169689Skan logical-OR-expression 4430169689Skan logical-OR-expression ? expression : conditional-expression 4431169689Skan 4432169689Skan GNU extensions: 4433169689Skan 4434169689Skan conditional-expression: 4435169689Skan logical-OR-expression ? : conditional-expression 4436169689Skan*/ 4437169689Skan 4438169689Skanstatic struct c_expr 4439169689Skanc_parser_conditional_expression (c_parser *parser, struct c_expr *after) 4440169689Skan{ 4441169689Skan struct c_expr cond, exp1, exp2, ret; 4442169689Skan gcc_assert (!after || c_dialect_objc ()); 4443169689Skan cond = c_parser_binary_expression (parser, after); 4444169689Skan if (c_parser_next_token_is_not (parser, CPP_QUERY)) 4445169689Skan return cond; 4446169689Skan cond = default_function_array_conversion (cond); 4447169689Skan c_parser_consume_token (parser); 4448169689Skan if (c_parser_next_token_is (parser, CPP_COLON)) 4449169689Skan { 4450169689Skan if (pedantic) 4451169689Skan pedwarn ("ISO C forbids omitting the middle term of a ?: expression"); 4452169689Skan /* Make sure first operand is calculated only once. */ 4453169689Skan exp1.value = save_expr (default_conversion (cond.value)); 4454169689Skan cond.value = c_objc_common_truthvalue_conversion (exp1.value); 4455169689Skan skip_evaluation += cond.value == truthvalue_true_node; 4456169689Skan } 4457169689Skan else 4458169689Skan { 4459169689Skan cond.value 4460169689Skan = c_objc_common_truthvalue_conversion 4461169689Skan (default_conversion (cond.value)); 4462169689Skan skip_evaluation += cond.value == truthvalue_false_node; 4463169689Skan exp1 = c_parser_expression_conv (parser); 4464169689Skan skip_evaluation += ((cond.value == truthvalue_true_node) 4465169689Skan - (cond.value == truthvalue_false_node)); 4466169689Skan } 4467169689Skan if (!c_parser_require (parser, CPP_COLON, "expected %<:%>")) 4468169689Skan { 4469169689Skan skip_evaluation -= cond.value == truthvalue_true_node; 4470169689Skan ret.value = error_mark_node; 4471169689Skan ret.original_code = ERROR_MARK; 4472169689Skan return ret; 4473169689Skan } 4474169689Skan exp2 = c_parser_conditional_expression (parser, NULL); 4475169689Skan exp2 = default_function_array_conversion (exp2); 4476169689Skan skip_evaluation -= cond.value == truthvalue_true_node; 4477169689Skan ret.value = build_conditional_expr (cond.value, exp1.value, exp2.value); 4478169689Skan ret.original_code = ERROR_MARK; 4479169689Skan return ret; 4480169689Skan} 4481169689Skan 4482169689Skan/* Parse a binary expression; that is, a logical-OR-expression (C90 4483169689Skan 6.3.5-6.3.14, C99 6.5.5-6.5.14). If AFTER is not NULL then it is 4484169689Skan an Objective-C message expression which is the primary-expression 4485169689Skan starting the expression as an initializer. 4486169689Skan 4487169689Skan multiplicative-expression: 4488169689Skan cast-expression 4489169689Skan multiplicative-expression * cast-expression 4490169689Skan multiplicative-expression / cast-expression 4491169689Skan multiplicative-expression % cast-expression 4492169689Skan 4493169689Skan additive-expression: 4494169689Skan multiplicative-expression 4495169689Skan additive-expression + multiplicative-expression 4496169689Skan additive-expression - multiplicative-expression 4497169689Skan 4498169689Skan shift-expression: 4499169689Skan additive-expression 4500169689Skan shift-expression << additive-expression 4501169689Skan shift-expression >> additive-expression 4502169689Skan 4503169689Skan relational-expression: 4504169689Skan shift-expression 4505169689Skan relational-expression < shift-expression 4506169689Skan relational-expression > shift-expression 4507169689Skan relational-expression <= shift-expression 4508169689Skan relational-expression >= shift-expression 4509169689Skan 4510169689Skan equality-expression: 4511169689Skan relational-expression 4512169689Skan equality-expression == relational-expression 4513169689Skan equality-expression != relational-expression 4514169689Skan 4515169689Skan AND-expression: 4516169689Skan equality-expression 4517169689Skan AND-expression & equality-expression 4518169689Skan 4519169689Skan exclusive-OR-expression: 4520169689Skan AND-expression 4521169689Skan exclusive-OR-expression ^ AND-expression 4522169689Skan 4523169689Skan inclusive-OR-expression: 4524169689Skan exclusive-OR-expression 4525169689Skan inclusive-OR-expression | exclusive-OR-expression 4526169689Skan 4527169689Skan logical-AND-expression: 4528169689Skan inclusive-OR-expression 4529169689Skan logical-AND-expression && inclusive-OR-expression 4530169689Skan 4531169689Skan logical-OR-expression: 4532169689Skan logical-AND-expression 4533169689Skan logical-OR-expression || logical-AND-expression 4534169689Skan*/ 4535169689Skan 4536169689Skanstatic struct c_expr 4537169689Skanc_parser_binary_expression (c_parser *parser, struct c_expr *after) 4538169689Skan{ 4539169689Skan /* A binary expression is parsed using operator-precedence parsing, 4540169689Skan with the operands being cast expressions. All the binary 4541169689Skan operators are left-associative. Thus a binary expression is of 4542169689Skan form: 4543169689Skan 4544169689Skan E0 op1 E1 op2 E2 ... 4545169689Skan 4546169689Skan which we represent on a stack. On the stack, the precedence 4547169689Skan levels are strictly increasing. When a new operator is 4548169689Skan encountered of higher precedence than that at the top of the 4549169689Skan stack, it is pushed; its LHS is the top expression, and its RHS 4550169689Skan is everything parsed until it is popped. When a new operator is 4551169689Skan encountered with precedence less than or equal to that at the top 4552169689Skan of the stack, triples E[i-1] op[i] E[i] are popped and replaced 4553169689Skan by the result of the operation until the operator at the top of 4554169689Skan the stack has lower precedence than the new operator or there is 4555169689Skan only one element on the stack; then the top expression is the LHS 4556169689Skan of the new operator. In the case of logical AND and OR 4557169689Skan expressions, we also need to adjust skip_evaluation as 4558169689Skan appropriate when the operators are pushed and popped. */ 4559169689Skan 4560169689Skan /* The precedence levels, where 0 is a dummy lowest level used for 4561169689Skan the bottom of the stack. */ 4562169689Skan enum prec { 4563169689Skan PREC_NONE, 4564169689Skan PREC_LOGOR, 4565169689Skan PREC_LOGAND, 4566169689Skan PREC_BITOR, 4567169689Skan PREC_BITXOR, 4568169689Skan PREC_BITAND, 4569169689Skan PREC_EQ, 4570169689Skan PREC_REL, 4571169689Skan PREC_SHIFT, 4572169689Skan PREC_ADD, 4573169689Skan PREC_MULT, 4574169689Skan NUM_PRECS 4575169689Skan }; 4576169689Skan struct { 4577169689Skan /* The expression at this stack level. */ 4578169689Skan struct c_expr expr; 4579169689Skan /* The precedence of the operator on its left, PREC_NONE at the 4580169689Skan bottom of the stack. */ 4581169689Skan enum prec prec; 4582169689Skan /* The operation on its left. */ 4583169689Skan enum tree_code op; 4584169689Skan } stack[NUM_PRECS]; 4585169689Skan int sp; 4586169689Skan#define POP \ 4587169689Skan do { \ 4588169689Skan switch (stack[sp].op) \ 4589169689Skan { \ 4590169689Skan case TRUTH_ANDIF_EXPR: \ 4591169689Skan skip_evaluation -= stack[sp - 1].expr.value == truthvalue_false_node; \ 4592169689Skan break; \ 4593169689Skan case TRUTH_ORIF_EXPR: \ 4594169689Skan skip_evaluation -= stack[sp - 1].expr.value == truthvalue_true_node; \ 4595169689Skan break; \ 4596169689Skan default: \ 4597169689Skan break; \ 4598169689Skan } \ 4599169689Skan stack[sp - 1].expr \ 4600169689Skan = default_function_array_conversion (stack[sp - 1].expr); \ 4601169689Skan stack[sp].expr \ 4602169689Skan = default_function_array_conversion (stack[sp].expr); \ 4603169689Skan stack[sp - 1].expr = parser_build_binary_op (stack[sp].op, \ 4604169689Skan stack[sp - 1].expr, \ 4605169689Skan stack[sp].expr); \ 4606169689Skan sp--; \ 4607169689Skan } while (0) 4608169689Skan gcc_assert (!after || c_dialect_objc ()); 4609169689Skan stack[0].expr = c_parser_cast_expression (parser, after); 4610169689Skan stack[0].prec = PREC_NONE; 4611169689Skan sp = 0; 4612169689Skan while (true) 4613169689Skan { 4614169689Skan enum prec oprec; 4615169689Skan enum tree_code ocode; 4616169689Skan if (parser->error) 4617169689Skan goto out; 4618169689Skan switch (c_parser_peek_token (parser)->type) 4619169689Skan { 4620169689Skan case CPP_MULT: 4621169689Skan oprec = PREC_MULT; 4622169689Skan ocode = MULT_EXPR; 4623169689Skan break; 4624169689Skan case CPP_DIV: 4625169689Skan oprec = PREC_MULT; 4626169689Skan ocode = TRUNC_DIV_EXPR; 4627169689Skan break; 4628169689Skan case CPP_MOD: 4629169689Skan oprec = PREC_MULT; 4630169689Skan ocode = TRUNC_MOD_EXPR; 4631169689Skan break; 4632169689Skan case CPP_PLUS: 4633169689Skan oprec = PREC_ADD; 4634169689Skan ocode = PLUS_EXPR; 4635169689Skan break; 4636169689Skan case CPP_MINUS: 4637169689Skan oprec = PREC_ADD; 4638169689Skan ocode = MINUS_EXPR; 4639169689Skan break; 4640169689Skan case CPP_LSHIFT: 4641169689Skan oprec = PREC_SHIFT; 4642169689Skan ocode = LSHIFT_EXPR; 4643169689Skan break; 4644169689Skan case CPP_RSHIFT: 4645169689Skan oprec = PREC_SHIFT; 4646169689Skan ocode = RSHIFT_EXPR; 4647169689Skan break; 4648169689Skan case CPP_LESS: 4649169689Skan oprec = PREC_REL; 4650169689Skan ocode = LT_EXPR; 4651169689Skan break; 4652169689Skan case CPP_GREATER: 4653169689Skan oprec = PREC_REL; 4654169689Skan ocode = GT_EXPR; 4655169689Skan break; 4656169689Skan case CPP_LESS_EQ: 4657169689Skan oprec = PREC_REL; 4658169689Skan ocode = LE_EXPR; 4659169689Skan break; 4660169689Skan case CPP_GREATER_EQ: 4661169689Skan oprec = PREC_REL; 4662169689Skan ocode = GE_EXPR; 4663169689Skan break; 4664169689Skan case CPP_EQ_EQ: 4665169689Skan oprec = PREC_EQ; 4666169689Skan ocode = EQ_EXPR; 4667169689Skan break; 4668169689Skan case CPP_NOT_EQ: 4669169689Skan oprec = PREC_EQ; 4670169689Skan ocode = NE_EXPR; 4671169689Skan break; 4672169689Skan case CPP_AND: 4673169689Skan oprec = PREC_BITAND; 4674169689Skan ocode = BIT_AND_EXPR; 4675169689Skan break; 4676169689Skan case CPP_XOR: 4677169689Skan oprec = PREC_BITXOR; 4678169689Skan ocode = BIT_XOR_EXPR; 4679169689Skan break; 4680169689Skan case CPP_OR: 4681169689Skan oprec = PREC_BITOR; 4682169689Skan ocode = BIT_IOR_EXPR; 4683169689Skan break; 4684169689Skan case CPP_AND_AND: 4685169689Skan oprec = PREC_LOGAND; 4686169689Skan ocode = TRUTH_ANDIF_EXPR; 4687169689Skan break; 4688169689Skan case CPP_OR_OR: 4689169689Skan oprec = PREC_LOGOR; 4690169689Skan ocode = TRUTH_ORIF_EXPR; 4691169689Skan break; 4692169689Skan default: 4693169689Skan /* Not a binary operator, so end of the binary 4694169689Skan expression. */ 4695169689Skan goto out; 4696169689Skan } 4697169689Skan c_parser_consume_token (parser); 4698169689Skan while (oprec <= stack[sp].prec) 4699169689Skan POP; 4700169689Skan switch (ocode) 4701169689Skan { 4702169689Skan case TRUTH_ANDIF_EXPR: 4703169689Skan stack[sp].expr 4704169689Skan = default_function_array_conversion (stack[sp].expr); 4705169689Skan stack[sp].expr.value = c_objc_common_truthvalue_conversion 4706169689Skan (default_conversion (stack[sp].expr.value)); 4707169689Skan skip_evaluation += stack[sp].expr.value == truthvalue_false_node; 4708169689Skan break; 4709169689Skan case TRUTH_ORIF_EXPR: 4710169689Skan stack[sp].expr 4711169689Skan = default_function_array_conversion (stack[sp].expr); 4712169689Skan stack[sp].expr.value = c_objc_common_truthvalue_conversion 4713169689Skan (default_conversion (stack[sp].expr.value)); 4714169689Skan skip_evaluation += stack[sp].expr.value == truthvalue_true_node; 4715169689Skan break; 4716169689Skan default: 4717169689Skan break; 4718169689Skan } 4719169689Skan sp++; 4720169689Skan stack[sp].expr = c_parser_cast_expression (parser, NULL); 4721169689Skan stack[sp].prec = oprec; 4722169689Skan stack[sp].op = ocode; 4723169689Skan } 4724169689Skan out: 4725169689Skan while (sp > 0) 4726169689Skan POP; 4727169689Skan return stack[0].expr; 4728169689Skan#undef POP 4729169689Skan} 4730169689Skan 4731169689Skan/* Parse a cast expression (C90 6.3.4, C99 6.5.4). If AFTER is not 4732169689Skan NULL then it is an Objective-C message expression which is the 4733169689Skan primary-expression starting the expression as an initializer. 4734169689Skan 4735169689Skan cast-expression: 4736169689Skan unary-expression 4737169689Skan ( type-name ) unary-expression 4738169689Skan*/ 4739169689Skan 4740169689Skanstatic struct c_expr 4741169689Skanc_parser_cast_expression (c_parser *parser, struct c_expr *after) 4742169689Skan{ 4743169689Skan gcc_assert (!after || c_dialect_objc ()); 4744169689Skan if (after) 4745169689Skan return c_parser_postfix_expression_after_primary (parser, *after); 4746169689Skan /* If the expression begins with a parenthesized type name, it may 4747169689Skan be either a cast or a compound literal; we need to see whether 4748169689Skan the next character is '{' to tell the difference. If not, it is 4749169689Skan an unary expression. */ 4750169689Skan if (c_parser_next_token_is (parser, CPP_OPEN_PAREN) 4751169689Skan && c_token_starts_typename (c_parser_peek_2nd_token (parser))) 4752169689Skan { 4753169689Skan struct c_type_name *type_name; 4754169689Skan struct c_expr ret; 4755169689Skan struct c_expr expr; 4756169689Skan c_parser_consume_token (parser); 4757169689Skan type_name = c_parser_type_name (parser); 4758169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>"); 4759169689Skan if (type_name == NULL) 4760169689Skan { 4761169689Skan ret.value = error_mark_node; 4762169689Skan ret.original_code = ERROR_MARK; 4763169689Skan return ret; 4764169689Skan } 4765169689Skan 4766169689Skan /* Save casted types in the function's used types hash table. */ 4767169689Skan used_types_insert (type_name->specs->type); 4768169689Skan 4769169689Skan if (c_parser_next_token_is (parser, CPP_OPEN_BRACE)) 4770169689Skan return c_parser_postfix_expression_after_paren_type (parser, 4771169689Skan type_name); 4772169689Skan expr = c_parser_cast_expression (parser, NULL); 4773169689Skan expr = default_function_array_conversion (expr); 4774169689Skan ret.value = c_cast_expr (type_name, expr.value); 4775169689Skan ret.original_code = ERROR_MARK; 4776169689Skan return ret; 4777169689Skan } 4778169689Skan else 4779169689Skan return c_parser_unary_expression (parser); 4780169689Skan} 4781169689Skan 4782169689Skan/* Parse an unary expression (C90 6.3.3, C99 6.5.3). 4783169689Skan 4784169689Skan unary-expression: 4785169689Skan postfix-expression 4786169689Skan ++ unary-expression 4787169689Skan -- unary-expression 4788169689Skan unary-operator cast-expression 4789169689Skan sizeof unary-expression 4790169689Skan sizeof ( type-name ) 4791169689Skan 4792169689Skan unary-operator: one of 4793169689Skan & * + - ~ ! 4794169689Skan 4795169689Skan GNU extensions: 4796169689Skan 4797169689Skan unary-expression: 4798169689Skan __alignof__ unary-expression 4799169689Skan __alignof__ ( type-name ) 4800169689Skan && identifier 4801169689Skan 4802169689Skan unary-operator: one of 4803169689Skan __extension__ __real__ __imag__ 4804169689Skan 4805169689Skan In addition, the GNU syntax treats ++ and -- as unary operators, so 4806169689Skan they may be applied to cast expressions with errors for non-lvalues 4807169689Skan given later. */ 4808169689Skan 4809169689Skanstatic struct c_expr 4810169689Skanc_parser_unary_expression (c_parser *parser) 4811169689Skan{ 4812169689Skan int ext; 4813169689Skan struct c_expr ret, op; 4814169689Skan switch (c_parser_peek_token (parser)->type) 4815169689Skan { 4816169689Skan case CPP_PLUS_PLUS: 4817169689Skan c_parser_consume_token (parser); 4818169689Skan op = c_parser_cast_expression (parser, NULL); 4819169689Skan op = default_function_array_conversion (op); 4820169689Skan return parser_build_unary_op (PREINCREMENT_EXPR, op); 4821169689Skan case CPP_MINUS_MINUS: 4822169689Skan c_parser_consume_token (parser); 4823169689Skan op = c_parser_cast_expression (parser, NULL); 4824169689Skan op = default_function_array_conversion (op); 4825169689Skan return parser_build_unary_op (PREDECREMENT_EXPR, op); 4826169689Skan case CPP_AND: 4827169689Skan c_parser_consume_token (parser); 4828169689Skan return parser_build_unary_op (ADDR_EXPR, 4829169689Skan c_parser_cast_expression (parser, NULL)); 4830169689Skan case CPP_MULT: 4831169689Skan c_parser_consume_token (parser); 4832169689Skan op = c_parser_cast_expression (parser, NULL); 4833169689Skan op = default_function_array_conversion (op); 4834169689Skan ret.value = build_indirect_ref (op.value, "unary *"); 4835169689Skan ret.original_code = ERROR_MARK; 4836169689Skan return ret; 4837169689Skan case CPP_PLUS: 4838169689Skan c_parser_consume_token (parser); 4839169689Skan if (!c_dialect_objc () && !in_system_header) 4840169689Skan warning (OPT_Wtraditional, 4841169689Skan "traditional C rejects the unary plus operator"); 4842169689Skan op = c_parser_cast_expression (parser, NULL); 4843169689Skan op = default_function_array_conversion (op); 4844169689Skan return parser_build_unary_op (CONVERT_EXPR, op); 4845169689Skan case CPP_MINUS: 4846169689Skan c_parser_consume_token (parser); 4847169689Skan op = c_parser_cast_expression (parser, NULL); 4848169689Skan op = default_function_array_conversion (op); 4849169689Skan return parser_build_unary_op (NEGATE_EXPR, op); 4850169689Skan case CPP_COMPL: 4851169689Skan c_parser_consume_token (parser); 4852169689Skan op = c_parser_cast_expression (parser, NULL); 4853169689Skan op = default_function_array_conversion (op); 4854169689Skan return parser_build_unary_op (BIT_NOT_EXPR, op); 4855169689Skan case CPP_NOT: 4856169689Skan c_parser_consume_token (parser); 4857169689Skan op = c_parser_cast_expression (parser, NULL); 4858169689Skan op = default_function_array_conversion (op); 4859169689Skan return parser_build_unary_op (TRUTH_NOT_EXPR, op); 4860169689Skan case CPP_AND_AND: 4861169689Skan /* Refer to the address of a label as a pointer. */ 4862169689Skan c_parser_consume_token (parser); 4863169689Skan if (c_parser_next_token_is (parser, CPP_NAME)) 4864169689Skan { 4865169689Skan ret.value = finish_label_address_expr 4866169689Skan (c_parser_peek_token (parser)->value); 4867169689Skan c_parser_consume_token (parser); 4868169689Skan } 4869169689Skan else 4870169689Skan { 4871169689Skan c_parser_error (parser, "expected identifier"); 4872169689Skan ret.value = error_mark_node; 4873169689Skan } 4874169689Skan ret.original_code = ERROR_MARK; 4875169689Skan return ret; 4876169689Skan case CPP_KEYWORD: 4877169689Skan switch (c_parser_peek_token (parser)->keyword) 4878169689Skan { 4879169689Skan case RID_SIZEOF: 4880169689Skan return c_parser_sizeof_expression (parser); 4881169689Skan case RID_ALIGNOF: 4882169689Skan return c_parser_alignof_expression (parser); 4883169689Skan case RID_EXTENSION: 4884169689Skan c_parser_consume_token (parser); 4885169689Skan ext = disable_extension_diagnostics (); 4886169689Skan ret = c_parser_cast_expression (parser, NULL); 4887169689Skan restore_extension_diagnostics (ext); 4888169689Skan return ret; 4889169689Skan case RID_REALPART: 4890169689Skan c_parser_consume_token (parser); 4891169689Skan op = c_parser_cast_expression (parser, NULL); 4892169689Skan op = default_function_array_conversion (op); 4893169689Skan return parser_build_unary_op (REALPART_EXPR, op); 4894169689Skan case RID_IMAGPART: 4895169689Skan c_parser_consume_token (parser); 4896169689Skan op = c_parser_cast_expression (parser, NULL); 4897169689Skan op = default_function_array_conversion (op); 4898169689Skan return parser_build_unary_op (IMAGPART_EXPR, op); 4899169689Skan default: 4900169689Skan return c_parser_postfix_expression (parser); 4901169689Skan } 4902169689Skan default: 4903169689Skan return c_parser_postfix_expression (parser); 4904169689Skan } 4905169689Skan} 4906169689Skan 4907169689Skan/* Parse a sizeof expression. */ 4908169689Skan 4909169689Skanstatic struct c_expr 4910169689Skanc_parser_sizeof_expression (c_parser *parser) 4911169689Skan{ 4912169689Skan struct c_expr expr; 4913169689Skan gcc_assert (c_parser_next_token_is_keyword (parser, RID_SIZEOF)); 4914169689Skan c_parser_consume_token (parser); 4915169689Skan skip_evaluation++; 4916169689Skan in_sizeof++; 4917169689Skan if (c_parser_next_token_is (parser, CPP_OPEN_PAREN) 4918169689Skan && c_token_starts_typename (c_parser_peek_2nd_token (parser))) 4919169689Skan { 4920169689Skan /* Either sizeof ( type-name ) or sizeof unary-expression 4921169689Skan starting with a compound literal. */ 4922169689Skan struct c_type_name *type_name; 4923169689Skan c_parser_consume_token (parser); 4924169689Skan type_name = c_parser_type_name (parser); 4925169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>"); 4926169689Skan if (type_name == NULL) 4927169689Skan { 4928169689Skan struct c_expr ret; 4929169689Skan skip_evaluation--; 4930169689Skan in_sizeof--; 4931169689Skan ret.value = error_mark_node; 4932169689Skan ret.original_code = ERROR_MARK; 4933169689Skan return ret; 4934169689Skan } 4935169689Skan if (c_parser_next_token_is (parser, CPP_OPEN_BRACE)) 4936169689Skan { 4937169689Skan expr = c_parser_postfix_expression_after_paren_type (parser, 4938169689Skan type_name); 4939169689Skan goto sizeof_expr; 4940169689Skan } 4941169689Skan /* sizeof ( type-name ). */ 4942169689Skan skip_evaluation--; 4943169689Skan in_sizeof--; 4944169689Skan if (type_name->declarator->kind == cdk_array 4945169689Skan && type_name->declarator->u.array.vla_unspec_p) 4946169689Skan { 4947169689Skan /* C99 6.7.5.2p4 */ 4948169689Skan error ("%<[*]%> not allowed in other than a declaration"); 4949169689Skan } 4950169689Skan return c_expr_sizeof_type (type_name); 4951169689Skan } 4952169689Skan else 4953169689Skan { 4954169689Skan expr = c_parser_unary_expression (parser); 4955169689Skan sizeof_expr: 4956169689Skan skip_evaluation--; 4957169689Skan in_sizeof--; 4958169689Skan if (TREE_CODE (expr.value) == COMPONENT_REF 4959169689Skan && DECL_C_BIT_FIELD (TREE_OPERAND (expr.value, 1))) 4960169689Skan error ("%<sizeof%> applied to a bit-field"); 4961169689Skan return c_expr_sizeof_expr (expr); 4962169689Skan } 4963169689Skan} 4964169689Skan 4965169689Skan/* Parse an alignof expression. */ 4966169689Skan 4967169689Skanstatic struct c_expr 4968169689Skanc_parser_alignof_expression (c_parser *parser) 4969169689Skan{ 4970169689Skan struct c_expr expr; 4971169689Skan gcc_assert (c_parser_next_token_is_keyword (parser, RID_ALIGNOF)); 4972169689Skan c_parser_consume_token (parser); 4973169689Skan skip_evaluation++; 4974169689Skan in_alignof++; 4975169689Skan if (c_parser_next_token_is (parser, CPP_OPEN_PAREN) 4976169689Skan && c_token_starts_typename (c_parser_peek_2nd_token (parser))) 4977169689Skan { 4978169689Skan /* Either __alignof__ ( type-name ) or __alignof__ 4979169689Skan unary-expression starting with a compound literal. */ 4980169689Skan struct c_type_name *type_name; 4981169689Skan struct c_expr ret; 4982169689Skan c_parser_consume_token (parser); 4983169689Skan type_name = c_parser_type_name (parser); 4984169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>"); 4985169689Skan if (type_name == NULL) 4986169689Skan { 4987169689Skan struct c_expr ret; 4988169689Skan skip_evaluation--; 4989169689Skan in_alignof--; 4990169689Skan ret.value = error_mark_node; 4991169689Skan ret.original_code = ERROR_MARK; 4992169689Skan return ret; 4993169689Skan } 4994169689Skan if (c_parser_next_token_is (parser, CPP_OPEN_BRACE)) 4995169689Skan { 4996169689Skan expr = c_parser_postfix_expression_after_paren_type (parser, 4997169689Skan type_name); 4998169689Skan goto alignof_expr; 4999169689Skan } 5000169689Skan /* alignof ( type-name ). */ 5001169689Skan skip_evaluation--; 5002169689Skan in_alignof--; 5003169689Skan ret.value = c_alignof (groktypename (type_name)); 5004169689Skan ret.original_code = ERROR_MARK; 5005169689Skan return ret; 5006169689Skan } 5007169689Skan else 5008169689Skan { 5009169689Skan struct c_expr ret; 5010169689Skan expr = c_parser_unary_expression (parser); 5011169689Skan alignof_expr: 5012169689Skan skip_evaluation--; 5013169689Skan in_alignof--; 5014169689Skan ret.value = c_alignof_expr (expr.value); 5015169689Skan ret.original_code = ERROR_MARK; 5016169689Skan return ret; 5017169689Skan } 5018169689Skan} 5019169689Skan 5020169689Skan/* Parse a postfix expression (C90 6.3.1-6.3.2, C99 6.5.1-6.5.2). 5021169689Skan 5022169689Skan postfix-expression: 5023169689Skan primary-expression 5024169689Skan postfix-expression [ expression ] 5025169689Skan postfix-expression ( argument-expression-list[opt] ) 5026169689Skan postfix-expression . identifier 5027169689Skan postfix-expression -> identifier 5028169689Skan postfix-expression ++ 5029169689Skan postfix-expression -- 5030169689Skan ( type-name ) { initializer-list } 5031169689Skan ( type-name ) { initializer-list , } 5032169689Skan 5033169689Skan argument-expression-list: 5034169689Skan argument-expression 5035169689Skan argument-expression-list , argument-expression 5036169689Skan 5037169689Skan primary-expression: 5038169689Skan identifier 5039169689Skan constant 5040169689Skan string-literal 5041169689Skan ( expression ) 5042169689Skan 5043169689Skan GNU extensions: 5044169689Skan 5045169689Skan primary-expression: 5046169689Skan __func__ 5047169689Skan (treated as a keyword in GNU C) 5048169689Skan __FUNCTION__ 5049169689Skan __PRETTY_FUNCTION__ 5050169689Skan ( compound-statement ) 5051169689Skan __builtin_va_arg ( assignment-expression , type-name ) 5052169689Skan __builtin_offsetof ( type-name , offsetof-member-designator ) 5053169689Skan __builtin_choose_expr ( assignment-expression , 5054169689Skan assignment-expression , 5055169689Skan assignment-expression ) 5056169689Skan __builtin_types_compatible_p ( type-name , type-name ) 5057169689Skan 5058169689Skan offsetof-member-designator: 5059169689Skan identifier 5060169689Skan offsetof-member-designator . identifier 5061169689Skan offsetof-member-designator [ expression ] 5062169689Skan 5063169689Skan Objective-C: 5064169689Skan 5065169689Skan primary-expression: 5066169689Skan [ objc-receiver objc-message-args ] 5067169689Skan @selector ( objc-selector-arg ) 5068169689Skan @protocol ( identifier ) 5069169689Skan @encode ( type-name ) 5070169689Skan objc-string-literal 5071169689Skan*/ 5072169689Skan 5073169689Skanstatic struct c_expr 5074169689Skanc_parser_postfix_expression (c_parser *parser) 5075169689Skan{ 5076169689Skan struct c_expr expr, e1, e2, e3; 5077169689Skan struct c_type_name *t1, *t2; 5078169689Skan switch (c_parser_peek_token (parser)->type) 5079169689Skan { 5080169689Skan case CPP_NUMBER: 5081169689Skan case CPP_CHAR: 5082169689Skan case CPP_WCHAR: 5083169689Skan expr.value = c_parser_peek_token (parser)->value; 5084169689Skan expr.original_code = ERROR_MARK; 5085169689Skan c_parser_consume_token (parser); 5086169689Skan break; 5087169689Skan case CPP_STRING: 5088169689Skan case CPP_WSTRING: 5089169689Skan expr.value = c_parser_peek_token (parser)->value; 5090169689Skan expr.original_code = STRING_CST; 5091169689Skan c_parser_consume_token (parser); 5092169689Skan break; 5093169689Skan case CPP_OBJC_STRING: 5094169689Skan gcc_assert (c_dialect_objc ()); 5095169689Skan expr.value 5096169689Skan = objc_build_string_object (c_parser_peek_token (parser)->value); 5097169689Skan expr.original_code = ERROR_MARK; 5098169689Skan c_parser_consume_token (parser); 5099169689Skan break; 5100169689Skan case CPP_NAME: 5101169689Skan if (c_parser_peek_token (parser)->id_kind != C_ID_ID) 5102169689Skan { 5103169689Skan c_parser_error (parser, "expected expression"); 5104169689Skan expr.value = error_mark_node; 5105169689Skan expr.original_code = ERROR_MARK; 5106169689Skan break; 5107169689Skan } 5108169689Skan { 5109169689Skan tree id = c_parser_peek_token (parser)->value; 5110169689Skan location_t loc = c_parser_peek_token (parser)->location; 5111169689Skan c_parser_consume_token (parser); 5112169689Skan expr.value = build_external_ref (id, 5113169689Skan (c_parser_peek_token (parser)->type 5114169689Skan == CPP_OPEN_PAREN), loc); 5115169689Skan expr.original_code = ERROR_MARK; 5116169689Skan } 5117169689Skan break; 5118169689Skan case CPP_OPEN_PAREN: 5119169689Skan /* A parenthesized expression, statement expression or compound 5120169689Skan literal. */ 5121169689Skan if (c_parser_peek_2nd_token (parser)->type == CPP_OPEN_BRACE) 5122169689Skan { 5123169689Skan /* A statement expression. */ 5124169689Skan tree stmt; 5125169689Skan c_parser_consume_token (parser); 5126169689Skan c_parser_consume_token (parser); 5127169689Skan if (cur_stmt_list == NULL) 5128169689Skan { 5129169689Skan error ("braced-group within expression allowed " 5130169689Skan "only inside a function"); 5131169689Skan parser->error = true; 5132169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL); 5133169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); 5134169689Skan expr.value = error_mark_node; 5135169689Skan expr.original_code = ERROR_MARK; 5136169689Skan break; 5137169689Skan } 5138169689Skan stmt = c_begin_stmt_expr (); 5139169689Skan c_parser_compound_statement_nostart (parser); 5140169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 5141169689Skan "expected %<)%>"); 5142169689Skan if (pedantic) 5143169689Skan pedwarn ("ISO C forbids braced-groups within expressions"); 5144169689Skan expr.value = c_finish_stmt_expr (stmt); 5145169689Skan expr.original_code = ERROR_MARK; 5146169689Skan } 5147169689Skan else if (c_token_starts_typename (c_parser_peek_2nd_token (parser))) 5148169689Skan { 5149169689Skan /* A compound literal. ??? Can we actually get here rather 5150169689Skan than going directly to 5151169689Skan c_parser_postfix_expression_after_paren_type from 5152169689Skan elsewhere? */ 5153169689Skan struct c_type_name *type_name; 5154169689Skan c_parser_consume_token (parser); 5155169689Skan type_name = c_parser_type_name (parser); 5156169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 5157169689Skan "expected %<)%>"); 5158169689Skan if (type_name == NULL) 5159169689Skan { 5160169689Skan expr.value = error_mark_node; 5161169689Skan expr.original_code = ERROR_MARK; 5162169689Skan } 5163169689Skan else 5164169689Skan expr = c_parser_postfix_expression_after_paren_type (parser, 5165169689Skan type_name); 5166169689Skan } 5167169689Skan else 5168169689Skan { 5169169689Skan /* A parenthesized expression. */ 5170169689Skan c_parser_consume_token (parser); 5171169689Skan expr = c_parser_expression (parser); 5172169689Skan if (TREE_CODE (expr.value) == MODIFY_EXPR) 5173169689Skan TREE_NO_WARNING (expr.value) = 1; 5174169689Skan expr.original_code = ERROR_MARK; 5175169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 5176169689Skan "expected %<)%>"); 5177169689Skan } 5178169689Skan break; 5179169689Skan case CPP_KEYWORD: 5180169689Skan switch (c_parser_peek_token (parser)->keyword) 5181169689Skan { 5182169689Skan case RID_FUNCTION_NAME: 5183169689Skan case RID_PRETTY_FUNCTION_NAME: 5184169689Skan case RID_C99_FUNCTION_NAME: 5185169689Skan expr.value = fname_decl (c_parser_peek_token (parser)->keyword, 5186169689Skan c_parser_peek_token (parser)->value); 5187169689Skan expr.original_code = ERROR_MARK; 5188169689Skan c_parser_consume_token (parser); 5189169689Skan break; 5190169689Skan case RID_VA_ARG: 5191169689Skan c_parser_consume_token (parser); 5192169689Skan if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 5193169689Skan { 5194169689Skan expr.value = error_mark_node; 5195169689Skan expr.original_code = ERROR_MARK; 5196169689Skan break; 5197169689Skan } 5198169689Skan e1 = c_parser_expr_no_commas (parser, NULL); 5199169689Skan if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>")) 5200169689Skan { 5201169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); 5202169689Skan expr.value = error_mark_node; 5203169689Skan expr.original_code = ERROR_MARK; 5204169689Skan break; 5205169689Skan } 5206169689Skan t1 = c_parser_type_name (parser); 5207169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 5208169689Skan "expected %<)%>"); 5209169689Skan if (t1 == NULL) 5210169689Skan { 5211169689Skan expr.value = error_mark_node; 5212169689Skan expr.original_code = ERROR_MARK; 5213169689Skan } 5214169689Skan else 5215169689Skan { 5216169689Skan expr.value = build_va_arg (e1.value, groktypename (t1)); 5217169689Skan expr.original_code = ERROR_MARK; 5218169689Skan } 5219169689Skan break; 5220169689Skan case RID_OFFSETOF: 5221169689Skan c_parser_consume_token (parser); 5222169689Skan if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 5223169689Skan { 5224169689Skan expr.value = error_mark_node; 5225169689Skan expr.original_code = ERROR_MARK; 5226169689Skan break; 5227169689Skan } 5228169689Skan t1 = c_parser_type_name (parser); 5229169689Skan if (t1 == NULL) 5230169689Skan { 5231169689Skan expr.value = error_mark_node; 5232169689Skan expr.original_code = ERROR_MARK; 5233169689Skan break; 5234169689Skan } 5235169689Skan if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>")) 5236169689Skan { 5237169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); 5238169689Skan expr.value = error_mark_node; 5239169689Skan expr.original_code = ERROR_MARK; 5240169689Skan break; 5241169689Skan } 5242169689Skan { 5243169689Skan tree type = groktypename (t1); 5244169689Skan tree offsetof_ref; 5245169689Skan if (type == error_mark_node) 5246169689Skan offsetof_ref = error_mark_node; 5247169689Skan else 5248169689Skan offsetof_ref = build1 (INDIRECT_REF, type, null_pointer_node); 5249169689Skan /* Parse the second argument to __builtin_offsetof. We 5250169689Skan must have one identifier, and beyond that we want to 5251169689Skan accept sub structure and sub array references. */ 5252169689Skan if (c_parser_next_token_is (parser, CPP_NAME)) 5253169689Skan { 5254169689Skan offsetof_ref = build_component_ref 5255169689Skan (offsetof_ref, c_parser_peek_token (parser)->value); 5256169689Skan c_parser_consume_token (parser); 5257169689Skan while (c_parser_next_token_is (parser, CPP_DOT) 5258169689Skan || c_parser_next_token_is (parser, 5259169689Skan CPP_OPEN_SQUARE)) 5260169689Skan { 5261169689Skan if (c_parser_next_token_is (parser, CPP_DOT)) 5262169689Skan { 5263169689Skan c_parser_consume_token (parser); 5264169689Skan if (c_parser_next_token_is_not (parser, 5265169689Skan CPP_NAME)) 5266169689Skan { 5267169689Skan c_parser_error (parser, "expected identifier"); 5268169689Skan break; 5269169689Skan } 5270169689Skan offsetof_ref = build_component_ref 5271169689Skan (offsetof_ref, 5272169689Skan c_parser_peek_token (parser)->value); 5273169689Skan c_parser_consume_token (parser); 5274169689Skan } 5275169689Skan else 5276169689Skan { 5277169689Skan tree idx; 5278169689Skan c_parser_consume_token (parser); 5279169689Skan idx = c_parser_expression (parser).value; 5280169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, 5281169689Skan "expected %<]%>"); 5282169689Skan offsetof_ref = build_array_ref (offsetof_ref, idx); 5283169689Skan } 5284169689Skan } 5285169689Skan } 5286169689Skan else 5287169689Skan c_parser_error (parser, "expected identifier"); 5288169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 5289169689Skan "expected %<)%>"); 5290169689Skan expr.value = fold_offsetof (offsetof_ref, NULL_TREE); 5291169689Skan expr.original_code = ERROR_MARK; 5292169689Skan } 5293169689Skan break; 5294169689Skan case RID_CHOOSE_EXPR: 5295169689Skan c_parser_consume_token (parser); 5296169689Skan if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 5297169689Skan { 5298169689Skan expr.value = error_mark_node; 5299169689Skan expr.original_code = ERROR_MARK; 5300169689Skan break; 5301169689Skan } 5302169689Skan e1 = c_parser_expr_no_commas (parser, NULL); 5303169689Skan if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>")) 5304169689Skan { 5305169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); 5306169689Skan expr.value = error_mark_node; 5307169689Skan expr.original_code = ERROR_MARK; 5308169689Skan break; 5309169689Skan } 5310169689Skan e2 = c_parser_expr_no_commas (parser, NULL); 5311169689Skan if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>")) 5312169689Skan { 5313169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); 5314169689Skan expr.value = error_mark_node; 5315169689Skan expr.original_code = ERROR_MARK; 5316169689Skan break; 5317169689Skan } 5318169689Skan e3 = c_parser_expr_no_commas (parser, NULL); 5319169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 5320169689Skan "expected %<)%>"); 5321169689Skan { 5322169689Skan tree c; 5323169689Skan 5324169689Skan c = fold (e1.value); 5325169689Skan if (TREE_CODE (c) != INTEGER_CST) 5326169689Skan error ("first argument to %<__builtin_choose_expr%> not" 5327169689Skan " a constant"); 5328169689Skan expr = integer_zerop (c) ? e3 : e2; 5329169689Skan } 5330169689Skan break; 5331169689Skan case RID_TYPES_COMPATIBLE_P: 5332169689Skan c_parser_consume_token (parser); 5333169689Skan if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 5334169689Skan { 5335169689Skan expr.value = error_mark_node; 5336169689Skan expr.original_code = ERROR_MARK; 5337169689Skan break; 5338169689Skan } 5339169689Skan t1 = c_parser_type_name (parser); 5340169689Skan if (t1 == NULL) 5341169689Skan { 5342169689Skan expr.value = error_mark_node; 5343169689Skan expr.original_code = ERROR_MARK; 5344169689Skan break; 5345169689Skan } 5346169689Skan if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>")) 5347169689Skan { 5348169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); 5349169689Skan expr.value = error_mark_node; 5350169689Skan expr.original_code = ERROR_MARK; 5351169689Skan break; 5352169689Skan } 5353169689Skan t2 = c_parser_type_name (parser); 5354169689Skan if (t2 == NULL) 5355169689Skan { 5356169689Skan expr.value = error_mark_node; 5357169689Skan expr.original_code = ERROR_MARK; 5358169689Skan break; 5359169689Skan } 5360169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 5361169689Skan "expected %<)%>"); 5362169689Skan { 5363169689Skan tree e1, e2; 5364169689Skan 5365169689Skan e1 = TYPE_MAIN_VARIANT (groktypename (t1)); 5366169689Skan e2 = TYPE_MAIN_VARIANT (groktypename (t2)); 5367169689Skan 5368169689Skan expr.value = comptypes (e1, e2) 5369169689Skan ? build_int_cst (NULL_TREE, 1) 5370169689Skan : build_int_cst (NULL_TREE, 0); 5371169689Skan expr.original_code = ERROR_MARK; 5372169689Skan } 5373169689Skan break; 5374169689Skan case RID_AT_SELECTOR: 5375169689Skan gcc_assert (c_dialect_objc ()); 5376169689Skan c_parser_consume_token (parser); 5377169689Skan if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 5378169689Skan { 5379169689Skan expr.value = error_mark_node; 5380169689Skan expr.original_code = ERROR_MARK; 5381169689Skan break; 5382169689Skan } 5383169689Skan { 5384169689Skan tree sel = c_parser_objc_selector_arg (parser); 5385169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 5386169689Skan "expected %<)%>"); 5387169689Skan expr.value = objc_build_selector_expr (sel); 5388169689Skan expr.original_code = ERROR_MARK; 5389169689Skan } 5390169689Skan break; 5391169689Skan case RID_AT_PROTOCOL: 5392169689Skan gcc_assert (c_dialect_objc ()); 5393169689Skan c_parser_consume_token (parser); 5394169689Skan if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 5395169689Skan { 5396169689Skan expr.value = error_mark_node; 5397169689Skan expr.original_code = ERROR_MARK; 5398169689Skan break; 5399169689Skan } 5400169689Skan if (c_parser_next_token_is_not (parser, CPP_NAME)) 5401169689Skan { 5402169689Skan c_parser_error (parser, "expected identifier"); 5403169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); 5404169689Skan expr.value = error_mark_node; 5405169689Skan expr.original_code = ERROR_MARK; 5406169689Skan break; 5407169689Skan } 5408169689Skan { 5409169689Skan tree id = c_parser_peek_token (parser)->value; 5410169689Skan c_parser_consume_token (parser); 5411169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 5412169689Skan "expected %<)%>"); 5413169689Skan expr.value = objc_build_protocol_expr (id); 5414169689Skan expr.original_code = ERROR_MARK; 5415169689Skan } 5416169689Skan break; 5417169689Skan case RID_AT_ENCODE: 5418169689Skan /* Extension to support C-structures in the archiver. */ 5419169689Skan gcc_assert (c_dialect_objc ()); 5420169689Skan c_parser_consume_token (parser); 5421169689Skan if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 5422169689Skan { 5423169689Skan expr.value = error_mark_node; 5424169689Skan expr.original_code = ERROR_MARK; 5425169689Skan break; 5426169689Skan } 5427169689Skan t1 = c_parser_type_name (parser); 5428169689Skan if (t1 == NULL) 5429169689Skan { 5430169689Skan expr.value = error_mark_node; 5431169689Skan expr.original_code = ERROR_MARK; 5432169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); 5433169689Skan break; 5434169689Skan } 5435169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 5436169689Skan "expected %<)%>"); 5437169689Skan { 5438169689Skan tree type = groktypename (t1); 5439169689Skan expr.value = objc_build_encode_expr (type); 5440169689Skan expr.original_code = ERROR_MARK; 5441169689Skan } 5442169689Skan break; 5443169689Skan default: 5444169689Skan c_parser_error (parser, "expected expression"); 5445169689Skan expr.value = error_mark_node; 5446169689Skan expr.original_code = ERROR_MARK; 5447169689Skan break; 5448169689Skan } 5449169689Skan break; 5450169689Skan case CPP_OPEN_SQUARE: 5451169689Skan if (c_dialect_objc ()) 5452169689Skan { 5453169689Skan tree receiver, args; 5454169689Skan c_parser_consume_token (parser); 5455169689Skan receiver = c_parser_objc_receiver (parser); 5456169689Skan args = c_parser_objc_message_args (parser); 5457169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, 5458169689Skan "expected %<]%>"); 5459169689Skan expr.value = objc_build_message_expr (build_tree_list (receiver, 5460169689Skan args)); 5461169689Skan expr.original_code = ERROR_MARK; 5462169689Skan break; 5463169689Skan } 5464169689Skan /* Else fall through to report error. */ 5465169689Skan default: 5466169689Skan c_parser_error (parser, "expected expression"); 5467169689Skan expr.value = error_mark_node; 5468169689Skan expr.original_code = ERROR_MARK; 5469169689Skan break; 5470169689Skan } 5471169689Skan return c_parser_postfix_expression_after_primary (parser, expr); 5472169689Skan} 5473169689Skan 5474169689Skan/* Parse a postfix expression after a parenthesized type name: the 5475169689Skan brace-enclosed initializer of a compound literal, possibly followed 5476169689Skan by some postfix operators. This is separate because it is not 5477169689Skan possible to tell until after the type name whether a cast 5478169689Skan expression has a cast or a compound literal, or whether the operand 5479169689Skan of sizeof is a parenthesized type name or starts with a compound 5480169689Skan literal. */ 5481169689Skan 5482169689Skanstatic struct c_expr 5483169689Skanc_parser_postfix_expression_after_paren_type (c_parser *parser, 5484169689Skan struct c_type_name *type_name) 5485169689Skan{ 5486169689Skan tree type; 5487169689Skan struct c_expr init; 5488169689Skan struct c_expr expr; 5489169689Skan start_init (NULL_TREE, NULL, 0); 5490169689Skan type = groktypename (type_name); 5491169689Skan if (type != error_mark_node && C_TYPE_VARIABLE_SIZE (type)) 5492169689Skan { 5493169689Skan error ("compound literal has variable size"); 5494169689Skan type = error_mark_node; 5495169689Skan } 5496169689Skan init = c_parser_braced_init (parser, type, false); 5497169689Skan finish_init (); 5498169689Skan maybe_warn_string_init (type, init); 5499169689Skan 5500169689Skan if (pedantic && !flag_isoc99) 5501169689Skan pedwarn ("ISO C90 forbids compound literals"); 5502169689Skan expr.value = build_compound_literal (type, init.value); 5503169689Skan expr.original_code = ERROR_MARK; 5504169689Skan return c_parser_postfix_expression_after_primary (parser, expr); 5505169689Skan} 5506169689Skan 5507169689Skan/* Parse a postfix expression after the initial primary or compound 5508169689Skan literal; that is, parse a series of postfix operators. */ 5509169689Skan 5510169689Skanstatic struct c_expr 5511169689Skanc_parser_postfix_expression_after_primary (c_parser *parser, 5512169689Skan struct c_expr expr) 5513169689Skan{ 5514169689Skan tree ident, idx, exprlist; 5515169689Skan while (true) 5516169689Skan { 5517169689Skan switch (c_parser_peek_token (parser)->type) 5518169689Skan { 5519169689Skan case CPP_OPEN_SQUARE: 5520169689Skan /* Array reference. */ 5521169689Skan c_parser_consume_token (parser); 5522169689Skan idx = c_parser_expression (parser).value; 5523169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, 5524169689Skan "expected %<]%>"); 5525169689Skan expr.value = build_array_ref (expr.value, idx); 5526169689Skan expr.original_code = ERROR_MARK; 5527169689Skan break; 5528169689Skan case CPP_OPEN_PAREN: 5529169689Skan /* Function call. */ 5530169689Skan c_parser_consume_token (parser); 5531169689Skan if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) 5532169689Skan exprlist = NULL_TREE; 5533169689Skan else 5534169689Skan exprlist = c_parser_expr_list (parser, true); 5535169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 5536169689Skan "expected %<)%>"); 5537169689Skan expr.value = build_function_call (expr.value, exprlist); 5538169689Skan expr.original_code = ERROR_MARK; 5539169689Skan break; 5540169689Skan case CPP_DOT: 5541169689Skan /* Structure element reference. */ 5542169689Skan c_parser_consume_token (parser); 5543169689Skan expr = default_function_array_conversion (expr); 5544169689Skan if (c_parser_next_token_is (parser, CPP_NAME)) 5545169689Skan ident = c_parser_peek_token (parser)->value; 5546169689Skan else 5547169689Skan { 5548169689Skan c_parser_error (parser, "expected identifier"); 5549169689Skan expr.value = error_mark_node; 5550169689Skan expr.original_code = ERROR_MARK; 5551169689Skan return expr; 5552169689Skan } 5553169689Skan c_parser_consume_token (parser); 5554169689Skan expr.value = build_component_ref (expr.value, ident); 5555169689Skan expr.original_code = ERROR_MARK; 5556169689Skan break; 5557169689Skan case CPP_DEREF: 5558169689Skan /* Structure element reference. */ 5559169689Skan c_parser_consume_token (parser); 5560169689Skan expr = default_function_array_conversion (expr); 5561169689Skan if (c_parser_next_token_is (parser, CPP_NAME)) 5562169689Skan ident = c_parser_peek_token (parser)->value; 5563169689Skan else 5564169689Skan { 5565169689Skan c_parser_error (parser, "expected identifier"); 5566169689Skan expr.value = error_mark_node; 5567169689Skan expr.original_code = ERROR_MARK; 5568169689Skan return expr; 5569169689Skan } 5570169689Skan c_parser_consume_token (parser); 5571169689Skan expr.value = build_component_ref (build_indirect_ref (expr.value, 5572169689Skan "->"), ident); 5573169689Skan expr.original_code = ERROR_MARK; 5574169689Skan break; 5575169689Skan case CPP_PLUS_PLUS: 5576169689Skan /* Postincrement. */ 5577169689Skan c_parser_consume_token (parser); 5578169689Skan expr = default_function_array_conversion (expr); 5579169689Skan expr.value = build_unary_op (POSTINCREMENT_EXPR, expr.value, 0); 5580169689Skan expr.original_code = ERROR_MARK; 5581169689Skan break; 5582169689Skan case CPP_MINUS_MINUS: 5583169689Skan /* Postdecrement. */ 5584169689Skan c_parser_consume_token (parser); 5585169689Skan expr = default_function_array_conversion (expr); 5586169689Skan expr.value = build_unary_op (POSTDECREMENT_EXPR, expr.value, 0); 5587169689Skan expr.original_code = ERROR_MARK; 5588169689Skan break; 5589169689Skan default: 5590169689Skan return expr; 5591169689Skan } 5592169689Skan } 5593169689Skan} 5594169689Skan 5595169689Skan/* Parse an expression (C90 6.3.17, C99 6.5.17). 5596169689Skan 5597169689Skan expression: 5598169689Skan assignment-expression 5599169689Skan expression , assignment-expression 5600169689Skan*/ 5601169689Skan 5602169689Skanstatic struct c_expr 5603169689Skanc_parser_expression (c_parser *parser) 5604169689Skan{ 5605169689Skan struct c_expr expr; 5606169689Skan expr = c_parser_expr_no_commas (parser, NULL); 5607169689Skan while (c_parser_next_token_is (parser, CPP_COMMA)) 5608169689Skan { 5609169689Skan struct c_expr next; 5610169689Skan c_parser_consume_token (parser); 5611169689Skan next = c_parser_expr_no_commas (parser, NULL); 5612169689Skan next = default_function_array_conversion (next); 5613169689Skan expr.value = build_compound_expr (expr.value, next.value); 5614169689Skan expr.original_code = COMPOUND_EXPR; 5615169689Skan } 5616169689Skan return expr; 5617169689Skan} 5618169689Skan 5619169689Skan/* Parse an expression and convert functions or arrays to 5620169689Skan pointers. */ 5621169689Skan 5622169689Skanstatic struct c_expr 5623169689Skanc_parser_expression_conv (c_parser *parser) 5624169689Skan{ 5625169689Skan struct c_expr expr; 5626169689Skan expr = c_parser_expression (parser); 5627169689Skan expr = default_function_array_conversion (expr); 5628169689Skan return expr; 5629169689Skan} 5630169689Skan 5631169689Skan/* Parse a non-empty list of expressions. If CONVERT_P, convert 5632169689Skan functions and arrays to pointers. 5633169689Skan 5634169689Skan nonempty-expr-list: 5635169689Skan assignment-expression 5636169689Skan nonempty-expr-list , assignment-expression 5637169689Skan*/ 5638169689Skan 5639169689Skanstatic tree 5640169689Skanc_parser_expr_list (c_parser *parser, bool convert_p) 5641169689Skan{ 5642169689Skan struct c_expr expr; 5643169689Skan tree ret, cur; 5644169689Skan expr = c_parser_expr_no_commas (parser, NULL); 5645169689Skan if (convert_p) 5646169689Skan expr = default_function_array_conversion (expr); 5647169689Skan ret = cur = build_tree_list (NULL_TREE, expr.value); 5648169689Skan while (c_parser_next_token_is (parser, CPP_COMMA)) 5649169689Skan { 5650169689Skan c_parser_consume_token (parser); 5651169689Skan expr = c_parser_expr_no_commas (parser, NULL); 5652169689Skan if (convert_p) 5653169689Skan expr = default_function_array_conversion (expr); 5654169689Skan cur = TREE_CHAIN (cur) = build_tree_list (NULL_TREE, expr.value); 5655169689Skan } 5656169689Skan return ret; 5657169689Skan} 5658169689Skan 5659169689Skan 5660169689Skan/* Parse Objective-C-specific constructs. */ 5661169689Skan 5662169689Skan/* Parse an objc-class-definition. 5663169689Skan 5664169689Skan objc-class-definition: 5665169689Skan @interface identifier objc-superclass[opt] objc-protocol-refs[opt] 5666169689Skan objc-class-instance-variables[opt] objc-methodprotolist @end 5667169689Skan @implementation identifier objc-superclass[opt] 5668169689Skan objc-class-instance-variables[opt] 5669169689Skan @interface identifier ( identifier ) objc-protocol-refs[opt] 5670169689Skan objc-methodprotolist @end 5671169689Skan @implementation identifier ( identifier ) 5672169689Skan 5673169689Skan objc-superclass: 5674169689Skan : identifier 5675169689Skan 5676169689Skan "@interface identifier (" must start "@interface identifier ( 5677169689Skan identifier ) ...": objc-methodprotolist in the first production may 5678169689Skan not start with a parenthesized identifier as a declarator of a data 5679169689Skan definition with no declaration specifiers if the objc-superclass, 5680169689Skan objc-protocol-refs and objc-class-instance-variables are omitted. */ 5681169689Skan 5682169689Skanstatic void 5683169689Skanc_parser_objc_class_definition (c_parser *parser) 5684169689Skan{ 5685169689Skan bool iface_p; 5686169689Skan tree id1; 5687169689Skan tree superclass; 5688169689Skan if (c_parser_next_token_is_keyword (parser, RID_AT_INTERFACE)) 5689169689Skan iface_p = true; 5690169689Skan else if (c_parser_next_token_is_keyword (parser, RID_AT_IMPLEMENTATION)) 5691169689Skan iface_p = false; 5692169689Skan else 5693169689Skan gcc_unreachable (); 5694169689Skan c_parser_consume_token (parser); 5695169689Skan if (c_parser_next_token_is_not (parser, CPP_NAME)) 5696169689Skan { 5697169689Skan c_parser_error (parser, "expected identifier"); 5698169689Skan return; 5699169689Skan } 5700169689Skan id1 = c_parser_peek_token (parser)->value; 5701169689Skan c_parser_consume_token (parser); 5702169689Skan if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)) 5703169689Skan { 5704169689Skan tree id2; 5705169689Skan tree proto = NULL_TREE; 5706169689Skan c_parser_consume_token (parser); 5707169689Skan if (c_parser_next_token_is_not (parser, CPP_NAME)) 5708169689Skan { 5709169689Skan c_parser_error (parser, "expected identifier"); 5710169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); 5711169689Skan return; 5712169689Skan } 5713169689Skan id2 = c_parser_peek_token (parser)->value; 5714169689Skan c_parser_consume_token (parser); 5715169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>"); 5716169689Skan if (!iface_p) 5717169689Skan { 5718169689Skan objc_start_category_implementation (id1, id2); 5719169689Skan return; 5720169689Skan } 5721169689Skan if (c_parser_next_token_is (parser, CPP_LESS)) 5722169689Skan proto = c_parser_objc_protocol_refs (parser); 5723169689Skan objc_start_category_interface (id1, id2, proto); 5724169689Skan c_parser_objc_methodprotolist (parser); 5725169689Skan c_parser_require_keyword (parser, RID_AT_END, "expected %<@end%>"); 5726169689Skan objc_finish_interface (); 5727169689Skan return; 5728169689Skan } 5729169689Skan if (c_parser_next_token_is (parser, CPP_COLON)) 5730169689Skan { 5731169689Skan c_parser_consume_token (parser); 5732169689Skan if (c_parser_next_token_is_not (parser, CPP_NAME)) 5733169689Skan { 5734169689Skan c_parser_error (parser, "expected identifier"); 5735169689Skan return; 5736169689Skan } 5737169689Skan superclass = c_parser_peek_token (parser)->value; 5738169689Skan c_parser_consume_token (parser); 5739169689Skan } 5740169689Skan else 5741169689Skan superclass = NULL_TREE; 5742169689Skan if (iface_p) 5743169689Skan { 5744169689Skan tree proto = NULL_TREE; 5745169689Skan if (c_parser_next_token_is (parser, CPP_LESS)) 5746169689Skan proto = c_parser_objc_protocol_refs (parser); 5747169689Skan objc_start_class_interface (id1, superclass, proto); 5748169689Skan } 5749169689Skan else 5750169689Skan objc_start_class_implementation (id1, superclass); 5751169689Skan if (c_parser_next_token_is (parser, CPP_OPEN_BRACE)) 5752169689Skan c_parser_objc_class_instance_variables (parser); 5753169689Skan if (iface_p) 5754169689Skan { 5755169689Skan objc_continue_interface (); 5756169689Skan c_parser_objc_methodprotolist (parser); 5757169689Skan c_parser_require_keyword (parser, RID_AT_END, "expected %<@end%>"); 5758169689Skan objc_finish_interface (); 5759169689Skan } 5760169689Skan else 5761169689Skan { 5762169689Skan objc_continue_implementation (); 5763169689Skan return; 5764169689Skan } 5765169689Skan} 5766169689Skan 5767169689Skan/* Parse objc-class-instance-variables. 5768169689Skan 5769169689Skan objc-class-instance-variables: 5770169689Skan { objc-instance-variable-decl-list[opt] } 5771169689Skan 5772169689Skan objc-instance-variable-decl-list: 5773169689Skan objc-visibility-spec 5774169689Skan objc-instance-variable-decl ; 5775169689Skan ; 5776169689Skan objc-instance-variable-decl-list objc-visibility-spec 5777169689Skan objc-instance-variable-decl-list objc-instance-variable-decl ; 5778169689Skan objc-instance-variable-decl-list ; 5779169689Skan 5780169689Skan objc-visibility-spec: 5781169689Skan @private 5782169689Skan @protected 5783169689Skan @public 5784169689Skan 5785169689Skan objc-instance-variable-decl: 5786169689Skan struct-declaration 5787169689Skan*/ 5788169689Skan 5789169689Skanstatic void 5790169689Skanc_parser_objc_class_instance_variables (c_parser *parser) 5791169689Skan{ 5792169689Skan gcc_assert (c_parser_next_token_is (parser, CPP_OPEN_BRACE)); 5793169689Skan c_parser_consume_token (parser); 5794169689Skan while (c_parser_next_token_is_not (parser, CPP_EOF)) 5795169689Skan { 5796169689Skan tree decls; 5797169689Skan /* Parse any stray semicolon. */ 5798169689Skan if (c_parser_next_token_is (parser, CPP_SEMICOLON)) 5799169689Skan { 5800169689Skan if (pedantic) 5801169689Skan pedwarn ("extra semicolon in struct or union specified"); 5802169689Skan c_parser_consume_token (parser); 5803169689Skan continue; 5804169689Skan } 5805169689Skan /* Stop if at the end of the instance variables. */ 5806169689Skan if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE)) 5807169689Skan { 5808169689Skan c_parser_consume_token (parser); 5809169689Skan break; 5810169689Skan } 5811169689Skan /* Parse any objc-visibility-spec. */ 5812169689Skan if (c_parser_next_token_is_keyword (parser, RID_AT_PRIVATE)) 5813169689Skan { 5814169689Skan c_parser_consume_token (parser); 5815169689Skan objc_set_visibility (2); 5816169689Skan continue; 5817169689Skan } 5818169689Skan else if (c_parser_next_token_is_keyword (parser, RID_AT_PROTECTED)) 5819169689Skan { 5820169689Skan c_parser_consume_token (parser); 5821169689Skan objc_set_visibility (0); 5822169689Skan continue; 5823169689Skan } 5824169689Skan else if (c_parser_next_token_is_keyword (parser, RID_AT_PUBLIC)) 5825169689Skan { 5826169689Skan c_parser_consume_token (parser); 5827169689Skan objc_set_visibility (1); 5828169689Skan continue; 5829169689Skan } 5830169689Skan else if (c_parser_next_token_is (parser, CPP_PRAGMA)) 5831169689Skan { 5832169689Skan c_parser_pragma (parser, pragma_external); 5833169689Skan continue; 5834169689Skan } 5835169689Skan 5836169689Skan /* Parse some comma-separated declarations. */ 5837169689Skan decls = c_parser_struct_declaration (parser); 5838169689Skan { 5839169689Skan /* Comma-separated instance variables are chained together in 5840169689Skan reverse order; add them one by one. */ 5841169689Skan tree ivar = nreverse (decls); 5842169689Skan for (; ivar; ivar = TREE_CHAIN (ivar)) 5843169689Skan objc_add_instance_variable (copy_node (ivar)); 5844169689Skan } 5845169689Skan c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>"); 5846169689Skan } 5847169689Skan} 5848169689Skan 5849169689Skan/* Parse an objc-class-declaration. 5850169689Skan 5851169689Skan objc-class-declaration: 5852169689Skan @class identifier-list ; 5853169689Skan*/ 5854169689Skan 5855169689Skanstatic void 5856169689Skanc_parser_objc_class_declaration (c_parser *parser) 5857169689Skan{ 5858169689Skan tree list = NULL_TREE; 5859169689Skan gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_CLASS)); 5860169689Skan c_parser_consume_token (parser); 5861169689Skan /* Any identifiers, including those declared as type names, are OK 5862169689Skan here. */ 5863169689Skan while (true) 5864169689Skan { 5865169689Skan tree id; 5866169689Skan if (c_parser_next_token_is_not (parser, CPP_NAME)) 5867169689Skan { 5868169689Skan c_parser_error (parser, "expected identifier"); 5869169689Skan break; 5870169689Skan } 5871169689Skan id = c_parser_peek_token (parser)->value; 5872169689Skan list = chainon (list, build_tree_list (NULL_TREE, id)); 5873169689Skan c_parser_consume_token (parser); 5874169689Skan if (c_parser_next_token_is (parser, CPP_COMMA)) 5875169689Skan c_parser_consume_token (parser); 5876169689Skan else 5877169689Skan break; 5878169689Skan } 5879169689Skan c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>"); 5880169689Skan objc_declare_class (list); 5881169689Skan} 5882169689Skan 5883169689Skan/* Parse an objc-alias-declaration. 5884169689Skan 5885169689Skan objc-alias-declaration: 5886169689Skan @compatibility_alias identifier identifier ; 5887169689Skan*/ 5888169689Skan 5889169689Skanstatic void 5890169689Skanc_parser_objc_alias_declaration (c_parser *parser) 5891169689Skan{ 5892169689Skan tree id1, id2; 5893169689Skan gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_ALIAS)); 5894169689Skan c_parser_consume_token (parser); 5895169689Skan if (c_parser_next_token_is_not (parser, CPP_NAME)) 5896169689Skan { 5897169689Skan c_parser_error (parser, "expected identifier"); 5898169689Skan c_parser_skip_until_found (parser, CPP_SEMICOLON, NULL); 5899169689Skan return; 5900169689Skan } 5901169689Skan id1 = c_parser_peek_token (parser)->value; 5902169689Skan c_parser_consume_token (parser); 5903169689Skan if (c_parser_next_token_is_not (parser, CPP_NAME)) 5904169689Skan { 5905169689Skan c_parser_error (parser, "expected identifier"); 5906169689Skan c_parser_skip_until_found (parser, CPP_SEMICOLON, NULL); 5907169689Skan return; 5908169689Skan } 5909169689Skan id2 = c_parser_peek_token (parser)->value; 5910169689Skan c_parser_consume_token (parser); 5911169689Skan c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>"); 5912169689Skan objc_declare_alias (id1, id2); 5913169689Skan} 5914169689Skan 5915169689Skan/* Parse an objc-protocol-definition. 5916169689Skan 5917169689Skan objc-protocol-definition: 5918169689Skan @protocol identifier objc-protocol-refs[opt] objc-methodprotolist @end 5919169689Skan @protocol identifier-list ; 5920169689Skan 5921169689Skan "@protocol identifier ;" should be resolved as "@protocol 5922169689Skan identifier-list ;": objc-methodprotolist may not start with a 5923169689Skan semicolon in the first alternative if objc-protocol-refs are 5924169689Skan omitted. */ 5925169689Skan 5926169689Skanstatic void 5927169689Skanc_parser_objc_protocol_definition (c_parser *parser) 5928169689Skan{ 5929169689Skan gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_PROTOCOL)); 5930169689Skan c_parser_consume_token (parser); 5931169689Skan if (c_parser_next_token_is_not (parser, CPP_NAME)) 5932169689Skan { 5933169689Skan c_parser_error (parser, "expected identifier"); 5934169689Skan return; 5935169689Skan } 5936169689Skan if (c_parser_peek_2nd_token (parser)->type == CPP_COMMA 5937169689Skan || c_parser_peek_2nd_token (parser)->type == CPP_SEMICOLON) 5938169689Skan { 5939169689Skan tree list = NULL_TREE; 5940169689Skan /* Any identifiers, including those declared as type names, are 5941169689Skan OK here. */ 5942169689Skan while (true) 5943169689Skan { 5944169689Skan tree id; 5945169689Skan if (c_parser_next_token_is_not (parser, CPP_NAME)) 5946169689Skan { 5947169689Skan c_parser_error (parser, "expected identifier"); 5948169689Skan break; 5949169689Skan } 5950169689Skan id = c_parser_peek_token (parser)->value; 5951169689Skan list = chainon (list, build_tree_list (NULL_TREE, id)); 5952169689Skan c_parser_consume_token (parser); 5953169689Skan if (c_parser_next_token_is (parser, CPP_COMMA)) 5954169689Skan c_parser_consume_token (parser); 5955169689Skan else 5956169689Skan break; 5957169689Skan } 5958169689Skan c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>"); 5959169689Skan objc_declare_protocols (list); 5960169689Skan } 5961169689Skan else 5962169689Skan { 5963169689Skan tree id = c_parser_peek_token (parser)->value; 5964169689Skan tree proto = NULL_TREE; 5965169689Skan c_parser_consume_token (parser); 5966169689Skan if (c_parser_next_token_is (parser, CPP_LESS)) 5967169689Skan proto = c_parser_objc_protocol_refs (parser); 5968169689Skan objc_pq_context = 1; 5969169689Skan objc_start_protocol (id, proto); 5970169689Skan c_parser_objc_methodprotolist (parser); 5971169689Skan c_parser_require_keyword (parser, RID_AT_END, "expected %<@end%>"); 5972169689Skan objc_pq_context = 0; 5973169689Skan objc_finish_interface (); 5974169689Skan } 5975169689Skan} 5976169689Skan 5977169689Skan/* Parse an objc-method-type. 5978169689Skan 5979169689Skan objc-method-type: 5980169689Skan + 5981169689Skan - 5982169689Skan*/ 5983169689Skan 5984169689Skanstatic enum tree_code 5985169689Skanc_parser_objc_method_type (c_parser *parser) 5986169689Skan{ 5987169689Skan switch (c_parser_peek_token (parser)->type) 5988169689Skan { 5989169689Skan case CPP_PLUS: 5990169689Skan c_parser_consume_token (parser); 5991169689Skan return PLUS_EXPR; 5992169689Skan case CPP_MINUS: 5993169689Skan c_parser_consume_token (parser); 5994169689Skan return MINUS_EXPR; 5995169689Skan default: 5996169689Skan gcc_unreachable (); 5997169689Skan } 5998169689Skan} 5999169689Skan 6000169689Skan/* Parse an objc-method-definition. 6001169689Skan 6002169689Skan objc-method-definition: 6003169689Skan objc-method-type objc-method-decl ;[opt] compound-statement 6004169689Skan*/ 6005169689Skan 6006169689Skanstatic void 6007169689Skanc_parser_objc_method_definition (c_parser *parser) 6008169689Skan{ 6009169689Skan enum tree_code type = c_parser_objc_method_type (parser); 6010169689Skan tree decl; 6011169689Skan objc_set_method_type (type); 6012169689Skan objc_pq_context = 1; 6013169689Skan decl = c_parser_objc_method_decl (parser); 6014169689Skan if (c_parser_next_token_is (parser, CPP_SEMICOLON)) 6015169689Skan { 6016169689Skan c_parser_consume_token (parser); 6017169689Skan if (pedantic) 6018169689Skan pedwarn ("extra semicolon in method definition specified"); 6019169689Skan } 6020169689Skan if (!c_parser_next_token_is (parser, CPP_OPEN_BRACE)) 6021169689Skan { 6022169689Skan c_parser_error (parser, "expected %<{%>"); 6023169689Skan return; 6024169689Skan } 6025169689Skan objc_pq_context = 0; 6026169689Skan objc_start_method_definition (decl); 6027169689Skan add_stmt (c_parser_compound_statement (parser)); 6028169689Skan objc_finish_method_definition (current_function_decl); 6029169689Skan} 6030169689Skan 6031169689Skan/* Parse an objc-methodprotolist. 6032169689Skan 6033169689Skan objc-methodprotolist: 6034169689Skan empty 6035169689Skan objc-methodprotolist objc-methodproto 6036169689Skan objc-methodprotolist declaration 6037169689Skan objc-methodprotolist ; 6038169689Skan 6039169689Skan The declaration is a data definition, which may be missing 6040169689Skan declaration specifiers under the same rules and diagnostics as 6041169689Skan other data definitions outside functions, and the stray semicolon 6042169689Skan is diagnosed the same way as a stray semicolon outside a 6043169689Skan function. */ 6044169689Skan 6045169689Skanstatic void 6046169689Skanc_parser_objc_methodprotolist (c_parser *parser) 6047169689Skan{ 6048169689Skan while (true) 6049169689Skan { 6050169689Skan /* The list is terminated by @end. */ 6051169689Skan switch (c_parser_peek_token (parser)->type) 6052169689Skan { 6053169689Skan case CPP_SEMICOLON: 6054169689Skan if (pedantic) 6055169689Skan pedwarn ("ISO C does not allow extra %<;%> outside of a function"); 6056169689Skan c_parser_consume_token (parser); 6057169689Skan break; 6058169689Skan case CPP_PLUS: 6059169689Skan case CPP_MINUS: 6060169689Skan c_parser_objc_methodproto (parser); 6061169689Skan break; 6062169689Skan case CPP_PRAGMA: 6063169689Skan c_parser_pragma (parser, pragma_external); 6064169689Skan break; 6065169689Skan case CPP_EOF: 6066169689Skan return; 6067169689Skan default: 6068169689Skan if (c_parser_next_token_is_keyword (parser, RID_AT_END)) 6069169689Skan return; 6070169689Skan c_parser_declaration_or_fndef (parser, false, true, false, true); 6071169689Skan break; 6072169689Skan } 6073169689Skan } 6074169689Skan} 6075169689Skan 6076169689Skan/* Parse an objc-methodproto. 6077169689Skan 6078169689Skan objc-methodproto: 6079169689Skan objc-method-type objc-method-decl ; 6080169689Skan*/ 6081169689Skan 6082169689Skanstatic void 6083169689Skanc_parser_objc_methodproto (c_parser *parser) 6084169689Skan{ 6085169689Skan enum tree_code type = c_parser_objc_method_type (parser); 6086169689Skan tree decl; 6087169689Skan objc_set_method_type (type); 6088169689Skan /* Remember protocol qualifiers in prototypes. */ 6089169689Skan objc_pq_context = 1; 6090169689Skan decl = c_parser_objc_method_decl (parser); 6091169689Skan /* Forget protocol qualifiers here. */ 6092169689Skan objc_pq_context = 0; 6093169689Skan objc_add_method_declaration (decl); 6094169689Skan c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>"); 6095169689Skan} 6096169689Skan 6097169689Skan/* Parse an objc-method-decl. 6098169689Skan 6099169689Skan objc-method-decl: 6100169689Skan ( objc-type-name ) objc-selector 6101169689Skan objc-selector 6102169689Skan ( objc-type-name ) objc-keyword-selector objc-optparmlist 6103169689Skan objc-keyword-selector objc-optparmlist 6104169689Skan 6105169689Skan objc-keyword-selector: 6106169689Skan objc-keyword-decl 6107169689Skan objc-keyword-selector objc-keyword-decl 6108169689Skan 6109169689Skan objc-keyword-decl: 6110169689Skan objc-selector : ( objc-type-name ) identifier 6111169689Skan objc-selector : identifier 6112169689Skan : ( objc-type-name ) identifier 6113169689Skan : identifier 6114169689Skan 6115169689Skan objc-optparmlist: 6116169689Skan objc-optparms objc-optellipsis 6117169689Skan 6118169689Skan objc-optparms: 6119169689Skan empty 6120169689Skan objc-opt-parms , parameter-declaration 6121169689Skan 6122169689Skan objc-optellipsis: 6123169689Skan empty 6124169689Skan , ... 6125169689Skan*/ 6126169689Skan 6127169689Skanstatic tree 6128169689Skanc_parser_objc_method_decl (c_parser *parser) 6129169689Skan{ 6130169689Skan tree type = NULL_TREE; 6131169689Skan tree sel; 6132169689Skan tree parms = NULL_TREE; 6133169689Skan bool ellipsis = false; 6134169689Skan 6135169689Skan if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)) 6136169689Skan { 6137169689Skan c_parser_consume_token (parser); 6138169689Skan type = c_parser_objc_type_name (parser); 6139169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>"); 6140169689Skan } 6141169689Skan sel = c_parser_objc_selector (parser); 6142169689Skan /* If there is no selector, or a colon follows, we have an 6143169689Skan objc-keyword-selector. If there is a selector, and a colon does 6144169689Skan not follow, that selector ends the objc-method-decl. */ 6145169689Skan if (!sel || c_parser_next_token_is (parser, CPP_COLON)) 6146169689Skan { 6147169689Skan tree tsel = sel; 6148169689Skan tree list = NULL_TREE; 6149169689Skan while (true) 6150169689Skan { 6151169689Skan tree atype = NULL_TREE, id, keyworddecl; 6152169689Skan if (!c_parser_require (parser, CPP_COLON, "expected %<:%>")) 6153169689Skan break; 6154169689Skan if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)) 6155169689Skan { 6156169689Skan c_parser_consume_token (parser); 6157169689Skan atype = c_parser_objc_type_name (parser); 6158169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 6159169689Skan "expected %<)%>"); 6160169689Skan } 6161169689Skan if (c_parser_next_token_is_not (parser, CPP_NAME)) 6162169689Skan { 6163169689Skan c_parser_error (parser, "expected identifier"); 6164169689Skan return error_mark_node; 6165169689Skan } 6166169689Skan id = c_parser_peek_token (parser)->value; 6167169689Skan c_parser_consume_token (parser); 6168169689Skan keyworddecl = objc_build_keyword_decl (tsel, atype, id); 6169169689Skan list = chainon (list, keyworddecl); 6170169689Skan tsel = c_parser_objc_selector (parser); 6171169689Skan if (!tsel && c_parser_next_token_is_not (parser, CPP_COLON)) 6172169689Skan break; 6173169689Skan } 6174169689Skan /* Parse the optional parameter list. Optional Objective-C 6175169689Skan method parameters follow the C syntax, and may include '...' 6176169689Skan to denote a variable number of arguments. */ 6177169689Skan parms = make_node (TREE_LIST); 6178169689Skan while (c_parser_next_token_is (parser, CPP_COMMA)) 6179169689Skan { 6180169689Skan struct c_parm *parm; 6181169689Skan c_parser_consume_token (parser); 6182169689Skan if (c_parser_next_token_is (parser, CPP_ELLIPSIS)) 6183169689Skan { 6184169689Skan ellipsis = true; 6185169689Skan c_parser_consume_token (parser); 6186169689Skan break; 6187169689Skan } 6188169689Skan parm = c_parser_parameter_declaration (parser, NULL_TREE); 6189169689Skan if (parm == NULL) 6190169689Skan break; 6191169689Skan parms = chainon (parms, 6192169689Skan build_tree_list (NULL_TREE, grokparm (parm))); 6193169689Skan } 6194169689Skan sel = list; 6195169689Skan } 6196169689Skan return objc_build_method_signature (type, sel, parms, ellipsis); 6197169689Skan} 6198169689Skan 6199169689Skan/* Parse an objc-type-name. 6200169689Skan 6201169689Skan objc-type-name: 6202169689Skan objc-type-qualifiers[opt] type-name 6203169689Skan objc-type-qualifiers[opt] 6204169689Skan 6205169689Skan objc-type-qualifiers: 6206169689Skan objc-type-qualifier 6207169689Skan objc-type-qualifiers objc-type-qualifier 6208169689Skan 6209169689Skan objc-type-qualifier: one of 6210169689Skan in out inout bycopy byref oneway 6211169689Skan*/ 6212169689Skan 6213169689Skanstatic tree 6214169689Skanc_parser_objc_type_name (c_parser *parser) 6215169689Skan{ 6216169689Skan tree quals = NULL_TREE; 6217169689Skan struct c_type_name *typename = NULL; 6218169689Skan tree type = NULL_TREE; 6219169689Skan while (true) 6220169689Skan { 6221169689Skan c_token *token = c_parser_peek_token (parser); 6222169689Skan if (token->type == CPP_KEYWORD 6223169689Skan && (token->keyword == RID_IN 6224169689Skan || token->keyword == RID_OUT 6225169689Skan || token->keyword == RID_INOUT 6226169689Skan || token->keyword == RID_BYCOPY 6227169689Skan || token->keyword == RID_BYREF 6228169689Skan || token->keyword == RID_ONEWAY)) 6229169689Skan { 6230169689Skan quals = chainon (quals, build_tree_list (NULL_TREE, token->value)); 6231169689Skan c_parser_consume_token (parser); 6232169689Skan } 6233169689Skan else 6234169689Skan break; 6235169689Skan } 6236169689Skan if (c_parser_next_token_starts_typename (parser)) 6237169689Skan typename = c_parser_type_name (parser); 6238169689Skan if (typename) 6239169689Skan type = groktypename (typename); 6240169689Skan return build_tree_list (quals, type); 6241169689Skan} 6242169689Skan 6243169689Skan/* Parse objc-protocol-refs. 6244169689Skan 6245169689Skan objc-protocol-refs: 6246169689Skan < identifier-list > 6247169689Skan*/ 6248169689Skan 6249169689Skanstatic tree 6250169689Skanc_parser_objc_protocol_refs (c_parser *parser) 6251169689Skan{ 6252169689Skan tree list = NULL_TREE; 6253169689Skan gcc_assert (c_parser_next_token_is (parser, CPP_LESS)); 6254169689Skan c_parser_consume_token (parser); 6255169689Skan /* Any identifiers, including those declared as type names, are OK 6256169689Skan here. */ 6257169689Skan while (true) 6258169689Skan { 6259169689Skan tree id; 6260169689Skan if (c_parser_next_token_is_not (parser, CPP_NAME)) 6261169689Skan { 6262169689Skan c_parser_error (parser, "expected identifier"); 6263169689Skan break; 6264169689Skan } 6265169689Skan id = c_parser_peek_token (parser)->value; 6266169689Skan list = chainon (list, build_tree_list (NULL_TREE, id)); 6267169689Skan c_parser_consume_token (parser); 6268169689Skan if (c_parser_next_token_is (parser, CPP_COMMA)) 6269169689Skan c_parser_consume_token (parser); 6270169689Skan else 6271169689Skan break; 6272169689Skan } 6273169689Skan c_parser_require (parser, CPP_GREATER, "expected %<>%>"); 6274169689Skan return list; 6275169689Skan} 6276169689Skan 6277169689Skan/* Parse an objc-try-catch-statement. 6278169689Skan 6279169689Skan objc-try-catch-statement: 6280169689Skan @try compound-statement objc-catch-list[opt] 6281169689Skan @try compound-statement objc-catch-list[opt] @finally compound-statement 6282169689Skan 6283169689Skan objc-catch-list: 6284169689Skan @catch ( parameter-declaration ) compound-statement 6285169689Skan objc-catch-list @catch ( parameter-declaration ) compound-statement 6286169689Skan*/ 6287169689Skan 6288169689Skanstatic void 6289169689Skanc_parser_objc_try_catch_statement (c_parser *parser) 6290169689Skan{ 6291169689Skan location_t loc; 6292169689Skan tree stmt; 6293169689Skan gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_TRY)); 6294169689Skan c_parser_consume_token (parser); 6295169689Skan loc = c_parser_peek_token (parser)->location; 6296169689Skan stmt = c_parser_compound_statement (parser); 6297169689Skan objc_begin_try_stmt (loc, stmt); 6298169689Skan while (c_parser_next_token_is_keyword (parser, RID_AT_CATCH)) 6299169689Skan { 6300169689Skan struct c_parm *parm; 6301169689Skan c_parser_consume_token (parser); 6302169689Skan if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 6303169689Skan break; 6304169689Skan parm = c_parser_parameter_declaration (parser, NULL_TREE); 6305169689Skan if (parm == NULL) 6306169689Skan { 6307169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); 6308169689Skan break; 6309169689Skan } 6310169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>"); 6311169689Skan objc_begin_catch_clause (grokparm (parm)); 6312169689Skan if (c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>")) 6313169689Skan c_parser_compound_statement_nostart (parser); 6314169689Skan objc_finish_catch_clause (); 6315169689Skan } 6316169689Skan if (c_parser_next_token_is_keyword (parser, RID_AT_FINALLY)) 6317169689Skan { 6318169689Skan location_t finloc; 6319169689Skan tree finstmt; 6320169689Skan c_parser_consume_token (parser); 6321169689Skan finloc = c_parser_peek_token (parser)->location; 6322169689Skan finstmt = c_parser_compound_statement (parser); 6323169689Skan objc_build_finally_clause (finloc, finstmt); 6324169689Skan } 6325169689Skan objc_finish_try_stmt (); 6326169689Skan} 6327169689Skan 6328169689Skan/* Parse an objc-synchronized-statement. 6329169689Skan 6330169689Skan objc-synchronized-statement: 6331169689Skan @synchronized ( expression ) compound-statement 6332169689Skan*/ 6333169689Skan 6334169689Skanstatic void 6335169689Skanc_parser_objc_synchronized_statement (c_parser *parser) 6336169689Skan{ 6337169689Skan location_t loc; 6338169689Skan tree expr, stmt; 6339169689Skan gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_SYNCHRONIZED)); 6340169689Skan c_parser_consume_token (parser); 6341169689Skan loc = c_parser_peek_token (parser)->location; 6342169689Skan if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 6343169689Skan { 6344169689Skan expr = c_parser_expression (parser).value; 6345169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>"); 6346169689Skan } 6347169689Skan else 6348169689Skan expr = error_mark_node; 6349169689Skan stmt = c_parser_compound_statement (parser); 6350169689Skan objc_build_synchronized (loc, expr, stmt); 6351169689Skan} 6352169689Skan 6353169689Skan/* Parse an objc-selector; return NULL_TREE without an error if the 6354169689Skan next token is not an objc-selector. 6355169689Skan 6356169689Skan objc-selector: 6357169689Skan identifier 6358169689Skan one of 6359169689Skan enum struct union if else while do for switch case default 6360169689Skan break continue return goto asm sizeof typeof __alignof 6361169689Skan unsigned long const short volatile signed restrict _Complex 6362169689Skan in out inout bycopy byref oneway int char float double void _Bool 6363169689Skan 6364169689Skan ??? Why this selection of keywords but not, for example, storage 6365169689Skan class specifiers? */ 6366169689Skan 6367169689Skanstatic tree 6368169689Skanc_parser_objc_selector (c_parser *parser) 6369169689Skan{ 6370169689Skan c_token *token = c_parser_peek_token (parser); 6371169689Skan tree value = token->value; 6372169689Skan if (token->type == CPP_NAME) 6373169689Skan { 6374169689Skan c_parser_consume_token (parser); 6375169689Skan return value; 6376169689Skan } 6377169689Skan if (token->type != CPP_KEYWORD) 6378169689Skan return NULL_TREE; 6379169689Skan switch (token->keyword) 6380169689Skan { 6381169689Skan case RID_ENUM: 6382169689Skan case RID_STRUCT: 6383169689Skan case RID_UNION: 6384169689Skan case RID_IF: 6385169689Skan case RID_ELSE: 6386169689Skan case RID_WHILE: 6387169689Skan case RID_DO: 6388169689Skan case RID_FOR: 6389169689Skan case RID_SWITCH: 6390169689Skan case RID_CASE: 6391169689Skan case RID_DEFAULT: 6392169689Skan case RID_BREAK: 6393169689Skan case RID_CONTINUE: 6394169689Skan case RID_RETURN: 6395169689Skan case RID_GOTO: 6396169689Skan case RID_ASM: 6397169689Skan case RID_SIZEOF: 6398169689Skan case RID_TYPEOF: 6399169689Skan case RID_ALIGNOF: 6400169689Skan case RID_UNSIGNED: 6401169689Skan case RID_LONG: 6402169689Skan case RID_CONST: 6403169689Skan case RID_SHORT: 6404169689Skan case RID_VOLATILE: 6405169689Skan case RID_SIGNED: 6406169689Skan case RID_RESTRICT: 6407169689Skan case RID_COMPLEX: 6408169689Skan case RID_IN: 6409169689Skan case RID_OUT: 6410169689Skan case RID_INOUT: 6411169689Skan case RID_BYCOPY: 6412169689Skan case RID_BYREF: 6413169689Skan case RID_ONEWAY: 6414169689Skan case RID_INT: 6415169689Skan case RID_CHAR: 6416169689Skan case RID_FLOAT: 6417169689Skan case RID_DOUBLE: 6418169689Skan case RID_VOID: 6419169689Skan case RID_BOOL: 6420169689Skan c_parser_consume_token (parser); 6421169689Skan return value; 6422169689Skan default: 6423169689Skan return NULL_TREE; 6424169689Skan } 6425169689Skan} 6426169689Skan 6427169689Skan/* Parse an objc-selector-arg. 6428169689Skan 6429169689Skan objc-selector-arg: 6430169689Skan objc-selector 6431169689Skan objc-keywordname-list 6432169689Skan 6433169689Skan objc-keywordname-list: 6434169689Skan objc-keywordname 6435169689Skan objc-keywordname-list objc-keywordname 6436169689Skan 6437169689Skan objc-keywordname: 6438169689Skan objc-selector : 6439169689Skan : 6440169689Skan*/ 6441169689Skan 6442169689Skanstatic tree 6443169689Skanc_parser_objc_selector_arg (c_parser *parser) 6444169689Skan{ 6445169689Skan tree sel = c_parser_objc_selector (parser); 6446169689Skan tree list = NULL_TREE; 6447169689Skan if (sel && c_parser_next_token_is_not (parser, CPP_COLON)) 6448169689Skan return sel; 6449169689Skan while (true) 6450169689Skan { 6451169689Skan if (!c_parser_require (parser, CPP_COLON, "expected %<:%>")) 6452169689Skan return list; 6453169689Skan list = chainon (list, build_tree_list (sel, NULL_TREE)); 6454169689Skan sel = c_parser_objc_selector (parser); 6455169689Skan if (!sel && c_parser_next_token_is_not (parser, CPP_COLON)) 6456169689Skan break; 6457169689Skan } 6458169689Skan return list; 6459169689Skan} 6460169689Skan 6461169689Skan/* Parse an objc-receiver. 6462169689Skan 6463169689Skan objc-receiver: 6464169689Skan expression 6465169689Skan class-name 6466169689Skan type-name 6467169689Skan*/ 6468169689Skan 6469169689Skanstatic tree 6470169689Skanc_parser_objc_receiver (c_parser *parser) 6471169689Skan{ 6472169689Skan if (c_parser_peek_token (parser)->type == CPP_NAME 6473169689Skan && (c_parser_peek_token (parser)->id_kind == C_ID_TYPENAME 6474169689Skan || c_parser_peek_token (parser)->id_kind == C_ID_CLASSNAME)) 6475169689Skan { 6476169689Skan tree id = c_parser_peek_token (parser)->value; 6477169689Skan c_parser_consume_token (parser); 6478169689Skan return objc_get_class_reference (id); 6479169689Skan } 6480169689Skan return c_parser_expression (parser).value; 6481169689Skan} 6482169689Skan 6483169689Skan/* Parse objc-message-args. 6484169689Skan 6485169689Skan objc-message-args: 6486169689Skan objc-selector 6487169689Skan objc-keywordarg-list 6488169689Skan 6489169689Skan objc-keywordarg-list: 6490169689Skan objc-keywordarg 6491169689Skan objc-keywordarg-list objc-keywordarg 6492169689Skan 6493169689Skan objc-keywordarg: 6494169689Skan objc-selector : objc-keywordexpr 6495169689Skan : objc-keywordexpr 6496169689Skan*/ 6497169689Skan 6498169689Skanstatic tree 6499169689Skanc_parser_objc_message_args (c_parser *parser) 6500169689Skan{ 6501169689Skan tree sel = c_parser_objc_selector (parser); 6502169689Skan tree list = NULL_TREE; 6503169689Skan if (sel && c_parser_next_token_is_not (parser, CPP_COLON)) 6504169689Skan return sel; 6505169689Skan while (true) 6506169689Skan { 6507169689Skan tree keywordexpr; 6508169689Skan if (!c_parser_require (parser, CPP_COLON, "expected %<:%>")) 6509169689Skan return list; 6510169689Skan keywordexpr = c_parser_objc_keywordexpr (parser); 6511169689Skan list = chainon (list, build_tree_list (sel, keywordexpr)); 6512169689Skan sel = c_parser_objc_selector (parser); 6513169689Skan if (!sel && c_parser_next_token_is_not (parser, CPP_COLON)) 6514169689Skan break; 6515169689Skan } 6516169689Skan return list; 6517169689Skan} 6518169689Skan 6519169689Skan/* Parse an objc-keywordexpr. 6520169689Skan 6521169689Skan objc-keywordexpr: 6522169689Skan nonempty-expr-list 6523169689Skan*/ 6524169689Skan 6525169689Skanstatic tree 6526169689Skanc_parser_objc_keywordexpr (c_parser *parser) 6527169689Skan{ 6528169689Skan tree list = c_parser_expr_list (parser, true); 6529169689Skan if (TREE_CHAIN (list) == NULL_TREE) 6530169689Skan { 6531169689Skan /* Just return the expression, remove a level of 6532169689Skan indirection. */ 6533169689Skan return TREE_VALUE (list); 6534169689Skan } 6535169689Skan else 6536169689Skan { 6537169689Skan /* We have a comma expression, we will collapse later. */ 6538169689Skan return list; 6539169689Skan } 6540169689Skan} 6541169689Skan 6542169689Skan 6543169689Skan/* Handle pragmas. Some OpenMP pragmas are associated with, and therefore 6544169689Skan should be considered, statements. ALLOW_STMT is true if we're within 6545169689Skan the context of a function and such pragmas are to be allowed. Returns 6546169689Skan true if we actually parsed such a pragma. */ 6547169689Skan 6548169689Skanstatic bool 6549169689Skanc_parser_pragma (c_parser *parser, enum pragma_context context) 6550169689Skan{ 6551169689Skan unsigned int id; 6552169689Skan 6553169689Skan id = c_parser_peek_token (parser)->pragma_kind; 6554169689Skan gcc_assert (id != PRAGMA_NONE); 6555169689Skan 6556169689Skan switch (id) 6557169689Skan { 6558169689Skan case PRAGMA_OMP_BARRIER: 6559169689Skan if (context != pragma_compound) 6560169689Skan { 6561169689Skan if (context == pragma_stmt) 6562169689Skan c_parser_error (parser, "%<#pragma omp barrier%> may only be " 6563169689Skan "used in compound statements"); 6564169689Skan goto bad_stmt; 6565169689Skan } 6566169689Skan c_parser_omp_barrier (parser); 6567169689Skan return false; 6568169689Skan 6569169689Skan case PRAGMA_OMP_FLUSH: 6570169689Skan if (context != pragma_compound) 6571169689Skan { 6572169689Skan if (context == pragma_stmt) 6573169689Skan c_parser_error (parser, "%<#pragma omp flush%> may only be " 6574169689Skan "used in compound statements"); 6575169689Skan goto bad_stmt; 6576169689Skan } 6577169689Skan c_parser_omp_flush (parser); 6578169689Skan return false; 6579169689Skan 6580169689Skan case PRAGMA_OMP_THREADPRIVATE: 6581169689Skan c_parser_omp_threadprivate (parser); 6582169689Skan return false; 6583169689Skan 6584169689Skan case PRAGMA_OMP_SECTION: 6585169689Skan error ("%<#pragma omp section%> may only be used in " 6586169689Skan "%<#pragma omp sections%> construct"); 6587169689Skan c_parser_skip_until_found (parser, CPP_PRAGMA_EOL, NULL); 6588169689Skan return false; 6589169689Skan 6590169689Skan case PRAGMA_GCC_PCH_PREPROCESS: 6591169689Skan c_parser_error (parser, "%<#pragma GCC pch_preprocess%> must be first"); 6592169689Skan c_parser_skip_until_found (parser, CPP_PRAGMA_EOL, NULL); 6593169689Skan return false; 6594169689Skan 6595169689Skan default: 6596169689Skan if (id < PRAGMA_FIRST_EXTERNAL) 6597169689Skan { 6598169689Skan if (context == pragma_external) 6599169689Skan { 6600169689Skan bad_stmt: 6601169689Skan c_parser_error (parser, "expected declaration specifiers"); 6602169689Skan c_parser_skip_until_found (parser, CPP_PRAGMA_EOL, NULL); 6603169689Skan return false; 6604169689Skan } 6605169689Skan c_parser_omp_construct (parser); 6606169689Skan return true; 6607169689Skan } 6608169689Skan break; 6609169689Skan } 6610169689Skan 6611169689Skan c_parser_consume_pragma (parser); 6612169689Skan c_invoke_pragma_handler (id); 6613169689Skan 6614169689Skan /* Skip to EOL, but suppress any error message. Those will have been 6615169689Skan generated by the handler routine through calling error, as opposed 6616169689Skan to calling c_parser_error. */ 6617169689Skan parser->error = true; 6618169689Skan c_parser_skip_to_pragma_eol (parser); 6619169689Skan 6620169689Skan return false; 6621169689Skan} 6622169689Skan 6623169689Skan/* The interface the pragma parsers have to the lexer. */ 6624169689Skan 6625169689Skanenum cpp_ttype 6626169689Skanpragma_lex (tree *value) 6627169689Skan{ 6628169689Skan c_token *tok = c_parser_peek_token (the_parser); 6629169689Skan enum cpp_ttype ret = tok->type; 6630169689Skan 6631169689Skan *value = tok->value; 6632169689Skan if (ret == CPP_PRAGMA_EOL || ret == CPP_EOF) 6633169689Skan ret = CPP_EOF; 6634169689Skan else 6635169689Skan { 6636169689Skan if (ret == CPP_KEYWORD) 6637169689Skan ret = CPP_NAME; 6638169689Skan c_parser_consume_token (the_parser); 6639169689Skan } 6640169689Skan 6641169689Skan return ret; 6642169689Skan} 6643169689Skan 6644169689Skanstatic void 6645169689Skanc_parser_pragma_pch_preprocess (c_parser *parser) 6646169689Skan{ 6647169689Skan tree name = NULL; 6648169689Skan 6649169689Skan c_parser_consume_pragma (parser); 6650169689Skan if (c_parser_next_token_is (parser, CPP_STRING)) 6651169689Skan { 6652169689Skan name = c_parser_peek_token (parser)->value; 6653169689Skan c_parser_consume_token (parser); 6654169689Skan } 6655169689Skan else 6656169689Skan c_parser_error (parser, "expected string literal"); 6657169689Skan c_parser_skip_to_pragma_eol (parser); 6658169689Skan 6659169689Skan if (name) 6660169689Skan c_common_pch_pragma (parse_in, TREE_STRING_POINTER (name)); 6661169689Skan} 6662169689Skan 6663169689Skan/* OpenMP 2.5 parsing routines. */ 6664169689Skan 6665169689Skan/* Returns name of the next clause. 6666169689Skan If the clause is not recognized PRAGMA_OMP_CLAUSE_NONE is returned and 6667169689Skan the token is not consumed. Otherwise appropriate pragma_omp_clause is 6668169689Skan returned and the token is consumed. */ 6669169689Skan 6670169689Skanstatic pragma_omp_clause 6671169689Skanc_parser_omp_clause_name (c_parser *parser) 6672169689Skan{ 6673169689Skan pragma_omp_clause result = PRAGMA_OMP_CLAUSE_NONE; 6674169689Skan 6675169689Skan if (c_parser_next_token_is_keyword (parser, RID_IF)) 6676169689Skan result = PRAGMA_OMP_CLAUSE_IF; 6677169689Skan else if (c_parser_next_token_is_keyword (parser, RID_DEFAULT)) 6678169689Skan result = PRAGMA_OMP_CLAUSE_DEFAULT; 6679169689Skan else if (c_parser_next_token_is (parser, CPP_NAME)) 6680169689Skan { 6681169689Skan const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value); 6682169689Skan 6683169689Skan switch (p[0]) 6684169689Skan { 6685169689Skan case 'c': 6686169689Skan if (!strcmp ("copyin", p)) 6687169689Skan result = PRAGMA_OMP_CLAUSE_COPYIN; 6688169689Skan else if (!strcmp ("copyprivate", p)) 6689169689Skan result = PRAGMA_OMP_CLAUSE_COPYPRIVATE; 6690169689Skan break; 6691169689Skan case 'f': 6692169689Skan if (!strcmp ("firstprivate", p)) 6693169689Skan result = PRAGMA_OMP_CLAUSE_FIRSTPRIVATE; 6694169689Skan break; 6695169689Skan case 'l': 6696169689Skan if (!strcmp ("lastprivate", p)) 6697169689Skan result = PRAGMA_OMP_CLAUSE_LASTPRIVATE; 6698169689Skan break; 6699169689Skan case 'n': 6700169689Skan if (!strcmp ("nowait", p)) 6701169689Skan result = PRAGMA_OMP_CLAUSE_NOWAIT; 6702169689Skan else if (!strcmp ("num_threads", p)) 6703169689Skan result = PRAGMA_OMP_CLAUSE_NUM_THREADS; 6704169689Skan break; 6705169689Skan case 'o': 6706169689Skan if (!strcmp ("ordered", p)) 6707169689Skan result = PRAGMA_OMP_CLAUSE_ORDERED; 6708169689Skan break; 6709169689Skan case 'p': 6710169689Skan if (!strcmp ("private", p)) 6711169689Skan result = PRAGMA_OMP_CLAUSE_PRIVATE; 6712169689Skan break; 6713169689Skan case 'r': 6714169689Skan if (!strcmp ("reduction", p)) 6715169689Skan result = PRAGMA_OMP_CLAUSE_REDUCTION; 6716169689Skan break; 6717169689Skan case 's': 6718169689Skan if (!strcmp ("schedule", p)) 6719169689Skan result = PRAGMA_OMP_CLAUSE_SCHEDULE; 6720169689Skan else if (!strcmp ("shared", p)) 6721169689Skan result = PRAGMA_OMP_CLAUSE_SHARED; 6722169689Skan break; 6723169689Skan } 6724169689Skan } 6725169689Skan 6726169689Skan if (result != PRAGMA_OMP_CLAUSE_NONE) 6727169689Skan c_parser_consume_token (parser); 6728169689Skan 6729169689Skan return result; 6730169689Skan} 6731169689Skan 6732169689Skan/* Validate that a clause of the given type does not already exist. */ 6733169689Skan 6734169689Skanstatic void 6735169689Skancheck_no_duplicate_clause (tree clauses, enum tree_code code, const char *name) 6736169689Skan{ 6737169689Skan tree c; 6738169689Skan 6739169689Skan for (c = clauses; c ; c = OMP_CLAUSE_CHAIN (c)) 6740169689Skan if (OMP_CLAUSE_CODE (c) == code) 6741169689Skan { 6742169689Skan error ("too many %qs clauses", name); 6743169689Skan break; 6744169689Skan } 6745169689Skan} 6746169689Skan 6747169689Skan/* OpenMP 2.5: 6748169689Skan variable-list: 6749169689Skan identifier 6750169689Skan variable-list , identifier 6751169689Skan 6752169689Skan If KIND is nonzero, create the appropriate node and install the decl 6753169689Skan in OMP_CLAUSE_DECL and add the node to the head of the list. 6754169689Skan 6755169689Skan If KIND is zero, create a TREE_LIST with the decl in TREE_PURPOSE; 6756169689Skan return the list created. */ 6757169689Skan 6758169689Skanstatic tree 6759169689Skanc_parser_omp_variable_list (c_parser *parser, enum omp_clause_code kind, 6760169689Skan tree list) 6761169689Skan{ 6762169689Skan if (c_parser_next_token_is_not (parser, CPP_NAME) 6763169689Skan || c_parser_peek_token (parser)->id_kind != C_ID_ID) 6764169689Skan c_parser_error (parser, "expected identifier"); 6765169689Skan 6766169689Skan while (c_parser_next_token_is (parser, CPP_NAME) 6767169689Skan && c_parser_peek_token (parser)->id_kind == C_ID_ID) 6768169689Skan { 6769169689Skan tree t = lookup_name (c_parser_peek_token (parser)->value); 6770169689Skan 6771169689Skan if (t == NULL_TREE) 6772169689Skan undeclared_variable (c_parser_peek_token (parser)->value, 6773169689Skan c_parser_peek_token (parser)->location); 6774169689Skan else if (t == error_mark_node) 6775169689Skan ; 6776169689Skan else if (kind != 0) 6777169689Skan { 6778169689Skan tree u = build_omp_clause (kind); 6779169689Skan OMP_CLAUSE_DECL (u) = t; 6780169689Skan OMP_CLAUSE_CHAIN (u) = list; 6781169689Skan list = u; 6782169689Skan } 6783169689Skan else 6784169689Skan list = tree_cons (t, NULL_TREE, list); 6785169689Skan 6786169689Skan c_parser_consume_token (parser); 6787169689Skan 6788169689Skan if (c_parser_next_token_is_not (parser, CPP_COMMA)) 6789169689Skan break; 6790169689Skan 6791169689Skan c_parser_consume_token (parser); 6792169689Skan } 6793169689Skan 6794169689Skan return list; 6795169689Skan} 6796169689Skan 6797169689Skan/* Similarly, but expect leading and trailing parenthesis. This is a very 6798169689Skan common case for omp clauses. */ 6799169689Skan 6800169689Skanstatic tree 6801169689Skanc_parser_omp_var_list_parens (c_parser *parser, enum tree_code kind, tree list) 6802169689Skan{ 6803169689Skan if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 6804169689Skan { 6805169689Skan list = c_parser_omp_variable_list (parser, kind, list); 6806169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>"); 6807169689Skan } 6808169689Skan return list; 6809169689Skan} 6810169689Skan 6811169689Skan/* OpenMP 2.5: 6812169689Skan copyin ( variable-list ) */ 6813169689Skan 6814169689Skanstatic tree 6815169689Skanc_parser_omp_clause_copyin (c_parser *parser, tree list) 6816169689Skan{ 6817169689Skan return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_COPYIN, list); 6818169689Skan} 6819169689Skan 6820169689Skan/* OpenMP 2.5: 6821169689Skan copyprivate ( variable-list ) */ 6822169689Skan 6823169689Skanstatic tree 6824169689Skanc_parser_omp_clause_copyprivate (c_parser *parser, tree list) 6825169689Skan{ 6826169689Skan return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_COPYPRIVATE, list); 6827169689Skan} 6828169689Skan 6829169689Skan/* OpenMP 2.5: 6830169689Skan default ( shared | none ) */ 6831169689Skan 6832169689Skanstatic tree 6833169689Skanc_parser_omp_clause_default (c_parser *parser, tree list) 6834169689Skan{ 6835169689Skan enum omp_clause_default_kind kind = OMP_CLAUSE_DEFAULT_UNSPECIFIED; 6836169689Skan tree c; 6837169689Skan 6838169689Skan if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 6839169689Skan return list; 6840169689Skan if (c_parser_next_token_is (parser, CPP_NAME)) 6841169689Skan { 6842169689Skan const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value); 6843169689Skan 6844169689Skan switch (p[0]) 6845169689Skan { 6846169689Skan case 'n': 6847169689Skan if (strcmp ("none", p) != 0) 6848169689Skan goto invalid_kind; 6849169689Skan kind = OMP_CLAUSE_DEFAULT_NONE; 6850169689Skan break; 6851169689Skan 6852169689Skan case 's': 6853169689Skan if (strcmp ("shared", p) != 0) 6854169689Skan goto invalid_kind; 6855169689Skan kind = OMP_CLAUSE_DEFAULT_SHARED; 6856169689Skan break; 6857169689Skan 6858169689Skan default: 6859169689Skan goto invalid_kind; 6860169689Skan } 6861169689Skan 6862169689Skan c_parser_consume_token (parser); 6863169689Skan } 6864169689Skan else 6865169689Skan { 6866169689Skan invalid_kind: 6867169689Skan c_parser_error (parser, "expected %<none%> or %<shared%>"); 6868169689Skan } 6869169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>"); 6870169689Skan 6871169689Skan if (kind == OMP_CLAUSE_DEFAULT_UNSPECIFIED) 6872169689Skan return list; 6873169689Skan 6874169689Skan check_no_duplicate_clause (list, OMP_CLAUSE_DEFAULT, "default"); 6875169689Skan c = build_omp_clause (OMP_CLAUSE_DEFAULT); 6876169689Skan OMP_CLAUSE_CHAIN (c) = list; 6877169689Skan OMP_CLAUSE_DEFAULT_KIND (c) = kind; 6878169689Skan 6879169689Skan return c; 6880169689Skan} 6881169689Skan 6882169689Skan/* OpenMP 2.5: 6883169689Skan firstprivate ( variable-list ) */ 6884169689Skan 6885169689Skanstatic tree 6886169689Skanc_parser_omp_clause_firstprivate (c_parser *parser, tree list) 6887169689Skan{ 6888169689Skan return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_FIRSTPRIVATE, list); 6889169689Skan} 6890169689Skan 6891169689Skan/* OpenMP 2.5: 6892169689Skan if ( expression ) */ 6893169689Skan 6894169689Skanstatic tree 6895169689Skanc_parser_omp_clause_if (c_parser *parser, tree list) 6896169689Skan{ 6897169689Skan if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)) 6898169689Skan { 6899169689Skan tree t = c_parser_paren_condition (parser); 6900169689Skan tree c; 6901169689Skan 6902169689Skan check_no_duplicate_clause (list, OMP_CLAUSE_IF, "if"); 6903169689Skan 6904169689Skan c = build_omp_clause (OMP_CLAUSE_IF); 6905169689Skan OMP_CLAUSE_IF_EXPR (c) = t; 6906169689Skan OMP_CLAUSE_CHAIN (c) = list; 6907169689Skan list = c; 6908169689Skan } 6909169689Skan else 6910169689Skan c_parser_error (parser, "expected %<(%>"); 6911169689Skan 6912169689Skan return list; 6913169689Skan} 6914169689Skan 6915169689Skan/* OpenMP 2.5: 6916169689Skan lastprivate ( variable-list ) */ 6917169689Skan 6918169689Skanstatic tree 6919169689Skanc_parser_omp_clause_lastprivate (c_parser *parser, tree list) 6920169689Skan{ 6921169689Skan return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_LASTPRIVATE, list); 6922169689Skan} 6923169689Skan 6924169689Skan/* OpenMP 2.5: 6925169689Skan nowait */ 6926169689Skan 6927169689Skanstatic tree 6928169689Skanc_parser_omp_clause_nowait (c_parser *parser ATTRIBUTE_UNUSED, tree list) 6929169689Skan{ 6930169689Skan tree c; 6931169689Skan 6932169689Skan check_no_duplicate_clause (list, OMP_CLAUSE_NOWAIT, "nowait"); 6933169689Skan 6934169689Skan c = build_omp_clause (OMP_CLAUSE_NOWAIT); 6935169689Skan OMP_CLAUSE_CHAIN (c) = list; 6936169689Skan return c; 6937169689Skan} 6938169689Skan 6939169689Skan/* OpenMP 2.5: 6940169689Skan num_threads ( expression ) */ 6941169689Skan 6942169689Skanstatic tree 6943169689Skanc_parser_omp_clause_num_threads (c_parser *parser, tree list) 6944169689Skan{ 6945169689Skan if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 6946169689Skan { 6947169689Skan tree c, t = c_parser_expression (parser).value; 6948169689Skan 6949169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>"); 6950169689Skan 6951169689Skan if (!INTEGRAL_TYPE_P (TREE_TYPE (t))) 6952169689Skan { 6953169689Skan c_parser_error (parser, "expected integer expression"); 6954169689Skan return list; 6955169689Skan } 6956169689Skan 6957169689Skan /* Attempt to statically determine when the number isn't positive. */ 6958169689Skan c = fold_build2 (LE_EXPR, boolean_type_node, t, 6959169689Skan build_int_cst (TREE_TYPE (t), 0)); 6960169689Skan if (c == boolean_true_node) 6961169689Skan { 6962169689Skan warning (0, "%<num_threads%> value must be positive"); 6963169689Skan t = integer_one_node; 6964169689Skan } 6965169689Skan 6966169689Skan check_no_duplicate_clause (list, OMP_CLAUSE_NUM_THREADS, "num_threads"); 6967169689Skan 6968169689Skan c = build_omp_clause (OMP_CLAUSE_NUM_THREADS); 6969169689Skan OMP_CLAUSE_NUM_THREADS_EXPR (c) = t; 6970169689Skan OMP_CLAUSE_CHAIN (c) = list; 6971169689Skan list = c; 6972169689Skan } 6973169689Skan 6974169689Skan return list; 6975169689Skan} 6976169689Skan 6977169689Skan/* OpenMP 2.5: 6978169689Skan ordered */ 6979169689Skan 6980169689Skanstatic tree 6981169689Skanc_parser_omp_clause_ordered (c_parser *parser ATTRIBUTE_UNUSED, tree list) 6982169689Skan{ 6983169689Skan tree c; 6984169689Skan 6985169689Skan check_no_duplicate_clause (list, OMP_CLAUSE_ORDERED, "ordered"); 6986169689Skan 6987169689Skan c = build_omp_clause (OMP_CLAUSE_ORDERED); 6988169689Skan OMP_CLAUSE_CHAIN (c) = list; 6989169689Skan return c; 6990169689Skan} 6991169689Skan 6992169689Skan/* OpenMP 2.5: 6993169689Skan private ( variable-list ) */ 6994169689Skan 6995169689Skanstatic tree 6996169689Skanc_parser_omp_clause_private (c_parser *parser, tree list) 6997169689Skan{ 6998169689Skan return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_PRIVATE, list); 6999169689Skan} 7000169689Skan 7001169689Skan/* OpenMP 2.5: 7002169689Skan reduction ( reduction-operator : variable-list ) 7003169689Skan 7004169689Skan reduction-operator: 7005169689Skan One of: + * - & ^ | && || */ 7006169689Skan 7007169689Skanstatic tree 7008169689Skanc_parser_omp_clause_reduction (c_parser *parser, tree list) 7009169689Skan{ 7010169689Skan if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 7011169689Skan { 7012169689Skan enum tree_code code; 7013169689Skan 7014169689Skan switch (c_parser_peek_token (parser)->type) 7015169689Skan { 7016169689Skan case CPP_PLUS: 7017169689Skan code = PLUS_EXPR; 7018169689Skan break; 7019169689Skan case CPP_MULT: 7020169689Skan code = MULT_EXPR; 7021169689Skan break; 7022169689Skan case CPP_MINUS: 7023169689Skan code = MINUS_EXPR; 7024169689Skan break; 7025169689Skan case CPP_AND: 7026169689Skan code = BIT_AND_EXPR; 7027169689Skan break; 7028169689Skan case CPP_XOR: 7029169689Skan code = BIT_XOR_EXPR; 7030169689Skan break; 7031169689Skan case CPP_OR: 7032169689Skan code = BIT_IOR_EXPR; 7033169689Skan break; 7034169689Skan case CPP_AND_AND: 7035169689Skan code = TRUTH_ANDIF_EXPR; 7036169689Skan break; 7037169689Skan case CPP_OR_OR: 7038169689Skan code = TRUTH_ORIF_EXPR; 7039169689Skan break; 7040169689Skan default: 7041169689Skan c_parser_error (parser, 7042169689Skan "expected %<+%>, %<*%>, %<-%>, %<&%>, " 7043169689Skan "%<^%>, %<|%>, %<&&%>, or %<||%>"); 7044169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 0); 7045169689Skan return list; 7046169689Skan } 7047169689Skan c_parser_consume_token (parser); 7048169689Skan if (c_parser_require (parser, CPP_COLON, "expected %<:%>")) 7049169689Skan { 7050169689Skan tree nl, c; 7051169689Skan 7052169689Skan nl = c_parser_omp_variable_list (parser, OMP_CLAUSE_REDUCTION, list); 7053169689Skan for (c = nl; c != list; c = OMP_CLAUSE_CHAIN (c)) 7054169689Skan OMP_CLAUSE_REDUCTION_CODE (c) = code; 7055169689Skan 7056169689Skan list = nl; 7057169689Skan } 7058169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>"); 7059169689Skan } 7060169689Skan return list; 7061169689Skan} 7062169689Skan 7063169689Skan/* OpenMP 2.5: 7064169689Skan schedule ( schedule-kind ) 7065169689Skan schedule ( schedule-kind , expression ) 7066169689Skan 7067169689Skan schedule-kind: 7068169689Skan static | dynamic | guided | runtime 7069169689Skan*/ 7070169689Skan 7071169689Skanstatic tree 7072169689Skanc_parser_omp_clause_schedule (c_parser *parser, tree list) 7073169689Skan{ 7074169689Skan tree c, t; 7075169689Skan 7076169689Skan if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 7077169689Skan return list; 7078169689Skan 7079169689Skan c = build_omp_clause (OMP_CLAUSE_SCHEDULE); 7080169689Skan 7081169689Skan if (c_parser_next_token_is (parser, CPP_NAME)) 7082169689Skan { 7083169689Skan tree kind = c_parser_peek_token (parser)->value; 7084169689Skan const char *p = IDENTIFIER_POINTER (kind); 7085169689Skan 7086169689Skan switch (p[0]) 7087169689Skan { 7088169689Skan case 'd': 7089169689Skan if (strcmp ("dynamic", p) != 0) 7090169689Skan goto invalid_kind; 7091169689Skan OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_DYNAMIC; 7092169689Skan break; 7093169689Skan 7094169689Skan case 'g': 7095169689Skan if (strcmp ("guided", p) != 0) 7096169689Skan goto invalid_kind; 7097169689Skan OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_GUIDED; 7098169689Skan break; 7099169689Skan 7100169689Skan case 'r': 7101169689Skan if (strcmp ("runtime", p) != 0) 7102169689Skan goto invalid_kind; 7103169689Skan OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_RUNTIME; 7104169689Skan break; 7105169689Skan 7106169689Skan default: 7107169689Skan goto invalid_kind; 7108169689Skan } 7109169689Skan } 7110169689Skan else if (c_parser_next_token_is_keyword (parser, RID_STATIC)) 7111169689Skan OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_STATIC; 7112169689Skan else 7113169689Skan goto invalid_kind; 7114169689Skan 7115169689Skan c_parser_consume_token (parser); 7116169689Skan if (c_parser_next_token_is (parser, CPP_COMMA)) 7117169689Skan { 7118169689Skan c_parser_consume_token (parser); 7119169689Skan 7120169689Skan t = c_parser_expr_no_commas (parser, NULL).value; 7121169689Skan 7122169689Skan if (OMP_CLAUSE_SCHEDULE_KIND (c) == OMP_CLAUSE_SCHEDULE_RUNTIME) 7123169689Skan error ("schedule %<runtime%> does not take " 7124169689Skan "a %<chunk_size%> parameter"); 7125169689Skan else if (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE) 7126169689Skan OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c) = t; 7127169689Skan else 7128169689Skan c_parser_error (parser, "expected integer expression"); 7129169689Skan 7130169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>"); 7131169689Skan } 7132169689Skan else 7133169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 7134169689Skan "expected %<,%> or %<)%>"); 7135169689Skan 7136169689Skan check_no_duplicate_clause (list, OMP_CLAUSE_SCHEDULE, "schedule"); 7137169689Skan OMP_CLAUSE_CHAIN (c) = list; 7138169689Skan return c; 7139169689Skan 7140169689Skan invalid_kind: 7141169689Skan c_parser_error (parser, "invalid schedule kind"); 7142169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 0); 7143169689Skan return list; 7144169689Skan} 7145169689Skan 7146169689Skan/* OpenMP 2.5: 7147169689Skan shared ( variable-list ) */ 7148169689Skan 7149169689Skanstatic tree 7150169689Skanc_parser_omp_clause_shared (c_parser *parser, tree list) 7151169689Skan{ 7152169689Skan return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_SHARED, list); 7153169689Skan} 7154169689Skan 7155169689Skan/* Parse all OpenMP clauses. The set clauses allowed by the directive 7156169689Skan is a bitmask in MASK. Return the list of clauses found; the result 7157169689Skan of clause default goes in *pdefault. */ 7158169689Skan 7159169689Skanstatic tree 7160169689Skanc_parser_omp_all_clauses (c_parser *parser, unsigned int mask, 7161169689Skan const char *where) 7162169689Skan{ 7163169689Skan tree clauses = NULL; 7164169689Skan 7165169689Skan while (c_parser_next_token_is_not (parser, CPP_PRAGMA_EOL)) 7166169689Skan { 7167169689Skan const pragma_omp_clause c_kind = c_parser_omp_clause_name (parser); 7168169689Skan const char *c_name; 7169169689Skan tree prev = clauses; 7170169689Skan 7171169689Skan switch (c_kind) 7172169689Skan { 7173169689Skan case PRAGMA_OMP_CLAUSE_COPYIN: 7174169689Skan clauses = c_parser_omp_clause_copyin (parser, clauses); 7175169689Skan c_name = "copyin"; 7176169689Skan break; 7177169689Skan case PRAGMA_OMP_CLAUSE_COPYPRIVATE: 7178169689Skan clauses = c_parser_omp_clause_copyprivate (parser, clauses); 7179169689Skan c_name = "copyprivate"; 7180169689Skan break; 7181169689Skan case PRAGMA_OMP_CLAUSE_DEFAULT: 7182169689Skan clauses = c_parser_omp_clause_default (parser, clauses); 7183169689Skan c_name = "default"; 7184169689Skan break; 7185169689Skan case PRAGMA_OMP_CLAUSE_FIRSTPRIVATE: 7186169689Skan clauses = c_parser_omp_clause_firstprivate (parser, clauses); 7187169689Skan c_name = "firstprivate"; 7188169689Skan break; 7189169689Skan case PRAGMA_OMP_CLAUSE_IF: 7190169689Skan clauses = c_parser_omp_clause_if (parser, clauses); 7191169689Skan c_name = "if"; 7192169689Skan break; 7193169689Skan case PRAGMA_OMP_CLAUSE_LASTPRIVATE: 7194169689Skan clauses = c_parser_omp_clause_lastprivate (parser, clauses); 7195169689Skan c_name = "lastprivate"; 7196169689Skan break; 7197169689Skan case PRAGMA_OMP_CLAUSE_NOWAIT: 7198169689Skan clauses = c_parser_omp_clause_nowait (parser, clauses); 7199169689Skan c_name = "nowait"; 7200169689Skan break; 7201169689Skan case PRAGMA_OMP_CLAUSE_NUM_THREADS: 7202169689Skan clauses = c_parser_omp_clause_num_threads (parser, clauses); 7203169689Skan c_name = "num_threads"; 7204169689Skan break; 7205169689Skan case PRAGMA_OMP_CLAUSE_ORDERED: 7206169689Skan clauses = c_parser_omp_clause_ordered (parser, clauses); 7207169689Skan c_name = "ordered"; 7208169689Skan break; 7209169689Skan case PRAGMA_OMP_CLAUSE_PRIVATE: 7210169689Skan clauses = c_parser_omp_clause_private (parser, clauses); 7211169689Skan c_name = "private"; 7212169689Skan break; 7213169689Skan case PRAGMA_OMP_CLAUSE_REDUCTION: 7214169689Skan clauses = c_parser_omp_clause_reduction (parser, clauses); 7215169689Skan c_name = "reduction"; 7216169689Skan break; 7217169689Skan case PRAGMA_OMP_CLAUSE_SCHEDULE: 7218169689Skan clauses = c_parser_omp_clause_schedule (parser, clauses); 7219169689Skan c_name = "schedule"; 7220169689Skan break; 7221169689Skan case PRAGMA_OMP_CLAUSE_SHARED: 7222169689Skan clauses = c_parser_omp_clause_shared (parser, clauses); 7223169689Skan c_name = "shared"; 7224169689Skan break; 7225169689Skan default: 7226169689Skan c_parser_error (parser, "expected %<#pragma omp%> clause"); 7227169689Skan goto saw_error; 7228169689Skan } 7229169689Skan 7230169689Skan if (((mask >> c_kind) & 1) == 0 && !parser->error) 7231169689Skan { 7232169689Skan /* Remove the invalid clause(s) from the list to avoid 7233169689Skan confusing the rest of the compiler. */ 7234169689Skan clauses = prev; 7235169689Skan error ("%qs is not valid for %qs", c_name, where); 7236169689Skan } 7237169689Skan } 7238169689Skan 7239169689Skan saw_error: 7240169689Skan c_parser_skip_to_pragma_eol (parser); 7241169689Skan 7242169689Skan return c_finish_omp_clauses (clauses); 7243169689Skan} 7244169689Skan 7245169689Skan/* OpenMP 2.5: 7246169689Skan structured-block: 7247169689Skan statement 7248169689Skan 7249169689Skan In practice, we're also interested in adding the statement to an 7250169689Skan outer node. So it is convenient if we work around the fact that 7251169689Skan c_parser_statement calls add_stmt. */ 7252169689Skan 7253169689Skanstatic tree 7254169689Skanc_parser_omp_structured_block (c_parser *parser) 7255169689Skan{ 7256169689Skan tree stmt = push_stmt_list (); 7257169689Skan c_parser_statement (parser); 7258169689Skan return pop_stmt_list (stmt); 7259169689Skan} 7260169689Skan 7261169689Skan/* OpenMP 2.5: 7262169689Skan # pragma omp atomic new-line 7263169689Skan expression-stmt 7264169689Skan 7265169689Skan expression-stmt: 7266169689Skan x binop= expr | x++ | ++x | x-- | --x 7267169689Skan binop: 7268169689Skan +, *, -, /, &, ^, |, <<, >> 7269169689Skan 7270169689Skan where x is an lvalue expression with scalar type. */ 7271169689Skan 7272169689Skanstatic void 7273169689Skanc_parser_omp_atomic (c_parser *parser) 7274169689Skan{ 7275169689Skan tree lhs, rhs; 7276169689Skan tree stmt; 7277169689Skan enum tree_code code; 7278169689Skan 7279169689Skan c_parser_skip_to_pragma_eol (parser); 7280169689Skan 7281169689Skan lhs = c_parser_unary_expression (parser).value; 7282169689Skan switch (TREE_CODE (lhs)) 7283169689Skan { 7284169689Skan case ERROR_MARK: 7285169689Skan saw_error: 7286169689Skan c_parser_skip_to_end_of_block_or_statement (parser); 7287169689Skan return; 7288169689Skan 7289169689Skan case PREINCREMENT_EXPR: 7290169689Skan case POSTINCREMENT_EXPR: 7291169689Skan lhs = TREE_OPERAND (lhs, 0); 7292169689Skan code = PLUS_EXPR; 7293169689Skan rhs = integer_one_node; 7294169689Skan break; 7295169689Skan 7296169689Skan case PREDECREMENT_EXPR: 7297169689Skan case POSTDECREMENT_EXPR: 7298169689Skan lhs = TREE_OPERAND (lhs, 0); 7299169689Skan code = MINUS_EXPR; 7300169689Skan rhs = integer_one_node; 7301169689Skan break; 7302169689Skan 7303169689Skan default: 7304169689Skan switch (c_parser_peek_token (parser)->type) 7305169689Skan { 7306169689Skan case CPP_MULT_EQ: 7307169689Skan code = MULT_EXPR; 7308169689Skan break; 7309169689Skan case CPP_DIV_EQ: 7310169689Skan code = TRUNC_DIV_EXPR; 7311169689Skan break; 7312169689Skan case CPP_PLUS_EQ: 7313169689Skan code = PLUS_EXPR; 7314169689Skan break; 7315169689Skan case CPP_MINUS_EQ: 7316169689Skan code = MINUS_EXPR; 7317169689Skan break; 7318169689Skan case CPP_LSHIFT_EQ: 7319169689Skan code = LSHIFT_EXPR; 7320169689Skan break; 7321169689Skan case CPP_RSHIFT_EQ: 7322169689Skan code = RSHIFT_EXPR; 7323169689Skan break; 7324169689Skan case CPP_AND_EQ: 7325169689Skan code = BIT_AND_EXPR; 7326169689Skan break; 7327169689Skan case CPP_OR_EQ: 7328169689Skan code = BIT_IOR_EXPR; 7329169689Skan break; 7330169689Skan case CPP_XOR_EQ: 7331169689Skan code = BIT_XOR_EXPR; 7332169689Skan break; 7333169689Skan default: 7334169689Skan c_parser_error (parser, 7335169689Skan "invalid operator for %<#pragma omp atomic%>"); 7336169689Skan goto saw_error; 7337169689Skan } 7338169689Skan 7339169689Skan c_parser_consume_token (parser); 7340169689Skan rhs = c_parser_expression (parser).value; 7341169689Skan break; 7342169689Skan } 7343169689Skan stmt = c_finish_omp_atomic (code, lhs, rhs); 7344169689Skan if (stmt != error_mark_node) 7345169689Skan add_stmt (stmt); 7346169689Skan c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>"); 7347169689Skan} 7348169689Skan 7349169689Skan 7350169689Skan/* OpenMP 2.5: 7351169689Skan # pragma omp barrier new-line 7352169689Skan*/ 7353169689Skan 7354169689Skanstatic void 7355169689Skanc_parser_omp_barrier (c_parser *parser) 7356169689Skan{ 7357169689Skan c_parser_consume_pragma (parser); 7358169689Skan c_parser_skip_to_pragma_eol (parser); 7359169689Skan 7360169689Skan c_finish_omp_barrier (); 7361169689Skan} 7362169689Skan 7363169689Skan/* OpenMP 2.5: 7364169689Skan # pragma omp critical [(name)] new-line 7365169689Skan structured-block 7366169689Skan*/ 7367169689Skan 7368169689Skanstatic tree 7369169689Skanc_parser_omp_critical (c_parser *parser) 7370169689Skan{ 7371169689Skan tree stmt, name = NULL; 7372169689Skan 7373169689Skan if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)) 7374169689Skan { 7375169689Skan c_parser_consume_token (parser); 7376169689Skan if (c_parser_next_token_is (parser, CPP_NAME)) 7377169689Skan { 7378169689Skan name = c_parser_peek_token (parser)->value; 7379169689Skan c_parser_consume_token (parser); 7380169689Skan c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"); 7381169689Skan } 7382169689Skan else 7383169689Skan c_parser_error (parser, "expected identifier"); 7384169689Skan } 7385169689Skan else if (c_parser_next_token_is_not (parser, CPP_PRAGMA_EOL)) 7386169689Skan c_parser_error (parser, "expected %<(%> or end of line"); 7387169689Skan c_parser_skip_to_pragma_eol (parser); 7388169689Skan 7389169689Skan stmt = c_parser_omp_structured_block (parser); 7390169689Skan return c_finish_omp_critical (stmt, name); 7391169689Skan} 7392169689Skan 7393169689Skan/* OpenMP 2.5: 7394169689Skan # pragma omp flush flush-vars[opt] new-line 7395169689Skan 7396169689Skan flush-vars: 7397169689Skan ( variable-list ) */ 7398169689Skan 7399169689Skanstatic void 7400169689Skanc_parser_omp_flush (c_parser *parser) 7401169689Skan{ 7402169689Skan c_parser_consume_pragma (parser); 7403169689Skan if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)) 7404169689Skan c_parser_omp_var_list_parens (parser, 0, NULL); 7405169689Skan else if (c_parser_next_token_is_not (parser, CPP_PRAGMA_EOL)) 7406169689Skan c_parser_error (parser, "expected %<(%> or end of line"); 7407169689Skan c_parser_skip_to_pragma_eol (parser); 7408169689Skan 7409169689Skan c_finish_omp_flush (); 7410169689Skan} 7411169689Skan 7412169689Skan/* Parse the restricted form of the for statment allowed by OpenMP. 7413169689Skan The real trick here is to determine the loop control variable early 7414169689Skan so that we can push a new decl if necessary to make it private. */ 7415169689Skan 7416169689Skanstatic tree 7417169689Skanc_parser_omp_for_loop (c_parser *parser) 7418169689Skan{ 7419169689Skan tree decl, cond, incr, save_break, save_cont, body, init; 7420169689Skan location_t loc; 7421169689Skan 7422169689Skan if (!c_parser_next_token_is_keyword (parser, RID_FOR)) 7423169689Skan { 7424169689Skan c_parser_error (parser, "for statement expected"); 7425169689Skan return NULL; 7426169689Skan } 7427169689Skan loc = c_parser_peek_token (parser)->location; 7428169689Skan c_parser_consume_token (parser); 7429169689Skan 7430169689Skan if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 7431169689Skan return NULL; 7432169689Skan 7433169689Skan /* Parse the initialization declaration or expression. */ 7434169689Skan if (c_parser_next_token_starts_declspecs (parser)) 7435169689Skan { 7436169689Skan c_parser_declaration_or_fndef (parser, true, true, true, true); 7437169689Skan decl = check_for_loop_decls (); 7438169689Skan if (decl == NULL) 7439169689Skan goto error_init; 7440169689Skan init = decl; 7441169689Skan } 7442169689Skan else if (c_parser_next_token_is (parser, CPP_NAME) 7443169689Skan && c_parser_peek_2nd_token (parser)->type == CPP_EQ) 7444169689Skan { 7445169689Skan decl = c_parser_postfix_expression (parser).value; 7446169689Skan 7447169689Skan c_parser_require (parser, CPP_EQ, "expected %<=%>"); 7448169689Skan 7449169689Skan init = c_parser_expr_no_commas (parser, NULL).value; 7450169689Skan init = build_modify_expr (decl, NOP_EXPR, init); 7451169689Skan init = c_process_expr_stmt (init); 7452169689Skan 7453169689Skan c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>"); 7454169689Skan } 7455169689Skan else 7456169689Skan goto error_init; 7457169689Skan 7458169689Skan /* Parse the loop condition. */ 7459169689Skan cond = NULL_TREE; 7460169689Skan if (c_parser_next_token_is_not (parser, CPP_SEMICOLON)) 7461169689Skan { 7462169689Skan cond = c_parser_expression_conv (parser).value; 7463169689Skan cond = c_objc_common_truthvalue_conversion (cond); 7464169689Skan if (EXPR_P (cond)) 7465169689Skan SET_EXPR_LOCATION (cond, input_location); 7466169689Skan } 7467169689Skan c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>"); 7468169689Skan 7469169689Skan /* Parse the increment expression. */ 7470169689Skan incr = NULL_TREE; 7471169689Skan if (c_parser_next_token_is_not (parser, CPP_CLOSE_PAREN)) 7472169689Skan incr = c_process_expr_stmt (c_parser_expression (parser).value); 7473169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>"); 7474169689Skan 7475169689Skan parse_body: 7476169689Skan save_break = c_break_label; 7477169689Skan c_break_label = size_one_node; 7478169689Skan save_cont = c_cont_label; 7479169689Skan c_cont_label = NULL_TREE; 7480169689Skan body = push_stmt_list (); 7481169689Skan 7482169689Skan add_stmt (c_parser_c99_block_statement (parser)); 7483169689Skan if (c_cont_label) 7484169689Skan add_stmt (build1 (LABEL_EXPR, void_type_node, c_cont_label)); 7485169689Skan 7486169689Skan body = pop_stmt_list (body); 7487169689Skan c_break_label = save_break; 7488169689Skan c_cont_label = save_cont; 7489169689Skan 7490169689Skan /* Only bother calling c_finish_omp_for if we havn't already generated 7491169689Skan an error from the initialization parsing. */ 7492169689Skan if (decl != NULL && decl != error_mark_node && init != error_mark_node) 7493169689Skan return c_finish_omp_for (loc, decl, init, cond, incr, body, NULL); 7494169689Skan return NULL; 7495169689Skan 7496169689Skan error_init: 7497169689Skan c_parser_error (parser, "expected iteration declaration or initialization"); 7498169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>"); 7499169689Skan decl = init = cond = incr = NULL_TREE; 7500169689Skan goto parse_body; 7501169689Skan} 7502169689Skan 7503169689Skan/* OpenMP 2.5: 7504169689Skan #pragma omp for for-clause[optseq] new-line 7505169689Skan for-loop 7506169689Skan*/ 7507169689Skan 7508169689Skan#define OMP_FOR_CLAUSE_MASK \ 7509169689Skan ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \ 7510169689Skan | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \ 7511169689Skan | (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \ 7512169689Skan | (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \ 7513169689Skan | (1u << PRAGMA_OMP_CLAUSE_ORDERED) \ 7514169689Skan | (1u << PRAGMA_OMP_CLAUSE_SCHEDULE) \ 7515169689Skan | (1u << PRAGMA_OMP_CLAUSE_NOWAIT)) 7516169689Skan 7517169689Skanstatic tree 7518169689Skanc_parser_omp_for (c_parser *parser) 7519169689Skan{ 7520169689Skan tree block, clauses, ret; 7521169689Skan 7522169689Skan clauses = c_parser_omp_all_clauses (parser, OMP_FOR_CLAUSE_MASK, 7523169689Skan "#pragma omp for"); 7524169689Skan 7525169689Skan block = c_begin_compound_stmt (true); 7526169689Skan ret = c_parser_omp_for_loop (parser); 7527169689Skan if (ret) 7528169689Skan OMP_FOR_CLAUSES (ret) = clauses; 7529169689Skan block = c_end_compound_stmt (block, true); 7530169689Skan add_stmt (block); 7531169689Skan 7532169689Skan return ret; 7533169689Skan} 7534169689Skan 7535169689Skan/* OpenMP 2.5: 7536169689Skan # pragma omp master new-line 7537169689Skan structured-block 7538169689Skan*/ 7539169689Skan 7540169689Skanstatic tree 7541169689Skanc_parser_omp_master (c_parser *parser) 7542169689Skan{ 7543169689Skan c_parser_skip_to_pragma_eol (parser); 7544169689Skan return c_finish_omp_master (c_parser_omp_structured_block (parser)); 7545169689Skan} 7546169689Skan 7547169689Skan/* OpenMP 2.5: 7548169689Skan # pragma omp ordered new-line 7549169689Skan structured-block 7550169689Skan*/ 7551169689Skan 7552169689Skanstatic tree 7553169689Skanc_parser_omp_ordered (c_parser *parser) 7554169689Skan{ 7555169689Skan c_parser_skip_to_pragma_eol (parser); 7556169689Skan return c_finish_omp_ordered (c_parser_omp_structured_block (parser)); 7557169689Skan} 7558169689Skan 7559169689Skan/* OpenMP 2.5: 7560169689Skan 7561169689Skan section-scope: 7562169689Skan { section-sequence } 7563169689Skan 7564169689Skan section-sequence: 7565169689Skan section-directive[opt] structured-block 7566169689Skan section-sequence section-directive structured-block */ 7567169689Skan 7568169689Skanstatic tree 7569169689Skanc_parser_omp_sections_scope (c_parser *parser) 7570169689Skan{ 7571169689Skan tree stmt, substmt; 7572169689Skan bool error_suppress = false; 7573169689Skan location_t loc; 7574169689Skan 7575169689Skan if (!c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>")) 7576169689Skan { 7577169689Skan /* Avoid skipping until the end of the block. */ 7578169689Skan parser->error = false; 7579169689Skan return NULL_TREE; 7580169689Skan } 7581169689Skan 7582169689Skan stmt = push_stmt_list (); 7583169689Skan 7584169689Skan loc = c_parser_peek_token (parser)->location; 7585169689Skan if (c_parser_peek_token (parser)->pragma_kind != PRAGMA_OMP_SECTION) 7586169689Skan { 7587169689Skan substmt = push_stmt_list (); 7588169689Skan 7589169689Skan while (1) 7590169689Skan { 7591169689Skan c_parser_statement (parser); 7592169689Skan 7593169689Skan if (c_parser_peek_token (parser)->pragma_kind == PRAGMA_OMP_SECTION) 7594169689Skan break; 7595169689Skan if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE)) 7596169689Skan break; 7597169689Skan if (c_parser_next_token_is (parser, CPP_EOF)) 7598169689Skan break; 7599169689Skan } 7600169689Skan 7601169689Skan substmt = pop_stmt_list (substmt); 7602169689Skan substmt = build1 (OMP_SECTION, void_type_node, substmt); 7603169689Skan SET_EXPR_LOCATION (substmt, loc); 7604169689Skan add_stmt (substmt); 7605169689Skan } 7606169689Skan 7607169689Skan while (1) 7608169689Skan { 7609169689Skan if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE)) 7610169689Skan break; 7611169689Skan if (c_parser_next_token_is (parser, CPP_EOF)) 7612169689Skan break; 7613169689Skan 7614169689Skan loc = c_parser_peek_token (parser)->location; 7615169689Skan if (c_parser_peek_token (parser)->pragma_kind == PRAGMA_OMP_SECTION) 7616169689Skan { 7617169689Skan c_parser_consume_pragma (parser); 7618169689Skan c_parser_skip_to_pragma_eol (parser); 7619169689Skan error_suppress = false; 7620169689Skan } 7621169689Skan else if (!error_suppress) 7622169689Skan { 7623169689Skan error ("expected %<#pragma omp section%> or %<}%>"); 7624169689Skan error_suppress = true; 7625169689Skan } 7626169689Skan 7627169689Skan substmt = c_parser_omp_structured_block (parser); 7628169689Skan substmt = build1 (OMP_SECTION, void_type_node, substmt); 7629169689Skan SET_EXPR_LOCATION (substmt, loc); 7630169689Skan add_stmt (substmt); 7631169689Skan } 7632169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, 7633169689Skan "expected %<#pragma omp section%> or %<}%>"); 7634169689Skan 7635169689Skan substmt = pop_stmt_list (stmt); 7636169689Skan 7637169689Skan stmt = make_node (OMP_SECTIONS); 7638169689Skan TREE_TYPE (stmt) = void_type_node; 7639169689Skan OMP_SECTIONS_BODY (stmt) = substmt; 7640169689Skan 7641169689Skan return add_stmt (stmt); 7642169689Skan} 7643169689Skan 7644169689Skan/* OpenMP 2.5: 7645169689Skan # pragma omp sections sections-clause[optseq] newline 7646169689Skan sections-scope 7647169689Skan*/ 7648169689Skan 7649169689Skan#define OMP_SECTIONS_CLAUSE_MASK \ 7650169689Skan ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \ 7651169689Skan | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \ 7652169689Skan | (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \ 7653169689Skan | (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \ 7654169689Skan | (1u << PRAGMA_OMP_CLAUSE_NOWAIT)) 7655169689Skan 7656169689Skanstatic tree 7657169689Skanc_parser_omp_sections (c_parser *parser) 7658169689Skan{ 7659169689Skan tree block, clauses, ret; 7660169689Skan 7661169689Skan clauses = c_parser_omp_all_clauses (parser, OMP_SECTIONS_CLAUSE_MASK, 7662169689Skan "#pragma omp sections"); 7663169689Skan 7664169689Skan block = c_begin_compound_stmt (true); 7665169689Skan ret = c_parser_omp_sections_scope (parser); 7666169689Skan if (ret) 7667169689Skan OMP_SECTIONS_CLAUSES (ret) = clauses; 7668169689Skan block = c_end_compound_stmt (block, true); 7669169689Skan add_stmt (block); 7670169689Skan 7671169689Skan return ret; 7672169689Skan} 7673169689Skan 7674169689Skan/* OpenMP 2.5: 7675169689Skan # pragma parallel parallel-clause new-line 7676169689Skan # pragma parallel for parallel-for-clause new-line 7677169689Skan # pragma parallel sections parallel-sections-clause new-line 7678169689Skan*/ 7679169689Skan 7680169689Skan#define OMP_PARALLEL_CLAUSE_MASK \ 7681169689Skan ( (1u << PRAGMA_OMP_CLAUSE_IF) \ 7682169689Skan | (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \ 7683169689Skan | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \ 7684169689Skan | (1u << PRAGMA_OMP_CLAUSE_DEFAULT) \ 7685169689Skan | (1u << PRAGMA_OMP_CLAUSE_SHARED) \ 7686169689Skan | (1u << PRAGMA_OMP_CLAUSE_COPYIN) \ 7687169689Skan | (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \ 7688169689Skan | (1u << PRAGMA_OMP_CLAUSE_NUM_THREADS)) 7689169689Skan 7690169689Skanstatic tree 7691169689Skanc_parser_omp_parallel (c_parser *parser) 7692169689Skan{ 7693169689Skan enum pragma_kind p_kind = PRAGMA_OMP_PARALLEL; 7694169689Skan const char *p_name = "#pragma omp parallel"; 7695169689Skan tree stmt, clauses, par_clause, ws_clause, block; 7696169689Skan unsigned int mask = OMP_PARALLEL_CLAUSE_MASK; 7697169689Skan 7698169689Skan if (c_parser_next_token_is_keyword (parser, RID_FOR)) 7699169689Skan { 7700169689Skan c_parser_consume_token (parser); 7701169689Skan p_kind = PRAGMA_OMP_PARALLEL_FOR; 7702169689Skan p_name = "#pragma omp parallel for"; 7703169689Skan mask |= OMP_FOR_CLAUSE_MASK; 7704169689Skan mask &= ~(1u << PRAGMA_OMP_CLAUSE_NOWAIT); 7705169689Skan } 7706169689Skan else if (c_parser_next_token_is (parser, CPP_NAME)) 7707169689Skan { 7708169689Skan const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value); 7709169689Skan if (strcmp (p, "sections") == 0) 7710169689Skan { 7711169689Skan c_parser_consume_token (parser); 7712169689Skan p_kind = PRAGMA_OMP_PARALLEL_SECTIONS; 7713169689Skan p_name = "#pragma omp parallel sections"; 7714169689Skan mask |= OMP_SECTIONS_CLAUSE_MASK; 7715169689Skan mask &= ~(1u << PRAGMA_OMP_CLAUSE_NOWAIT); 7716169689Skan } 7717169689Skan } 7718169689Skan 7719169689Skan clauses = c_parser_omp_all_clauses (parser, mask, p_name); 7720169689Skan 7721169689Skan switch (p_kind) 7722169689Skan { 7723169689Skan case PRAGMA_OMP_PARALLEL: 7724169689Skan block = c_begin_omp_parallel (); 7725169689Skan c_parser_statement (parser); 7726169689Skan stmt = c_finish_omp_parallel (clauses, block); 7727169689Skan break; 7728169689Skan 7729169689Skan case PRAGMA_OMP_PARALLEL_FOR: 7730169689Skan block = c_begin_omp_parallel (); 7731169689Skan c_split_parallel_clauses (clauses, &par_clause, &ws_clause); 7732169689Skan stmt = c_parser_omp_for_loop (parser); 7733169689Skan if (stmt) 7734169689Skan OMP_FOR_CLAUSES (stmt) = ws_clause; 7735169689Skan stmt = c_finish_omp_parallel (par_clause, block); 7736169689Skan OMP_PARALLEL_COMBINED (stmt) = 1; 7737169689Skan break; 7738169689Skan 7739169689Skan case PRAGMA_OMP_PARALLEL_SECTIONS: 7740169689Skan block = c_begin_omp_parallel (); 7741169689Skan c_split_parallel_clauses (clauses, &par_clause, &ws_clause); 7742169689Skan stmt = c_parser_omp_sections_scope (parser); 7743169689Skan if (stmt) 7744169689Skan OMP_SECTIONS_CLAUSES (stmt) = ws_clause; 7745169689Skan stmt = c_finish_omp_parallel (par_clause, block); 7746169689Skan OMP_PARALLEL_COMBINED (stmt) = 1; 7747169689Skan break; 7748169689Skan 7749169689Skan default: 7750169689Skan gcc_unreachable (); 7751169689Skan } 7752169689Skan 7753169689Skan return stmt; 7754169689Skan} 7755169689Skan 7756169689Skan/* OpenMP 2.5: 7757169689Skan # pragma omp single single-clause[optseq] new-line 7758169689Skan structured-block 7759169689Skan*/ 7760169689Skan 7761169689Skan#define OMP_SINGLE_CLAUSE_MASK \ 7762169689Skan ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \ 7763169689Skan | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \ 7764169689Skan | (1u << PRAGMA_OMP_CLAUSE_COPYPRIVATE) \ 7765169689Skan | (1u << PRAGMA_OMP_CLAUSE_NOWAIT)) 7766169689Skan 7767169689Skanstatic tree 7768169689Skanc_parser_omp_single (c_parser *parser) 7769169689Skan{ 7770169689Skan tree stmt = make_node (OMP_SINGLE); 7771169689Skan TREE_TYPE (stmt) = void_type_node; 7772169689Skan 7773169689Skan OMP_SINGLE_CLAUSES (stmt) 7774169689Skan = c_parser_omp_all_clauses (parser, OMP_SINGLE_CLAUSE_MASK, 7775169689Skan "#pragma omp single"); 7776169689Skan OMP_SINGLE_BODY (stmt) = c_parser_omp_structured_block (parser); 7777169689Skan 7778169689Skan return add_stmt (stmt); 7779169689Skan} 7780169689Skan 7781169689Skan 7782169689Skan/* Main entry point to parsing most OpenMP pragmas. */ 7783169689Skan 7784169689Skanstatic void 7785169689Skanc_parser_omp_construct (c_parser *parser) 7786169689Skan{ 7787169689Skan enum pragma_kind p_kind; 7788169689Skan location_t loc; 7789169689Skan tree stmt; 7790169689Skan 7791169689Skan loc = c_parser_peek_token (parser)->location; 7792169689Skan p_kind = c_parser_peek_token (parser)->pragma_kind; 7793169689Skan c_parser_consume_pragma (parser); 7794169689Skan 7795169689Skan /* For all constructs below except #pragma omp atomic 7796169689Skan MUST_NOT_THROW catch handlers are needed when exceptions 7797169689Skan are enabled. */ 7798169689Skan if (p_kind != PRAGMA_OMP_ATOMIC) 7799169689Skan c_maybe_initialize_eh (); 7800169689Skan 7801169689Skan switch (p_kind) 7802169689Skan { 7803169689Skan case PRAGMA_OMP_ATOMIC: 7804169689Skan c_parser_omp_atomic (parser); 7805169689Skan return; 7806169689Skan case PRAGMA_OMP_CRITICAL: 7807169689Skan stmt = c_parser_omp_critical (parser); 7808169689Skan break; 7809169689Skan case PRAGMA_OMP_FOR: 7810169689Skan stmt = c_parser_omp_for (parser); 7811169689Skan break; 7812169689Skan case PRAGMA_OMP_MASTER: 7813169689Skan stmt = c_parser_omp_master (parser); 7814169689Skan break; 7815169689Skan case PRAGMA_OMP_ORDERED: 7816169689Skan stmt = c_parser_omp_ordered (parser); 7817169689Skan break; 7818169689Skan case PRAGMA_OMP_PARALLEL: 7819169689Skan stmt = c_parser_omp_parallel (parser); 7820169689Skan break; 7821169689Skan case PRAGMA_OMP_SECTIONS: 7822169689Skan stmt = c_parser_omp_sections (parser); 7823169689Skan break; 7824169689Skan case PRAGMA_OMP_SINGLE: 7825169689Skan stmt = c_parser_omp_single (parser); 7826169689Skan break; 7827169689Skan default: 7828169689Skan gcc_unreachable (); 7829169689Skan } 7830169689Skan 7831169689Skan if (stmt) 7832169689Skan SET_EXPR_LOCATION (stmt, loc); 7833169689Skan} 7834169689Skan 7835169689Skan 7836169689Skan/* OpenMP 2.5: 7837169689Skan # pragma omp threadprivate (variable-list) */ 7838169689Skan 7839169689Skanstatic void 7840169689Skanc_parser_omp_threadprivate (c_parser *parser) 7841169689Skan{ 7842169689Skan tree vars, t; 7843169689Skan 7844169689Skan c_parser_consume_pragma (parser); 7845169689Skan vars = c_parser_omp_var_list_parens (parser, 0, NULL); 7846169689Skan 7847169689Skan if (!targetm.have_tls) 7848169689Skan sorry ("threadprivate variables not supported in this target"); 7849169689Skan 7850169689Skan /* Mark every variable in VARS to be assigned thread local storage. */ 7851169689Skan for (t = vars; t; t = TREE_CHAIN (t)) 7852169689Skan { 7853169689Skan tree v = TREE_PURPOSE (t); 7854169689Skan 7855169689Skan /* If V had already been marked threadprivate, it doesn't matter 7856169689Skan whether it had been used prior to this point. */ 7857169689Skan if (TREE_USED (v) && !C_DECL_THREADPRIVATE_P (v)) 7858169689Skan error ("%qE declared %<threadprivate%> after first use", v); 7859169689Skan else if (! TREE_STATIC (v) && ! DECL_EXTERNAL (v)) 7860169689Skan error ("automatic variable %qE cannot be %<threadprivate%>", v); 7861169689Skan else if (! COMPLETE_TYPE_P (TREE_TYPE (v))) 7862169689Skan error ("%<threadprivate%> %qE has incomplete type", v); 7863169689Skan else 7864169689Skan { 7865169689Skan if (! DECL_THREAD_LOCAL_P (v)) 7866169689Skan { 7867169689Skan DECL_TLS_MODEL (v) = decl_default_tls_model (v); 7868169689Skan /* If rtl has been already set for this var, call 7869169689Skan make_decl_rtl once again, so that encode_section_info 7870169689Skan has a chance to look at the new decl flags. */ 7871169689Skan if (DECL_RTL_SET_P (v)) 7872169689Skan make_decl_rtl (v); 7873169689Skan } 7874169689Skan C_DECL_THREADPRIVATE_P (v) = 1; 7875169689Skan } 7876169689Skan } 7877169689Skan 7878169689Skan c_parser_skip_to_pragma_eol (parser); 7879169689Skan} 7880169689Skan 7881169689Skan 7882169689Skan/* Parse a single source file. */ 7883169689Skan 7884169689Skanvoid 7885169689Skanc_parse_file (void) 7886169689Skan{ 7887169689Skan /* Use local storage to begin. If the first token is a pragma, parse it. 7888169689Skan If it is #pragma GCC pch_preprocess, then this will load a PCH file 7889169689Skan which will cause garbage collection. */ 7890169689Skan c_parser tparser; 7891169689Skan 7892169689Skan memset (&tparser, 0, sizeof tparser); 7893169689Skan the_parser = &tparser; 7894169689Skan 7895169689Skan if (c_parser_peek_token (&tparser)->pragma_kind == PRAGMA_GCC_PCH_PREPROCESS) 7896169689Skan c_parser_pragma_pch_preprocess (&tparser); 7897169689Skan 7898169689Skan the_parser = GGC_NEW (c_parser); 7899169689Skan *the_parser = tparser; 7900169689Skan 7901169689Skan c_parser_translation_unit (the_parser); 7902169689Skan the_parser = NULL; 7903169689Skan} 7904169689Skan 7905169689Skan#include "gt-c-parser.h" 7906