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: 3943169689Skan while (expression) statement 3944169689Skan*/ 3945169689Skan 3946169689Skanstatic void 3947169689Skanc_parser_while_statement (c_parser *parser) 3948169689Skan{ 3949169689Skan tree block, cond, body, save_break, save_cont; 3950169689Skan location_t loc; 3951169689Skan gcc_assert (c_parser_next_token_is_keyword (parser, RID_WHILE)); 3952169689Skan c_parser_consume_token (parser); 3953169689Skan block = c_begin_compound_stmt (flag_isoc99); 3954169689Skan loc = c_parser_peek_token (parser)->location; 3955169689Skan cond = c_parser_paren_condition (parser); 3956169689Skan save_break = c_break_label; 3957169689Skan c_break_label = NULL_TREE; 3958169689Skan save_cont = c_cont_label; 3959169689Skan c_cont_label = NULL_TREE; 3960169689Skan body = c_parser_c99_block_statement (parser); 3961169689Skan c_finish_loop (loc, cond, NULL, body, c_break_label, c_cont_label, true); 3962169689Skan add_stmt (c_end_compound_stmt (block, flag_isoc99)); 3963169689Skan c_break_label = save_break; 3964169689Skan c_cont_label = save_cont; 3965169689Skan} 3966169689Skan 3967169689Skan/* Parse a do statement (C90 6.6.5, C99 6.8.5). 3968169689Skan 3969169689Skan do-statement: 3970169689Skan do statement while ( expression ) ; 3971169689Skan*/ 3972169689Skan 3973169689Skanstatic void 3974169689Skanc_parser_do_statement (c_parser *parser) 3975169689Skan{ 3976169689Skan tree block, cond, body, save_break, save_cont, new_break, new_cont; 3977169689Skan location_t loc; 3978169689Skan gcc_assert (c_parser_next_token_is_keyword (parser, RID_DO)); 3979169689Skan c_parser_consume_token (parser); 3980169689Skan block = c_begin_compound_stmt (flag_isoc99); 3981169689Skan loc = c_parser_peek_token (parser)->location; 3982169689Skan save_break = c_break_label; 3983169689Skan c_break_label = NULL_TREE; 3984169689Skan save_cont = c_cont_label; 3985169689Skan c_cont_label = NULL_TREE; 3986169689Skan body = c_parser_c99_block_statement (parser); 3987169689Skan c_parser_require_keyword (parser, RID_WHILE, "expected %<while%>"); 3988169689Skan new_break = c_break_label; 3989169689Skan c_break_label = save_break; 3990169689Skan new_cont = c_cont_label; 3991169689Skan c_cont_label = save_cont; 3992169689Skan cond = c_parser_paren_condition (parser); 3993169689Skan if (!c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>")) 3994169689Skan c_parser_skip_to_end_of_block_or_statement (parser); 3995169689Skan c_finish_loop (loc, cond, NULL, body, new_break, new_cont, false); 3996169689Skan add_stmt (c_end_compound_stmt (block, flag_isoc99)); 3997169689Skan} 3998169689Skan 3999169689Skan/* Parse a for statement (C90 6.6.5, C99 6.8.5). 4000169689Skan 4001169689Skan for-statement: 4002169689Skan for ( expression[opt] ; expression[opt] ; expression[opt] ) statement 4003169689Skan for ( nested-declaration expression[opt] ; expression[opt] ) statement 4004169689Skan 4005169689Skan The form with a declaration is new in C99. 4006169689Skan 4007169689Skan ??? In accordance with the old parser, the declaration may be a 4008169689Skan nested function, which is then rejected in check_for_loop_decls, 4009169689Skan but does it make any sense for this to be included in the grammar? 4010169689Skan Note in particular that the nested function does not include a 4011169689Skan trailing ';', whereas the "declaration" production includes one. 4012169689Skan Also, can we reject bad declarations earlier and cheaper than 4013169689Skan check_for_loop_decls? */ 4014169689Skan 4015169689Skanstatic void 4016169689Skanc_parser_for_statement (c_parser *parser) 4017169689Skan{ 4018169689Skan tree block, cond, incr, save_break, save_cont, body; 4019169689Skan location_t loc; 4020169689Skan gcc_assert (c_parser_next_token_is_keyword (parser, RID_FOR)); 4021169689Skan loc = c_parser_peek_token (parser)->location; 4022169689Skan c_parser_consume_token (parser); 4023169689Skan block = c_begin_compound_stmt (flag_isoc99); 4024169689Skan if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 4025169689Skan { 4026169689Skan /* Parse the initialization declaration or expression. */ 4027169689Skan if (c_parser_next_token_is (parser, CPP_SEMICOLON)) 4028169689Skan { 4029169689Skan c_parser_consume_token (parser); 4030169689Skan c_finish_expr_stmt (NULL_TREE); 4031169689Skan } 4032169689Skan else if (c_parser_next_token_starts_declspecs (parser)) 4033169689Skan { 4034169689Skan c_parser_declaration_or_fndef (parser, true, true, true, true); 4035169689Skan check_for_loop_decls (); 4036169689Skan } 4037169689Skan else if (c_parser_next_token_is_keyword (parser, RID_EXTENSION)) 4038169689Skan { 4039169689Skan /* __extension__ can start a declaration, but is also an 4040169689Skan unary operator that can start an expression. Consume all 4041169689Skan but the last of a possible series of __extension__ to 4042169689Skan determine which. */ 4043169689Skan while (c_parser_peek_2nd_token (parser)->type == CPP_KEYWORD 4044169689Skan && (c_parser_peek_2nd_token (parser)->keyword 4045169689Skan == RID_EXTENSION)) 4046169689Skan c_parser_consume_token (parser); 4047169689Skan if (c_token_starts_declspecs (c_parser_peek_2nd_token (parser))) 4048169689Skan { 4049169689Skan int ext; 4050169689Skan ext = disable_extension_diagnostics (); 4051169689Skan c_parser_consume_token (parser); 4052169689Skan c_parser_declaration_or_fndef (parser, true, true, true, true); 4053169689Skan restore_extension_diagnostics (ext); 4054169689Skan check_for_loop_decls (); 4055169689Skan } 4056169689Skan else 4057169689Skan goto init_expr; 4058169689Skan } 4059169689Skan else 4060169689Skan { 4061169689Skan init_expr: 4062169689Skan c_finish_expr_stmt (c_parser_expression (parser).value); 4063169689Skan c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>"); 4064169689Skan } 4065169689Skan /* Parse the loop condition. */ 4066169689Skan loc = c_parser_peek_token (parser)->location; 4067169689Skan if (c_parser_next_token_is (parser, CPP_SEMICOLON)) 4068169689Skan { 4069169689Skan c_parser_consume_token (parser); 4070169689Skan cond = NULL_TREE; 4071169689Skan } 4072169689Skan else 4073169689Skan { 4074169689Skan tree ocond = c_parser_expression_conv (parser).value; 4075169689Skan cond = c_objc_common_truthvalue_conversion (ocond); 4076169689Skan if (EXPR_P (cond)) 4077169689Skan SET_EXPR_LOCATION (cond, loc); 4078169689Skan c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>"); 4079169689Skan } 4080169689Skan /* Parse the increment expression. */ 4081169689Skan if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) 4082169689Skan incr = c_process_expr_stmt (NULL_TREE); 4083169689Skan else 4084169689Skan incr = c_process_expr_stmt (c_parser_expression (parser).value); 4085169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>"); 4086169689Skan } 4087169689Skan else 4088169689Skan { 4089169689Skan cond = error_mark_node; 4090169689Skan incr = error_mark_node; 4091169689Skan } 4092169689Skan save_break = c_break_label; 4093169689Skan c_break_label = NULL_TREE; 4094169689Skan save_cont = c_cont_label; 4095169689Skan c_cont_label = NULL_TREE; 4096169689Skan body = c_parser_c99_block_statement (parser); 4097169689Skan c_finish_loop (loc, cond, incr, body, c_break_label, c_cont_label, true); 4098169689Skan add_stmt (c_end_compound_stmt (block, flag_isoc99)); 4099169689Skan c_break_label = save_break; 4100169689Skan c_cont_label = save_cont; 4101169689Skan} 4102169689Skan 4103169689Skan/* Parse an asm statement, a GNU extension. This is a full-blown asm 4104169689Skan statement with inputs, outputs, clobbers, and volatile tag 4105169689Skan allowed. 4106169689Skan 4107169689Skan asm-statement: 4108169689Skan asm type-qualifier[opt] ( asm-argument ) ; 4109169689Skan 4110169689Skan asm-argument: 4111169689Skan asm-string-literal 4112169689Skan asm-string-literal : asm-operands[opt] 4113169689Skan asm-string-literal : asm-operands[opt] : asm-operands[opt] 4114169689Skan asm-string-literal : asm-operands[opt] : asm-operands[opt] : asm-clobbers 4115169689Skan 4116169689Skan Qualifiers other than volatile are accepted in the syntax but 4117169689Skan warned for. */ 4118169689Skan 4119169689Skanstatic tree 4120169689Skanc_parser_asm_statement (c_parser *parser) 4121169689Skan{ 4122169689Skan tree quals, str, outputs, inputs, clobbers, ret; 4123169689Skan bool simple; 4124169689Skan gcc_assert (c_parser_next_token_is_keyword (parser, RID_ASM)); 4125169689Skan c_parser_consume_token (parser); 4126169689Skan if (c_parser_next_token_is_keyword (parser, RID_VOLATILE)) 4127169689Skan { 4128169689Skan quals = c_parser_peek_token (parser)->value; 4129169689Skan c_parser_consume_token (parser); 4130169689Skan } 4131169689Skan else if (c_parser_next_token_is_keyword (parser, RID_CONST) 4132169689Skan || c_parser_next_token_is_keyword (parser, RID_RESTRICT)) 4133169689Skan { 4134169689Skan warning (0, "%E qualifier ignored on asm", 4135169689Skan c_parser_peek_token (parser)->value); 4136169689Skan quals = NULL_TREE; 4137169689Skan c_parser_consume_token (parser); 4138169689Skan } 4139169689Skan else 4140169689Skan quals = NULL_TREE; 4141169689Skan /* ??? Follow the C++ parser rather than using the 4142169689Skan c_lex_string_translate kludge. */ 4143169689Skan c_lex_string_translate = 0; 4144169689Skan if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 4145169689Skan { 4146169689Skan c_lex_string_translate = 1; 4147169689Skan return NULL_TREE; 4148169689Skan } 4149169689Skan str = c_parser_asm_string_literal (parser); 4150169689Skan if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) 4151169689Skan { 4152169689Skan simple = true; 4153169689Skan outputs = NULL_TREE; 4154169689Skan inputs = NULL_TREE; 4155169689Skan clobbers = NULL_TREE; 4156169689Skan goto done_asm; 4157169689Skan } 4158169689Skan if (!c_parser_require (parser, CPP_COLON, "expected %<:%> or %<)%>")) 4159169689Skan { 4160169689Skan c_lex_string_translate = 1; 4161169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); 4162169689Skan return NULL_TREE; 4163169689Skan } 4164169689Skan simple = false; 4165169689Skan /* Parse outputs. */ 4166169689Skan if (c_parser_next_token_is (parser, CPP_COLON) 4167169689Skan || c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) 4168169689Skan outputs = NULL_TREE; 4169169689Skan else 4170169689Skan outputs = c_parser_asm_operands (parser, false); 4171169689Skan if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) 4172169689Skan { 4173169689Skan inputs = NULL_TREE; 4174169689Skan clobbers = NULL_TREE; 4175169689Skan goto done_asm; 4176169689Skan } 4177169689Skan if (!c_parser_require (parser, CPP_COLON, "expected %<:%> or %<)%>")) 4178169689Skan { 4179169689Skan c_lex_string_translate = 1; 4180169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); 4181169689Skan return NULL_TREE; 4182169689Skan } 4183169689Skan /* Parse inputs. */ 4184169689Skan if (c_parser_next_token_is (parser, CPP_COLON) 4185169689Skan || c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) 4186169689Skan inputs = NULL_TREE; 4187169689Skan else 4188169689Skan inputs = c_parser_asm_operands (parser, true); 4189169689Skan if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) 4190169689Skan { 4191169689Skan clobbers = NULL_TREE; 4192169689Skan goto done_asm; 4193169689Skan } 4194169689Skan if (!c_parser_require (parser, CPP_COLON, "expected %<:%> or %<)%>")) 4195169689Skan { 4196169689Skan c_lex_string_translate = 1; 4197169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); 4198169689Skan return NULL_TREE; 4199169689Skan } 4200169689Skan /* Parse clobbers. */ 4201169689Skan clobbers = c_parser_asm_clobbers (parser); 4202169689Skan done_asm: 4203169689Skan c_lex_string_translate = 1; 4204169689Skan if (!c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>")) 4205169689Skan { 4206169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); 4207169689Skan return NULL_TREE; 4208169689Skan } 4209169689Skan if (!c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>")) 4210169689Skan c_parser_skip_to_end_of_block_or_statement (parser); 4211169689Skan ret = build_asm_stmt (quals, build_asm_expr (str, outputs, inputs, 4212169689Skan clobbers, simple)); 4213169689Skan return ret; 4214169689Skan} 4215169689Skan 4216169689Skan/* Parse asm operands, a GNU extension. If CONVERT_P (for inputs but 4217169689Skan not outputs), apply the default conversion of functions and arrays 4218169689Skan to pointers. 4219169689Skan 4220169689Skan asm-operands: 4221169689Skan asm-operand 4222169689Skan asm-operands , asm-operand 4223169689Skan 4224169689Skan asm-operand: 4225169689Skan asm-string-literal ( expression ) 4226169689Skan [ identifier ] asm-string-literal ( expression ) 4227169689Skan*/ 4228169689Skan 4229169689Skanstatic tree 4230169689Skanc_parser_asm_operands (c_parser *parser, bool convert_p) 4231169689Skan{ 4232169689Skan tree list = NULL_TREE; 4233169689Skan while (true) 4234169689Skan { 4235169689Skan tree name, str; 4236169689Skan struct c_expr expr; 4237169689Skan if (c_parser_next_token_is (parser, CPP_OPEN_SQUARE)) 4238169689Skan { 4239169689Skan c_parser_consume_token (parser); 4240169689Skan if (c_parser_next_token_is (parser, CPP_NAME)) 4241169689Skan { 4242169689Skan tree id = c_parser_peek_token (parser)->value; 4243169689Skan c_parser_consume_token (parser); 4244169689Skan name = build_string (IDENTIFIER_LENGTH (id), 4245169689Skan IDENTIFIER_POINTER (id)); 4246169689Skan } 4247169689Skan else 4248169689Skan { 4249169689Skan c_parser_error (parser, "expected identifier"); 4250169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, NULL); 4251169689Skan return NULL_TREE; 4252169689Skan } 4253169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, 4254169689Skan "expected %<]%>"); 4255169689Skan } 4256169689Skan else 4257169689Skan name = NULL_TREE; 4258169689Skan str = c_parser_asm_string_literal (parser); 4259169689Skan if (str == NULL_TREE) 4260169689Skan return NULL_TREE; 4261169689Skan c_lex_string_translate = 1; 4262169689Skan if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 4263169689Skan { 4264169689Skan c_lex_string_translate = 0; 4265169689Skan return NULL_TREE; 4266169689Skan } 4267169689Skan expr = c_parser_expression (parser); 4268169689Skan if (convert_p) 4269169689Skan expr = default_function_array_conversion (expr); 4270169689Skan c_lex_string_translate = 0; 4271169689Skan if (!c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>")) 4272169689Skan { 4273169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); 4274169689Skan return NULL_TREE; 4275169689Skan } 4276169689Skan list = chainon (list, build_tree_list (build_tree_list (name, str), 4277169689Skan expr.value)); 4278169689Skan if (c_parser_next_token_is (parser, CPP_COMMA)) 4279169689Skan c_parser_consume_token (parser); 4280169689Skan else 4281169689Skan break; 4282169689Skan } 4283169689Skan return list; 4284169689Skan} 4285169689Skan 4286169689Skan/* Parse asm clobbers, a GNU extension. 4287169689Skan 4288169689Skan asm-clobbers: 4289169689Skan asm-string-literal 4290169689Skan asm-clobbers , asm-string-literal 4291169689Skan*/ 4292169689Skan 4293169689Skanstatic tree 4294169689Skanc_parser_asm_clobbers (c_parser *parser) 4295169689Skan{ 4296169689Skan tree list = NULL_TREE; 4297169689Skan while (true) 4298169689Skan { 4299169689Skan tree str = c_parser_asm_string_literal (parser); 4300169689Skan if (str) 4301169689Skan list = tree_cons (NULL_TREE, str, list); 4302169689Skan else 4303169689Skan return NULL_TREE; 4304169689Skan if (c_parser_next_token_is (parser, CPP_COMMA)) 4305169689Skan c_parser_consume_token (parser); 4306169689Skan else 4307169689Skan break; 4308169689Skan } 4309169689Skan return list; 4310169689Skan} 4311169689Skan 4312169689Skan/* Parse an expression other than a compound expression; that is, an 4313169689Skan assignment expression (C90 6.3.16, C99 6.5.16). If AFTER is not 4314169689Skan NULL then it is an Objective-C message expression which is the 4315169689Skan primary-expression starting the expression as an initializer. 4316169689Skan 4317169689Skan assignment-expression: 4318169689Skan conditional-expression 4319169689Skan unary-expression assignment-operator assignment-expression 4320169689Skan 4321169689Skan assignment-operator: one of 4322169689Skan = *= /= %= += -= <<= >>= &= ^= |= 4323169689Skan 4324169689Skan In GNU C we accept any conditional expression on the LHS and 4325169689Skan diagnose the invalid lvalue rather than producing a syntax 4326169689Skan error. */ 4327169689Skan 4328169689Skanstatic struct c_expr 4329169689Skanc_parser_expr_no_commas (c_parser *parser, struct c_expr *after) 4330169689Skan{ 4331169689Skan struct c_expr lhs, rhs, ret; 4332169689Skan enum tree_code code; 4333169689Skan gcc_assert (!after || c_dialect_objc ()); 4334169689Skan lhs = c_parser_conditional_expression (parser, after); 4335169689Skan switch (c_parser_peek_token (parser)->type) 4336169689Skan { 4337169689Skan case CPP_EQ: 4338169689Skan code = NOP_EXPR; 4339169689Skan break; 4340169689Skan case CPP_MULT_EQ: 4341169689Skan code = MULT_EXPR; 4342169689Skan break; 4343169689Skan case CPP_DIV_EQ: 4344169689Skan code = TRUNC_DIV_EXPR; 4345169689Skan break; 4346169689Skan case CPP_MOD_EQ: 4347169689Skan code = TRUNC_MOD_EXPR; 4348169689Skan break; 4349169689Skan case CPP_PLUS_EQ: 4350169689Skan code = PLUS_EXPR; 4351169689Skan break; 4352169689Skan case CPP_MINUS_EQ: 4353169689Skan code = MINUS_EXPR; 4354169689Skan break; 4355169689Skan case CPP_LSHIFT_EQ: 4356169689Skan code = LSHIFT_EXPR; 4357169689Skan break; 4358169689Skan case CPP_RSHIFT_EQ: 4359169689Skan code = RSHIFT_EXPR; 4360169689Skan break; 4361169689Skan case CPP_AND_EQ: 4362169689Skan code = BIT_AND_EXPR; 4363169689Skan break; 4364169689Skan case CPP_XOR_EQ: 4365169689Skan code = BIT_XOR_EXPR; 4366169689Skan break; 4367169689Skan case CPP_OR_EQ: 4368169689Skan code = BIT_IOR_EXPR; 4369169689Skan break; 4370169689Skan default: 4371169689Skan return lhs; 4372169689Skan } 4373169689Skan c_parser_consume_token (parser); 4374169689Skan rhs = c_parser_expr_no_commas (parser, NULL); 4375169689Skan rhs = default_function_array_conversion (rhs); 4376169689Skan ret.value = build_modify_expr (lhs.value, code, rhs.value); 4377169689Skan if (code == NOP_EXPR) 4378169689Skan ret.original_code = MODIFY_EXPR; 4379169689Skan else 4380169689Skan { 4381169689Skan TREE_NO_WARNING (ret.value) = 1; 4382169689Skan ret.original_code = ERROR_MARK; 4383169689Skan } 4384169689Skan return ret; 4385169689Skan} 4386169689Skan 4387169689Skan/* Parse a conditional expression (C90 6.3.15, C99 6.5.15). If AFTER 4388169689Skan is not NULL then it is an Objective-C message expression which is 4389169689Skan the primary-expression starting the expression as an initializer. 4390169689Skan 4391169689Skan conditional-expression: 4392169689Skan logical-OR-expression 4393169689Skan logical-OR-expression ? expression : conditional-expression 4394169689Skan 4395169689Skan GNU extensions: 4396169689Skan 4397169689Skan conditional-expression: 4398169689Skan logical-OR-expression ? : conditional-expression 4399169689Skan*/ 4400169689Skan 4401169689Skanstatic struct c_expr 4402169689Skanc_parser_conditional_expression (c_parser *parser, struct c_expr *after) 4403169689Skan{ 4404169689Skan struct c_expr cond, exp1, exp2, ret; 4405169689Skan gcc_assert (!after || c_dialect_objc ()); 4406169689Skan cond = c_parser_binary_expression (parser, after); 4407169689Skan if (c_parser_next_token_is_not (parser, CPP_QUERY)) 4408169689Skan return cond; 4409169689Skan cond = default_function_array_conversion (cond); 4410169689Skan c_parser_consume_token (parser); 4411169689Skan if (c_parser_next_token_is (parser, CPP_COLON)) 4412169689Skan { 4413169689Skan if (pedantic) 4414169689Skan pedwarn ("ISO C forbids omitting the middle term of a ?: expression"); 4415169689Skan /* Make sure first operand is calculated only once. */ 4416169689Skan exp1.value = save_expr (default_conversion (cond.value)); 4417169689Skan cond.value = c_objc_common_truthvalue_conversion (exp1.value); 4418169689Skan skip_evaluation += cond.value == truthvalue_true_node; 4419169689Skan } 4420169689Skan else 4421169689Skan { 4422169689Skan cond.value 4423169689Skan = c_objc_common_truthvalue_conversion 4424169689Skan (default_conversion (cond.value)); 4425169689Skan skip_evaluation += cond.value == truthvalue_false_node; 4426169689Skan exp1 = c_parser_expression_conv (parser); 4427169689Skan skip_evaluation += ((cond.value == truthvalue_true_node) 4428169689Skan - (cond.value == truthvalue_false_node)); 4429169689Skan } 4430169689Skan if (!c_parser_require (parser, CPP_COLON, "expected %<:%>")) 4431169689Skan { 4432169689Skan skip_evaluation -= cond.value == truthvalue_true_node; 4433169689Skan ret.value = error_mark_node; 4434169689Skan ret.original_code = ERROR_MARK; 4435169689Skan return ret; 4436169689Skan } 4437169689Skan exp2 = c_parser_conditional_expression (parser, NULL); 4438169689Skan exp2 = default_function_array_conversion (exp2); 4439169689Skan skip_evaluation -= cond.value == truthvalue_true_node; 4440169689Skan ret.value = build_conditional_expr (cond.value, exp1.value, exp2.value); 4441169689Skan ret.original_code = ERROR_MARK; 4442169689Skan return ret; 4443169689Skan} 4444169689Skan 4445169689Skan/* Parse a binary expression; that is, a logical-OR-expression (C90 4446169689Skan 6.3.5-6.3.14, C99 6.5.5-6.5.14). If AFTER is not NULL then it is 4447169689Skan an Objective-C message expression which is the primary-expression 4448169689Skan starting the expression as an initializer. 4449169689Skan 4450169689Skan multiplicative-expression: 4451169689Skan cast-expression 4452169689Skan multiplicative-expression * cast-expression 4453169689Skan multiplicative-expression / cast-expression 4454169689Skan multiplicative-expression % cast-expression 4455169689Skan 4456169689Skan additive-expression: 4457169689Skan multiplicative-expression 4458169689Skan additive-expression + multiplicative-expression 4459169689Skan additive-expression - multiplicative-expression 4460169689Skan 4461169689Skan shift-expression: 4462169689Skan additive-expression 4463169689Skan shift-expression << additive-expression 4464169689Skan shift-expression >> additive-expression 4465169689Skan 4466169689Skan relational-expression: 4467169689Skan shift-expression 4468169689Skan relational-expression < shift-expression 4469169689Skan relational-expression > shift-expression 4470169689Skan relational-expression <= shift-expression 4471169689Skan relational-expression >= shift-expression 4472169689Skan 4473169689Skan equality-expression: 4474169689Skan relational-expression 4475169689Skan equality-expression == relational-expression 4476169689Skan equality-expression != relational-expression 4477169689Skan 4478169689Skan AND-expression: 4479169689Skan equality-expression 4480169689Skan AND-expression & equality-expression 4481169689Skan 4482169689Skan exclusive-OR-expression: 4483169689Skan AND-expression 4484169689Skan exclusive-OR-expression ^ AND-expression 4485169689Skan 4486169689Skan inclusive-OR-expression: 4487169689Skan exclusive-OR-expression 4488169689Skan inclusive-OR-expression | exclusive-OR-expression 4489169689Skan 4490169689Skan logical-AND-expression: 4491169689Skan inclusive-OR-expression 4492169689Skan logical-AND-expression && inclusive-OR-expression 4493169689Skan 4494169689Skan logical-OR-expression: 4495169689Skan logical-AND-expression 4496169689Skan logical-OR-expression || logical-AND-expression 4497169689Skan*/ 4498169689Skan 4499169689Skanstatic struct c_expr 4500169689Skanc_parser_binary_expression (c_parser *parser, struct c_expr *after) 4501169689Skan{ 4502169689Skan /* A binary expression is parsed using operator-precedence parsing, 4503169689Skan with the operands being cast expressions. All the binary 4504169689Skan operators are left-associative. Thus a binary expression is of 4505169689Skan form: 4506169689Skan 4507169689Skan E0 op1 E1 op2 E2 ... 4508169689Skan 4509169689Skan which we represent on a stack. On the stack, the precedence 4510169689Skan levels are strictly increasing. When a new operator is 4511169689Skan encountered of higher precedence than that at the top of the 4512169689Skan stack, it is pushed; its LHS is the top expression, and its RHS 4513169689Skan is everything parsed until it is popped. When a new operator is 4514169689Skan encountered with precedence less than or equal to that at the top 4515169689Skan of the stack, triples E[i-1] op[i] E[i] are popped and replaced 4516169689Skan by the result of the operation until the operator at the top of 4517169689Skan the stack has lower precedence than the new operator or there is 4518169689Skan only one element on the stack; then the top expression is the LHS 4519169689Skan of the new operator. In the case of logical AND and OR 4520169689Skan expressions, we also need to adjust skip_evaluation as 4521169689Skan appropriate when the operators are pushed and popped. */ 4522169689Skan 4523169689Skan /* The precedence levels, where 0 is a dummy lowest level used for 4524169689Skan the bottom of the stack. */ 4525169689Skan enum prec { 4526169689Skan PREC_NONE, 4527169689Skan PREC_LOGOR, 4528169689Skan PREC_LOGAND, 4529169689Skan PREC_BITOR, 4530169689Skan PREC_BITXOR, 4531169689Skan PREC_BITAND, 4532169689Skan PREC_EQ, 4533169689Skan PREC_REL, 4534169689Skan PREC_SHIFT, 4535169689Skan PREC_ADD, 4536169689Skan PREC_MULT, 4537169689Skan NUM_PRECS 4538169689Skan }; 4539169689Skan struct { 4540169689Skan /* The expression at this stack level. */ 4541169689Skan struct c_expr expr; 4542169689Skan /* The precedence of the operator on its left, PREC_NONE at the 4543169689Skan bottom of the stack. */ 4544169689Skan enum prec prec; 4545169689Skan /* The operation on its left. */ 4546169689Skan enum tree_code op; 4547169689Skan } stack[NUM_PRECS]; 4548169689Skan int sp; 4549169689Skan#define POP \ 4550169689Skan do { \ 4551169689Skan switch (stack[sp].op) \ 4552169689Skan { \ 4553169689Skan case TRUTH_ANDIF_EXPR: \ 4554169689Skan skip_evaluation -= stack[sp - 1].expr.value == truthvalue_false_node; \ 4555169689Skan break; \ 4556169689Skan case TRUTH_ORIF_EXPR: \ 4557169689Skan skip_evaluation -= stack[sp - 1].expr.value == truthvalue_true_node; \ 4558169689Skan break; \ 4559169689Skan default: \ 4560169689Skan break; \ 4561169689Skan } \ 4562169689Skan stack[sp - 1].expr \ 4563169689Skan = default_function_array_conversion (stack[sp - 1].expr); \ 4564169689Skan stack[sp].expr \ 4565169689Skan = default_function_array_conversion (stack[sp].expr); \ 4566169689Skan stack[sp - 1].expr = parser_build_binary_op (stack[sp].op, \ 4567169689Skan stack[sp - 1].expr, \ 4568169689Skan stack[sp].expr); \ 4569169689Skan sp--; \ 4570169689Skan } while (0) 4571169689Skan gcc_assert (!after || c_dialect_objc ()); 4572169689Skan stack[0].expr = c_parser_cast_expression (parser, after); 4573169689Skan stack[0].prec = PREC_NONE; 4574169689Skan sp = 0; 4575169689Skan while (true) 4576169689Skan { 4577169689Skan enum prec oprec; 4578169689Skan enum tree_code ocode; 4579169689Skan if (parser->error) 4580169689Skan goto out; 4581169689Skan switch (c_parser_peek_token (parser)->type) 4582169689Skan { 4583169689Skan case CPP_MULT: 4584169689Skan oprec = PREC_MULT; 4585169689Skan ocode = MULT_EXPR; 4586169689Skan break; 4587169689Skan case CPP_DIV: 4588169689Skan oprec = PREC_MULT; 4589169689Skan ocode = TRUNC_DIV_EXPR; 4590169689Skan break; 4591169689Skan case CPP_MOD: 4592169689Skan oprec = PREC_MULT; 4593169689Skan ocode = TRUNC_MOD_EXPR; 4594169689Skan break; 4595169689Skan case CPP_PLUS: 4596169689Skan oprec = PREC_ADD; 4597169689Skan ocode = PLUS_EXPR; 4598169689Skan break; 4599169689Skan case CPP_MINUS: 4600169689Skan oprec = PREC_ADD; 4601169689Skan ocode = MINUS_EXPR; 4602169689Skan break; 4603169689Skan case CPP_LSHIFT: 4604169689Skan oprec = PREC_SHIFT; 4605169689Skan ocode = LSHIFT_EXPR; 4606169689Skan break; 4607169689Skan case CPP_RSHIFT: 4608169689Skan oprec = PREC_SHIFT; 4609169689Skan ocode = RSHIFT_EXPR; 4610169689Skan break; 4611169689Skan case CPP_LESS: 4612169689Skan oprec = PREC_REL; 4613169689Skan ocode = LT_EXPR; 4614169689Skan break; 4615169689Skan case CPP_GREATER: 4616169689Skan oprec = PREC_REL; 4617169689Skan ocode = GT_EXPR; 4618169689Skan break; 4619169689Skan case CPP_LESS_EQ: 4620169689Skan oprec = PREC_REL; 4621169689Skan ocode = LE_EXPR; 4622169689Skan break; 4623169689Skan case CPP_GREATER_EQ: 4624169689Skan oprec = PREC_REL; 4625169689Skan ocode = GE_EXPR; 4626169689Skan break; 4627169689Skan case CPP_EQ_EQ: 4628169689Skan oprec = PREC_EQ; 4629169689Skan ocode = EQ_EXPR; 4630169689Skan break; 4631169689Skan case CPP_NOT_EQ: 4632169689Skan oprec = PREC_EQ; 4633169689Skan ocode = NE_EXPR; 4634169689Skan break; 4635169689Skan case CPP_AND: 4636169689Skan oprec = PREC_BITAND; 4637169689Skan ocode = BIT_AND_EXPR; 4638169689Skan break; 4639169689Skan case CPP_XOR: 4640169689Skan oprec = PREC_BITXOR; 4641169689Skan ocode = BIT_XOR_EXPR; 4642169689Skan break; 4643169689Skan case CPP_OR: 4644169689Skan oprec = PREC_BITOR; 4645169689Skan ocode = BIT_IOR_EXPR; 4646169689Skan break; 4647169689Skan case CPP_AND_AND: 4648169689Skan oprec = PREC_LOGAND; 4649169689Skan ocode = TRUTH_ANDIF_EXPR; 4650169689Skan break; 4651169689Skan case CPP_OR_OR: 4652169689Skan oprec = PREC_LOGOR; 4653169689Skan ocode = TRUTH_ORIF_EXPR; 4654169689Skan break; 4655169689Skan default: 4656169689Skan /* Not a binary operator, so end of the binary 4657169689Skan expression. */ 4658169689Skan goto out; 4659169689Skan } 4660169689Skan c_parser_consume_token (parser); 4661169689Skan while (oprec <= stack[sp].prec) 4662169689Skan POP; 4663169689Skan switch (ocode) 4664169689Skan { 4665169689Skan case TRUTH_ANDIF_EXPR: 4666169689Skan stack[sp].expr 4667169689Skan = default_function_array_conversion (stack[sp].expr); 4668169689Skan stack[sp].expr.value = c_objc_common_truthvalue_conversion 4669169689Skan (default_conversion (stack[sp].expr.value)); 4670169689Skan skip_evaluation += stack[sp].expr.value == truthvalue_false_node; 4671169689Skan break; 4672169689Skan case TRUTH_ORIF_EXPR: 4673169689Skan stack[sp].expr 4674169689Skan = default_function_array_conversion (stack[sp].expr); 4675169689Skan stack[sp].expr.value = c_objc_common_truthvalue_conversion 4676169689Skan (default_conversion (stack[sp].expr.value)); 4677169689Skan skip_evaluation += stack[sp].expr.value == truthvalue_true_node; 4678169689Skan break; 4679169689Skan default: 4680169689Skan break; 4681169689Skan } 4682169689Skan sp++; 4683169689Skan stack[sp].expr = c_parser_cast_expression (parser, NULL); 4684169689Skan stack[sp].prec = oprec; 4685169689Skan stack[sp].op = ocode; 4686169689Skan } 4687169689Skan out: 4688169689Skan while (sp > 0) 4689169689Skan POP; 4690169689Skan return stack[0].expr; 4691169689Skan#undef POP 4692169689Skan} 4693169689Skan 4694169689Skan/* Parse a cast expression (C90 6.3.4, C99 6.5.4). If AFTER is not 4695169689Skan NULL then it is an Objective-C message expression which is the 4696169689Skan primary-expression starting the expression as an initializer. 4697169689Skan 4698169689Skan cast-expression: 4699169689Skan unary-expression 4700169689Skan ( type-name ) unary-expression 4701169689Skan*/ 4702169689Skan 4703169689Skanstatic struct c_expr 4704169689Skanc_parser_cast_expression (c_parser *parser, struct c_expr *after) 4705169689Skan{ 4706169689Skan gcc_assert (!after || c_dialect_objc ()); 4707169689Skan if (after) 4708169689Skan return c_parser_postfix_expression_after_primary (parser, *after); 4709169689Skan /* If the expression begins with a parenthesized type name, it may 4710169689Skan be either a cast or a compound literal; we need to see whether 4711169689Skan the next character is '{' to tell the difference. If not, it is 4712169689Skan an unary expression. */ 4713169689Skan if (c_parser_next_token_is (parser, CPP_OPEN_PAREN) 4714169689Skan && c_token_starts_typename (c_parser_peek_2nd_token (parser))) 4715169689Skan { 4716169689Skan struct c_type_name *type_name; 4717169689Skan struct c_expr ret; 4718169689Skan struct c_expr expr; 4719169689Skan c_parser_consume_token (parser); 4720169689Skan type_name = c_parser_type_name (parser); 4721169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>"); 4722169689Skan if (type_name == NULL) 4723169689Skan { 4724169689Skan ret.value = error_mark_node; 4725169689Skan ret.original_code = ERROR_MARK; 4726169689Skan return ret; 4727169689Skan } 4728169689Skan 4729169689Skan /* Save casted types in the function's used types hash table. */ 4730169689Skan used_types_insert (type_name->specs->type); 4731169689Skan 4732169689Skan if (c_parser_next_token_is (parser, CPP_OPEN_BRACE)) 4733169689Skan return c_parser_postfix_expression_after_paren_type (parser, 4734169689Skan type_name); 4735169689Skan expr = c_parser_cast_expression (parser, NULL); 4736169689Skan expr = default_function_array_conversion (expr); 4737169689Skan ret.value = c_cast_expr (type_name, expr.value); 4738169689Skan ret.original_code = ERROR_MARK; 4739169689Skan return ret; 4740169689Skan } 4741169689Skan else 4742169689Skan return c_parser_unary_expression (parser); 4743169689Skan} 4744169689Skan 4745169689Skan/* Parse an unary expression (C90 6.3.3, C99 6.5.3). 4746169689Skan 4747169689Skan unary-expression: 4748169689Skan postfix-expression 4749169689Skan ++ unary-expression 4750169689Skan -- unary-expression 4751169689Skan unary-operator cast-expression 4752169689Skan sizeof unary-expression 4753169689Skan sizeof ( type-name ) 4754169689Skan 4755169689Skan unary-operator: one of 4756169689Skan & * + - ~ ! 4757169689Skan 4758169689Skan GNU extensions: 4759169689Skan 4760169689Skan unary-expression: 4761169689Skan __alignof__ unary-expression 4762169689Skan __alignof__ ( type-name ) 4763169689Skan && identifier 4764169689Skan 4765169689Skan unary-operator: one of 4766169689Skan __extension__ __real__ __imag__ 4767169689Skan 4768169689Skan In addition, the GNU syntax treats ++ and -- as unary operators, so 4769169689Skan they may be applied to cast expressions with errors for non-lvalues 4770169689Skan given later. */ 4771169689Skan 4772169689Skanstatic struct c_expr 4773169689Skanc_parser_unary_expression (c_parser *parser) 4774169689Skan{ 4775169689Skan int ext; 4776169689Skan struct c_expr ret, op; 4777169689Skan switch (c_parser_peek_token (parser)->type) 4778169689Skan { 4779169689Skan case CPP_PLUS_PLUS: 4780169689Skan c_parser_consume_token (parser); 4781169689Skan op = c_parser_cast_expression (parser, NULL); 4782169689Skan op = default_function_array_conversion (op); 4783169689Skan return parser_build_unary_op (PREINCREMENT_EXPR, op); 4784169689Skan case CPP_MINUS_MINUS: 4785169689Skan c_parser_consume_token (parser); 4786169689Skan op = c_parser_cast_expression (parser, NULL); 4787169689Skan op = default_function_array_conversion (op); 4788169689Skan return parser_build_unary_op (PREDECREMENT_EXPR, op); 4789169689Skan case CPP_AND: 4790169689Skan c_parser_consume_token (parser); 4791169689Skan return parser_build_unary_op (ADDR_EXPR, 4792169689Skan c_parser_cast_expression (parser, NULL)); 4793169689Skan case CPP_MULT: 4794169689Skan c_parser_consume_token (parser); 4795169689Skan op = c_parser_cast_expression (parser, NULL); 4796169689Skan op = default_function_array_conversion (op); 4797169689Skan ret.value = build_indirect_ref (op.value, "unary *"); 4798169689Skan ret.original_code = ERROR_MARK; 4799169689Skan return ret; 4800169689Skan case CPP_PLUS: 4801169689Skan c_parser_consume_token (parser); 4802169689Skan if (!c_dialect_objc () && !in_system_header) 4803169689Skan warning (OPT_Wtraditional, 4804169689Skan "traditional C rejects the unary plus operator"); 4805169689Skan op = c_parser_cast_expression (parser, NULL); 4806169689Skan op = default_function_array_conversion (op); 4807169689Skan return parser_build_unary_op (CONVERT_EXPR, op); 4808169689Skan case CPP_MINUS: 4809169689Skan c_parser_consume_token (parser); 4810169689Skan op = c_parser_cast_expression (parser, NULL); 4811169689Skan op = default_function_array_conversion (op); 4812169689Skan return parser_build_unary_op (NEGATE_EXPR, op); 4813169689Skan case CPP_COMPL: 4814169689Skan c_parser_consume_token (parser); 4815169689Skan op = c_parser_cast_expression (parser, NULL); 4816169689Skan op = default_function_array_conversion (op); 4817169689Skan return parser_build_unary_op (BIT_NOT_EXPR, op); 4818169689Skan case CPP_NOT: 4819169689Skan c_parser_consume_token (parser); 4820169689Skan op = c_parser_cast_expression (parser, NULL); 4821169689Skan op = default_function_array_conversion (op); 4822169689Skan return parser_build_unary_op (TRUTH_NOT_EXPR, op); 4823169689Skan case CPP_AND_AND: 4824169689Skan /* Refer to the address of a label as a pointer. */ 4825169689Skan c_parser_consume_token (parser); 4826169689Skan if (c_parser_next_token_is (parser, CPP_NAME)) 4827169689Skan { 4828169689Skan ret.value = finish_label_address_expr 4829169689Skan (c_parser_peek_token (parser)->value); 4830169689Skan c_parser_consume_token (parser); 4831169689Skan } 4832169689Skan else 4833169689Skan { 4834169689Skan c_parser_error (parser, "expected identifier"); 4835169689Skan ret.value = error_mark_node; 4836169689Skan } 4837169689Skan ret.original_code = ERROR_MARK; 4838169689Skan return ret; 4839169689Skan case CPP_KEYWORD: 4840169689Skan switch (c_parser_peek_token (parser)->keyword) 4841169689Skan { 4842169689Skan case RID_SIZEOF: 4843169689Skan return c_parser_sizeof_expression (parser); 4844169689Skan case RID_ALIGNOF: 4845169689Skan return c_parser_alignof_expression (parser); 4846169689Skan case RID_EXTENSION: 4847169689Skan c_parser_consume_token (parser); 4848169689Skan ext = disable_extension_diagnostics (); 4849169689Skan ret = c_parser_cast_expression (parser, NULL); 4850169689Skan restore_extension_diagnostics (ext); 4851169689Skan return ret; 4852169689Skan case RID_REALPART: 4853169689Skan c_parser_consume_token (parser); 4854169689Skan op = c_parser_cast_expression (parser, NULL); 4855169689Skan op = default_function_array_conversion (op); 4856169689Skan return parser_build_unary_op (REALPART_EXPR, op); 4857169689Skan case RID_IMAGPART: 4858169689Skan c_parser_consume_token (parser); 4859169689Skan op = c_parser_cast_expression (parser, NULL); 4860169689Skan op = default_function_array_conversion (op); 4861169689Skan return parser_build_unary_op (IMAGPART_EXPR, op); 4862169689Skan default: 4863169689Skan return c_parser_postfix_expression (parser); 4864169689Skan } 4865169689Skan default: 4866169689Skan return c_parser_postfix_expression (parser); 4867169689Skan } 4868169689Skan} 4869169689Skan 4870169689Skan/* Parse a sizeof expression. */ 4871169689Skan 4872169689Skanstatic struct c_expr 4873169689Skanc_parser_sizeof_expression (c_parser *parser) 4874169689Skan{ 4875169689Skan struct c_expr expr; 4876169689Skan gcc_assert (c_parser_next_token_is_keyword (parser, RID_SIZEOF)); 4877169689Skan c_parser_consume_token (parser); 4878169689Skan skip_evaluation++; 4879169689Skan in_sizeof++; 4880169689Skan if (c_parser_next_token_is (parser, CPP_OPEN_PAREN) 4881169689Skan && c_token_starts_typename (c_parser_peek_2nd_token (parser))) 4882169689Skan { 4883169689Skan /* Either sizeof ( type-name ) or sizeof unary-expression 4884169689Skan starting with a compound literal. */ 4885169689Skan struct c_type_name *type_name; 4886169689Skan c_parser_consume_token (parser); 4887169689Skan type_name = c_parser_type_name (parser); 4888169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>"); 4889169689Skan if (type_name == NULL) 4890169689Skan { 4891169689Skan struct c_expr ret; 4892169689Skan skip_evaluation--; 4893169689Skan in_sizeof--; 4894169689Skan ret.value = error_mark_node; 4895169689Skan ret.original_code = ERROR_MARK; 4896169689Skan return ret; 4897169689Skan } 4898169689Skan if (c_parser_next_token_is (parser, CPP_OPEN_BRACE)) 4899169689Skan { 4900169689Skan expr = c_parser_postfix_expression_after_paren_type (parser, 4901169689Skan type_name); 4902169689Skan goto sizeof_expr; 4903169689Skan } 4904169689Skan /* sizeof ( type-name ). */ 4905169689Skan skip_evaluation--; 4906169689Skan in_sizeof--; 4907169689Skan if (type_name->declarator->kind == cdk_array 4908169689Skan && type_name->declarator->u.array.vla_unspec_p) 4909169689Skan { 4910169689Skan /* C99 6.7.5.2p4 */ 4911169689Skan error ("%<[*]%> not allowed in other than a declaration"); 4912169689Skan } 4913169689Skan return c_expr_sizeof_type (type_name); 4914169689Skan } 4915169689Skan else 4916169689Skan { 4917169689Skan expr = c_parser_unary_expression (parser); 4918169689Skan sizeof_expr: 4919169689Skan skip_evaluation--; 4920169689Skan in_sizeof--; 4921169689Skan if (TREE_CODE (expr.value) == COMPONENT_REF 4922169689Skan && DECL_C_BIT_FIELD (TREE_OPERAND (expr.value, 1))) 4923169689Skan error ("%<sizeof%> applied to a bit-field"); 4924169689Skan return c_expr_sizeof_expr (expr); 4925169689Skan } 4926169689Skan} 4927169689Skan 4928169689Skan/* Parse an alignof expression. */ 4929169689Skan 4930169689Skanstatic struct c_expr 4931169689Skanc_parser_alignof_expression (c_parser *parser) 4932169689Skan{ 4933169689Skan struct c_expr expr; 4934169689Skan gcc_assert (c_parser_next_token_is_keyword (parser, RID_ALIGNOF)); 4935169689Skan c_parser_consume_token (parser); 4936169689Skan skip_evaluation++; 4937169689Skan in_alignof++; 4938169689Skan if (c_parser_next_token_is (parser, CPP_OPEN_PAREN) 4939169689Skan && c_token_starts_typename (c_parser_peek_2nd_token (parser))) 4940169689Skan { 4941169689Skan /* Either __alignof__ ( type-name ) or __alignof__ 4942169689Skan unary-expression starting with a compound literal. */ 4943169689Skan struct c_type_name *type_name; 4944169689Skan struct c_expr ret; 4945169689Skan c_parser_consume_token (parser); 4946169689Skan type_name = c_parser_type_name (parser); 4947169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>"); 4948169689Skan if (type_name == NULL) 4949169689Skan { 4950169689Skan struct c_expr ret; 4951169689Skan skip_evaluation--; 4952169689Skan in_alignof--; 4953169689Skan ret.value = error_mark_node; 4954169689Skan ret.original_code = ERROR_MARK; 4955169689Skan return ret; 4956169689Skan } 4957169689Skan if (c_parser_next_token_is (parser, CPP_OPEN_BRACE)) 4958169689Skan { 4959169689Skan expr = c_parser_postfix_expression_after_paren_type (parser, 4960169689Skan type_name); 4961169689Skan goto alignof_expr; 4962169689Skan } 4963169689Skan /* alignof ( type-name ). */ 4964169689Skan skip_evaluation--; 4965169689Skan in_alignof--; 4966169689Skan ret.value = c_alignof (groktypename (type_name)); 4967169689Skan ret.original_code = ERROR_MARK; 4968169689Skan return ret; 4969169689Skan } 4970169689Skan else 4971169689Skan { 4972169689Skan struct c_expr ret; 4973169689Skan expr = c_parser_unary_expression (parser); 4974169689Skan alignof_expr: 4975169689Skan skip_evaluation--; 4976169689Skan in_alignof--; 4977169689Skan ret.value = c_alignof_expr (expr.value); 4978169689Skan ret.original_code = ERROR_MARK; 4979169689Skan return ret; 4980169689Skan } 4981169689Skan} 4982169689Skan 4983169689Skan/* Parse a postfix expression (C90 6.3.1-6.3.2, C99 6.5.1-6.5.2). 4984169689Skan 4985169689Skan postfix-expression: 4986169689Skan primary-expression 4987169689Skan postfix-expression [ expression ] 4988169689Skan postfix-expression ( argument-expression-list[opt] ) 4989169689Skan postfix-expression . identifier 4990169689Skan postfix-expression -> identifier 4991169689Skan postfix-expression ++ 4992169689Skan postfix-expression -- 4993169689Skan ( type-name ) { initializer-list } 4994169689Skan ( type-name ) { initializer-list , } 4995169689Skan 4996169689Skan argument-expression-list: 4997169689Skan argument-expression 4998169689Skan argument-expression-list , argument-expression 4999169689Skan 5000169689Skan primary-expression: 5001169689Skan identifier 5002169689Skan constant 5003169689Skan string-literal 5004169689Skan ( expression ) 5005169689Skan 5006169689Skan GNU extensions: 5007169689Skan 5008169689Skan primary-expression: 5009169689Skan __func__ 5010169689Skan (treated as a keyword in GNU C) 5011169689Skan __FUNCTION__ 5012169689Skan __PRETTY_FUNCTION__ 5013169689Skan ( compound-statement ) 5014169689Skan __builtin_va_arg ( assignment-expression , type-name ) 5015169689Skan __builtin_offsetof ( type-name , offsetof-member-designator ) 5016169689Skan __builtin_choose_expr ( assignment-expression , 5017169689Skan assignment-expression , 5018169689Skan assignment-expression ) 5019169689Skan __builtin_types_compatible_p ( type-name , type-name ) 5020169689Skan 5021169689Skan offsetof-member-designator: 5022169689Skan identifier 5023169689Skan offsetof-member-designator . identifier 5024169689Skan offsetof-member-designator [ expression ] 5025169689Skan 5026169689Skan Objective-C: 5027169689Skan 5028169689Skan primary-expression: 5029169689Skan [ objc-receiver objc-message-args ] 5030169689Skan @selector ( objc-selector-arg ) 5031169689Skan @protocol ( identifier ) 5032169689Skan @encode ( type-name ) 5033169689Skan objc-string-literal 5034169689Skan*/ 5035169689Skan 5036169689Skanstatic struct c_expr 5037169689Skanc_parser_postfix_expression (c_parser *parser) 5038169689Skan{ 5039169689Skan struct c_expr expr, e1, e2, e3; 5040169689Skan struct c_type_name *t1, *t2; 5041169689Skan switch (c_parser_peek_token (parser)->type) 5042169689Skan { 5043169689Skan case CPP_NUMBER: 5044169689Skan case CPP_CHAR: 5045169689Skan case CPP_WCHAR: 5046169689Skan expr.value = c_parser_peek_token (parser)->value; 5047169689Skan expr.original_code = ERROR_MARK; 5048169689Skan c_parser_consume_token (parser); 5049169689Skan break; 5050169689Skan case CPP_STRING: 5051169689Skan case CPP_WSTRING: 5052169689Skan expr.value = c_parser_peek_token (parser)->value; 5053169689Skan expr.original_code = STRING_CST; 5054169689Skan c_parser_consume_token (parser); 5055169689Skan break; 5056169689Skan case CPP_OBJC_STRING: 5057169689Skan gcc_assert (c_dialect_objc ()); 5058169689Skan expr.value 5059169689Skan = objc_build_string_object (c_parser_peek_token (parser)->value); 5060169689Skan expr.original_code = ERROR_MARK; 5061169689Skan c_parser_consume_token (parser); 5062169689Skan break; 5063169689Skan case CPP_NAME: 5064169689Skan if (c_parser_peek_token (parser)->id_kind != C_ID_ID) 5065169689Skan { 5066169689Skan c_parser_error (parser, "expected expression"); 5067169689Skan expr.value = error_mark_node; 5068169689Skan expr.original_code = ERROR_MARK; 5069169689Skan break; 5070169689Skan } 5071169689Skan { 5072169689Skan tree id = c_parser_peek_token (parser)->value; 5073169689Skan location_t loc = c_parser_peek_token (parser)->location; 5074169689Skan c_parser_consume_token (parser); 5075169689Skan expr.value = build_external_ref (id, 5076169689Skan (c_parser_peek_token (parser)->type 5077169689Skan == CPP_OPEN_PAREN), loc); 5078169689Skan expr.original_code = ERROR_MARK; 5079169689Skan } 5080169689Skan break; 5081169689Skan case CPP_OPEN_PAREN: 5082169689Skan /* A parenthesized expression, statement expression or compound 5083169689Skan literal. */ 5084169689Skan if (c_parser_peek_2nd_token (parser)->type == CPP_OPEN_BRACE) 5085169689Skan { 5086169689Skan /* A statement expression. */ 5087169689Skan tree stmt; 5088169689Skan c_parser_consume_token (parser); 5089169689Skan c_parser_consume_token (parser); 5090169689Skan if (cur_stmt_list == NULL) 5091169689Skan { 5092169689Skan error ("braced-group within expression allowed " 5093169689Skan "only inside a function"); 5094169689Skan parser->error = true; 5095169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL); 5096169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); 5097169689Skan expr.value = error_mark_node; 5098169689Skan expr.original_code = ERROR_MARK; 5099169689Skan break; 5100169689Skan } 5101169689Skan stmt = c_begin_stmt_expr (); 5102169689Skan c_parser_compound_statement_nostart (parser); 5103169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 5104169689Skan "expected %<)%>"); 5105169689Skan if (pedantic) 5106169689Skan pedwarn ("ISO C forbids braced-groups within expressions"); 5107169689Skan expr.value = c_finish_stmt_expr (stmt); 5108169689Skan expr.original_code = ERROR_MARK; 5109169689Skan } 5110169689Skan else if (c_token_starts_typename (c_parser_peek_2nd_token (parser))) 5111169689Skan { 5112169689Skan /* A compound literal. ??? Can we actually get here rather 5113169689Skan than going directly to 5114169689Skan c_parser_postfix_expression_after_paren_type from 5115169689Skan elsewhere? */ 5116169689Skan struct c_type_name *type_name; 5117169689Skan c_parser_consume_token (parser); 5118169689Skan type_name = c_parser_type_name (parser); 5119169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 5120169689Skan "expected %<)%>"); 5121169689Skan if (type_name == NULL) 5122169689Skan { 5123169689Skan expr.value = error_mark_node; 5124169689Skan expr.original_code = ERROR_MARK; 5125169689Skan } 5126169689Skan else 5127169689Skan expr = c_parser_postfix_expression_after_paren_type (parser, 5128169689Skan type_name); 5129169689Skan } 5130169689Skan else 5131169689Skan { 5132169689Skan /* A parenthesized expression. */ 5133169689Skan c_parser_consume_token (parser); 5134169689Skan expr = c_parser_expression (parser); 5135169689Skan if (TREE_CODE (expr.value) == MODIFY_EXPR) 5136169689Skan TREE_NO_WARNING (expr.value) = 1; 5137169689Skan expr.original_code = ERROR_MARK; 5138169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 5139169689Skan "expected %<)%>"); 5140169689Skan } 5141169689Skan break; 5142169689Skan case CPP_KEYWORD: 5143169689Skan switch (c_parser_peek_token (parser)->keyword) 5144169689Skan { 5145169689Skan case RID_FUNCTION_NAME: 5146169689Skan case RID_PRETTY_FUNCTION_NAME: 5147169689Skan case RID_C99_FUNCTION_NAME: 5148169689Skan expr.value = fname_decl (c_parser_peek_token (parser)->keyword, 5149169689Skan c_parser_peek_token (parser)->value); 5150169689Skan expr.original_code = ERROR_MARK; 5151169689Skan c_parser_consume_token (parser); 5152169689Skan break; 5153169689Skan case RID_VA_ARG: 5154169689Skan c_parser_consume_token (parser); 5155169689Skan if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 5156169689Skan { 5157169689Skan expr.value = error_mark_node; 5158169689Skan expr.original_code = ERROR_MARK; 5159169689Skan break; 5160169689Skan } 5161169689Skan e1 = c_parser_expr_no_commas (parser, NULL); 5162169689Skan if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>")) 5163169689Skan { 5164169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); 5165169689Skan expr.value = error_mark_node; 5166169689Skan expr.original_code = ERROR_MARK; 5167169689Skan break; 5168169689Skan } 5169169689Skan t1 = c_parser_type_name (parser); 5170169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 5171169689Skan "expected %<)%>"); 5172169689Skan if (t1 == NULL) 5173169689Skan { 5174169689Skan expr.value = error_mark_node; 5175169689Skan expr.original_code = ERROR_MARK; 5176169689Skan } 5177169689Skan else 5178169689Skan { 5179169689Skan expr.value = build_va_arg (e1.value, groktypename (t1)); 5180169689Skan expr.original_code = ERROR_MARK; 5181169689Skan } 5182169689Skan break; 5183169689Skan case RID_OFFSETOF: 5184169689Skan c_parser_consume_token (parser); 5185169689Skan if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 5186169689Skan { 5187169689Skan expr.value = error_mark_node; 5188169689Skan expr.original_code = ERROR_MARK; 5189169689Skan break; 5190169689Skan } 5191169689Skan t1 = c_parser_type_name (parser); 5192169689Skan if (t1 == NULL) 5193169689Skan { 5194169689Skan expr.value = error_mark_node; 5195169689Skan expr.original_code = ERROR_MARK; 5196169689Skan break; 5197169689Skan } 5198169689Skan if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>")) 5199169689Skan { 5200169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); 5201169689Skan expr.value = error_mark_node; 5202169689Skan expr.original_code = ERROR_MARK; 5203169689Skan break; 5204169689Skan } 5205169689Skan { 5206169689Skan tree type = groktypename (t1); 5207169689Skan tree offsetof_ref; 5208169689Skan if (type == error_mark_node) 5209169689Skan offsetof_ref = error_mark_node; 5210169689Skan else 5211169689Skan offsetof_ref = build1 (INDIRECT_REF, type, null_pointer_node); 5212169689Skan /* Parse the second argument to __builtin_offsetof. We 5213169689Skan must have one identifier, and beyond that we want to 5214169689Skan accept sub structure and sub array references. */ 5215169689Skan if (c_parser_next_token_is (parser, CPP_NAME)) 5216169689Skan { 5217169689Skan offsetof_ref = build_component_ref 5218169689Skan (offsetof_ref, c_parser_peek_token (parser)->value); 5219169689Skan c_parser_consume_token (parser); 5220169689Skan while (c_parser_next_token_is (parser, CPP_DOT) 5221169689Skan || c_parser_next_token_is (parser, 5222169689Skan CPP_OPEN_SQUARE)) 5223169689Skan { 5224169689Skan if (c_parser_next_token_is (parser, CPP_DOT)) 5225169689Skan { 5226169689Skan c_parser_consume_token (parser); 5227169689Skan if (c_parser_next_token_is_not (parser, 5228169689Skan CPP_NAME)) 5229169689Skan { 5230169689Skan c_parser_error (parser, "expected identifier"); 5231169689Skan break; 5232169689Skan } 5233169689Skan offsetof_ref = build_component_ref 5234169689Skan (offsetof_ref, 5235169689Skan c_parser_peek_token (parser)->value); 5236169689Skan c_parser_consume_token (parser); 5237169689Skan } 5238169689Skan else 5239169689Skan { 5240169689Skan tree idx; 5241169689Skan c_parser_consume_token (parser); 5242169689Skan idx = c_parser_expression (parser).value; 5243169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, 5244169689Skan "expected %<]%>"); 5245169689Skan offsetof_ref = build_array_ref (offsetof_ref, idx); 5246169689Skan } 5247169689Skan } 5248169689Skan } 5249169689Skan else 5250169689Skan c_parser_error (parser, "expected identifier"); 5251169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 5252169689Skan "expected %<)%>"); 5253169689Skan expr.value = fold_offsetof (offsetof_ref, NULL_TREE); 5254169689Skan expr.original_code = ERROR_MARK; 5255169689Skan } 5256169689Skan break; 5257169689Skan case RID_CHOOSE_EXPR: 5258169689Skan c_parser_consume_token (parser); 5259169689Skan if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 5260169689Skan { 5261169689Skan expr.value = error_mark_node; 5262169689Skan expr.original_code = ERROR_MARK; 5263169689Skan break; 5264169689Skan } 5265169689Skan e1 = c_parser_expr_no_commas (parser, NULL); 5266169689Skan if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>")) 5267169689Skan { 5268169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); 5269169689Skan expr.value = error_mark_node; 5270169689Skan expr.original_code = ERROR_MARK; 5271169689Skan break; 5272169689Skan } 5273169689Skan e2 = c_parser_expr_no_commas (parser, NULL); 5274169689Skan if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>")) 5275169689Skan { 5276169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); 5277169689Skan expr.value = error_mark_node; 5278169689Skan expr.original_code = ERROR_MARK; 5279169689Skan break; 5280169689Skan } 5281169689Skan e3 = c_parser_expr_no_commas (parser, NULL); 5282169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 5283169689Skan "expected %<)%>"); 5284169689Skan { 5285169689Skan tree c; 5286169689Skan 5287169689Skan c = fold (e1.value); 5288169689Skan if (TREE_CODE (c) != INTEGER_CST) 5289169689Skan error ("first argument to %<__builtin_choose_expr%> not" 5290169689Skan " a constant"); 5291169689Skan expr = integer_zerop (c) ? e3 : e2; 5292169689Skan } 5293169689Skan break; 5294169689Skan case RID_TYPES_COMPATIBLE_P: 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 t1 = c_parser_type_name (parser); 5303169689Skan if (t1 == NULL) 5304169689Skan { 5305169689Skan expr.value = error_mark_node; 5306169689Skan expr.original_code = ERROR_MARK; 5307169689Skan break; 5308169689Skan } 5309169689Skan if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>")) 5310169689Skan { 5311169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); 5312169689Skan expr.value = error_mark_node; 5313169689Skan expr.original_code = ERROR_MARK; 5314169689Skan break; 5315169689Skan } 5316169689Skan t2 = c_parser_type_name (parser); 5317169689Skan if (t2 == NULL) 5318169689Skan { 5319169689Skan expr.value = error_mark_node; 5320169689Skan expr.original_code = ERROR_MARK; 5321169689Skan break; 5322169689Skan } 5323169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 5324169689Skan "expected %<)%>"); 5325169689Skan { 5326169689Skan tree e1, e2; 5327169689Skan 5328169689Skan e1 = TYPE_MAIN_VARIANT (groktypename (t1)); 5329169689Skan e2 = TYPE_MAIN_VARIANT (groktypename (t2)); 5330169689Skan 5331169689Skan expr.value = comptypes (e1, e2) 5332169689Skan ? build_int_cst (NULL_TREE, 1) 5333169689Skan : build_int_cst (NULL_TREE, 0); 5334169689Skan expr.original_code = ERROR_MARK; 5335169689Skan } 5336169689Skan break; 5337169689Skan case RID_AT_SELECTOR: 5338169689Skan gcc_assert (c_dialect_objc ()); 5339169689Skan c_parser_consume_token (parser); 5340169689Skan if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 5341169689Skan { 5342169689Skan expr.value = error_mark_node; 5343169689Skan expr.original_code = ERROR_MARK; 5344169689Skan break; 5345169689Skan } 5346169689Skan { 5347169689Skan tree sel = c_parser_objc_selector_arg (parser); 5348169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 5349169689Skan "expected %<)%>"); 5350169689Skan expr.value = objc_build_selector_expr (sel); 5351169689Skan expr.original_code = ERROR_MARK; 5352169689Skan } 5353169689Skan break; 5354169689Skan case RID_AT_PROTOCOL: 5355169689Skan gcc_assert (c_dialect_objc ()); 5356169689Skan c_parser_consume_token (parser); 5357169689Skan if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 5358169689Skan { 5359169689Skan expr.value = error_mark_node; 5360169689Skan expr.original_code = ERROR_MARK; 5361169689Skan break; 5362169689Skan } 5363169689Skan if (c_parser_next_token_is_not (parser, CPP_NAME)) 5364169689Skan { 5365169689Skan c_parser_error (parser, "expected identifier"); 5366169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); 5367169689Skan expr.value = error_mark_node; 5368169689Skan expr.original_code = ERROR_MARK; 5369169689Skan break; 5370169689Skan } 5371169689Skan { 5372169689Skan tree id = c_parser_peek_token (parser)->value; 5373169689Skan c_parser_consume_token (parser); 5374169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 5375169689Skan "expected %<)%>"); 5376169689Skan expr.value = objc_build_protocol_expr (id); 5377169689Skan expr.original_code = ERROR_MARK; 5378169689Skan } 5379169689Skan break; 5380169689Skan case RID_AT_ENCODE: 5381169689Skan /* Extension to support C-structures in the archiver. */ 5382169689Skan gcc_assert (c_dialect_objc ()); 5383169689Skan c_parser_consume_token (parser); 5384169689Skan if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 5385169689Skan { 5386169689Skan expr.value = error_mark_node; 5387169689Skan expr.original_code = ERROR_MARK; 5388169689Skan break; 5389169689Skan } 5390169689Skan t1 = c_parser_type_name (parser); 5391169689Skan if (t1 == NULL) 5392169689Skan { 5393169689Skan expr.value = error_mark_node; 5394169689Skan expr.original_code = ERROR_MARK; 5395169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); 5396169689Skan break; 5397169689Skan } 5398169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 5399169689Skan "expected %<)%>"); 5400169689Skan { 5401169689Skan tree type = groktypename (t1); 5402169689Skan expr.value = objc_build_encode_expr (type); 5403169689Skan expr.original_code = ERROR_MARK; 5404169689Skan } 5405169689Skan break; 5406169689Skan default: 5407169689Skan c_parser_error (parser, "expected expression"); 5408169689Skan expr.value = error_mark_node; 5409169689Skan expr.original_code = ERROR_MARK; 5410169689Skan break; 5411169689Skan } 5412169689Skan break; 5413169689Skan case CPP_OPEN_SQUARE: 5414169689Skan if (c_dialect_objc ()) 5415169689Skan { 5416169689Skan tree receiver, args; 5417169689Skan c_parser_consume_token (parser); 5418169689Skan receiver = c_parser_objc_receiver (parser); 5419169689Skan args = c_parser_objc_message_args (parser); 5420169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, 5421169689Skan "expected %<]%>"); 5422169689Skan expr.value = objc_build_message_expr (build_tree_list (receiver, 5423169689Skan args)); 5424169689Skan expr.original_code = ERROR_MARK; 5425169689Skan break; 5426169689Skan } 5427169689Skan /* Else fall through to report error. */ 5428169689Skan default: 5429169689Skan c_parser_error (parser, "expected expression"); 5430169689Skan expr.value = error_mark_node; 5431169689Skan expr.original_code = ERROR_MARK; 5432169689Skan break; 5433169689Skan } 5434169689Skan return c_parser_postfix_expression_after_primary (parser, expr); 5435169689Skan} 5436169689Skan 5437169689Skan/* Parse a postfix expression after a parenthesized type name: the 5438169689Skan brace-enclosed initializer of a compound literal, possibly followed 5439169689Skan by some postfix operators. This is separate because it is not 5440169689Skan possible to tell until after the type name whether a cast 5441169689Skan expression has a cast or a compound literal, or whether the operand 5442169689Skan of sizeof is a parenthesized type name or starts with a compound 5443169689Skan literal. */ 5444169689Skan 5445169689Skanstatic struct c_expr 5446169689Skanc_parser_postfix_expression_after_paren_type (c_parser *parser, 5447169689Skan struct c_type_name *type_name) 5448169689Skan{ 5449169689Skan tree type; 5450169689Skan struct c_expr init; 5451169689Skan struct c_expr expr; 5452169689Skan start_init (NULL_TREE, NULL, 0); 5453169689Skan type = groktypename (type_name); 5454169689Skan if (type != error_mark_node && C_TYPE_VARIABLE_SIZE (type)) 5455169689Skan { 5456169689Skan error ("compound literal has variable size"); 5457169689Skan type = error_mark_node; 5458169689Skan } 5459169689Skan init = c_parser_braced_init (parser, type, false); 5460169689Skan finish_init (); 5461169689Skan maybe_warn_string_init (type, init); 5462169689Skan 5463169689Skan if (pedantic && !flag_isoc99) 5464169689Skan pedwarn ("ISO C90 forbids compound literals"); 5465169689Skan expr.value = build_compound_literal (type, init.value); 5466169689Skan expr.original_code = ERROR_MARK; 5467169689Skan return c_parser_postfix_expression_after_primary (parser, expr); 5468169689Skan} 5469169689Skan 5470169689Skan/* Parse a postfix expression after the initial primary or compound 5471169689Skan literal; that is, parse a series of postfix operators. */ 5472169689Skan 5473169689Skanstatic struct c_expr 5474169689Skanc_parser_postfix_expression_after_primary (c_parser *parser, 5475169689Skan struct c_expr expr) 5476169689Skan{ 5477169689Skan tree ident, idx, exprlist; 5478169689Skan while (true) 5479169689Skan { 5480169689Skan switch (c_parser_peek_token (parser)->type) 5481169689Skan { 5482169689Skan case CPP_OPEN_SQUARE: 5483169689Skan /* Array reference. */ 5484169689Skan c_parser_consume_token (parser); 5485169689Skan idx = c_parser_expression (parser).value; 5486169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, 5487169689Skan "expected %<]%>"); 5488169689Skan expr.value = build_array_ref (expr.value, idx); 5489169689Skan expr.original_code = ERROR_MARK; 5490169689Skan break; 5491169689Skan case CPP_OPEN_PAREN: 5492169689Skan /* Function call. */ 5493169689Skan c_parser_consume_token (parser); 5494169689Skan if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) 5495169689Skan exprlist = NULL_TREE; 5496169689Skan else 5497169689Skan exprlist = c_parser_expr_list (parser, true); 5498169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 5499169689Skan "expected %<)%>"); 5500169689Skan expr.value = build_function_call (expr.value, exprlist); 5501169689Skan expr.original_code = ERROR_MARK; 5502169689Skan break; 5503169689Skan case CPP_DOT: 5504169689Skan /* Structure element reference. */ 5505169689Skan c_parser_consume_token (parser); 5506169689Skan expr = default_function_array_conversion (expr); 5507169689Skan if (c_parser_next_token_is (parser, CPP_NAME)) 5508169689Skan ident = c_parser_peek_token (parser)->value; 5509169689Skan else 5510169689Skan { 5511169689Skan c_parser_error (parser, "expected identifier"); 5512169689Skan expr.value = error_mark_node; 5513169689Skan expr.original_code = ERROR_MARK; 5514169689Skan return expr; 5515169689Skan } 5516169689Skan c_parser_consume_token (parser); 5517169689Skan expr.value = build_component_ref (expr.value, ident); 5518169689Skan expr.original_code = ERROR_MARK; 5519169689Skan break; 5520169689Skan case CPP_DEREF: 5521169689Skan /* Structure element reference. */ 5522169689Skan c_parser_consume_token (parser); 5523169689Skan expr = default_function_array_conversion (expr); 5524169689Skan if (c_parser_next_token_is (parser, CPP_NAME)) 5525169689Skan ident = c_parser_peek_token (parser)->value; 5526169689Skan else 5527169689Skan { 5528169689Skan c_parser_error (parser, "expected identifier"); 5529169689Skan expr.value = error_mark_node; 5530169689Skan expr.original_code = ERROR_MARK; 5531169689Skan return expr; 5532169689Skan } 5533169689Skan c_parser_consume_token (parser); 5534169689Skan expr.value = build_component_ref (build_indirect_ref (expr.value, 5535169689Skan "->"), ident); 5536169689Skan expr.original_code = ERROR_MARK; 5537169689Skan break; 5538169689Skan case CPP_PLUS_PLUS: 5539169689Skan /* Postincrement. */ 5540169689Skan c_parser_consume_token (parser); 5541169689Skan expr = default_function_array_conversion (expr); 5542169689Skan expr.value = build_unary_op (POSTINCREMENT_EXPR, expr.value, 0); 5543169689Skan expr.original_code = ERROR_MARK; 5544169689Skan break; 5545169689Skan case CPP_MINUS_MINUS: 5546169689Skan /* Postdecrement. */ 5547169689Skan c_parser_consume_token (parser); 5548169689Skan expr = default_function_array_conversion (expr); 5549169689Skan expr.value = build_unary_op (POSTDECREMENT_EXPR, expr.value, 0); 5550169689Skan expr.original_code = ERROR_MARK; 5551169689Skan break; 5552169689Skan default: 5553169689Skan return expr; 5554169689Skan } 5555169689Skan } 5556169689Skan} 5557169689Skan 5558169689Skan/* Parse an expression (C90 6.3.17, C99 6.5.17). 5559169689Skan 5560169689Skan expression: 5561169689Skan assignment-expression 5562169689Skan expression , assignment-expression 5563169689Skan*/ 5564169689Skan 5565169689Skanstatic struct c_expr 5566169689Skanc_parser_expression (c_parser *parser) 5567169689Skan{ 5568169689Skan struct c_expr expr; 5569169689Skan expr = c_parser_expr_no_commas (parser, NULL); 5570169689Skan while (c_parser_next_token_is (parser, CPP_COMMA)) 5571169689Skan { 5572169689Skan struct c_expr next; 5573169689Skan c_parser_consume_token (parser); 5574169689Skan next = c_parser_expr_no_commas (parser, NULL); 5575169689Skan next = default_function_array_conversion (next); 5576169689Skan expr.value = build_compound_expr (expr.value, next.value); 5577169689Skan expr.original_code = COMPOUND_EXPR; 5578169689Skan } 5579169689Skan return expr; 5580169689Skan} 5581169689Skan 5582169689Skan/* Parse an expression and convert functions or arrays to 5583169689Skan pointers. */ 5584169689Skan 5585169689Skanstatic struct c_expr 5586169689Skanc_parser_expression_conv (c_parser *parser) 5587169689Skan{ 5588169689Skan struct c_expr expr; 5589169689Skan expr = c_parser_expression (parser); 5590169689Skan expr = default_function_array_conversion (expr); 5591169689Skan return expr; 5592169689Skan} 5593169689Skan 5594169689Skan/* Parse a non-empty list of expressions. If CONVERT_P, convert 5595169689Skan functions and arrays to pointers. 5596169689Skan 5597169689Skan nonempty-expr-list: 5598169689Skan assignment-expression 5599169689Skan nonempty-expr-list , assignment-expression 5600169689Skan*/ 5601169689Skan 5602169689Skanstatic tree 5603169689Skanc_parser_expr_list (c_parser *parser, bool convert_p) 5604169689Skan{ 5605169689Skan struct c_expr expr; 5606169689Skan tree ret, cur; 5607169689Skan expr = c_parser_expr_no_commas (parser, NULL); 5608169689Skan if (convert_p) 5609169689Skan expr = default_function_array_conversion (expr); 5610169689Skan ret = cur = build_tree_list (NULL_TREE, expr.value); 5611169689Skan while (c_parser_next_token_is (parser, CPP_COMMA)) 5612169689Skan { 5613169689Skan c_parser_consume_token (parser); 5614169689Skan expr = c_parser_expr_no_commas (parser, NULL); 5615169689Skan if (convert_p) 5616169689Skan expr = default_function_array_conversion (expr); 5617169689Skan cur = TREE_CHAIN (cur) = build_tree_list (NULL_TREE, expr.value); 5618169689Skan } 5619169689Skan return ret; 5620169689Skan} 5621169689Skan 5622169689Skan 5623169689Skan/* Parse Objective-C-specific constructs. */ 5624169689Skan 5625169689Skan/* Parse an objc-class-definition. 5626169689Skan 5627169689Skan objc-class-definition: 5628169689Skan @interface identifier objc-superclass[opt] objc-protocol-refs[opt] 5629169689Skan objc-class-instance-variables[opt] objc-methodprotolist @end 5630169689Skan @implementation identifier objc-superclass[opt] 5631169689Skan objc-class-instance-variables[opt] 5632169689Skan @interface identifier ( identifier ) objc-protocol-refs[opt] 5633169689Skan objc-methodprotolist @end 5634169689Skan @implementation identifier ( identifier ) 5635169689Skan 5636169689Skan objc-superclass: 5637169689Skan : identifier 5638169689Skan 5639169689Skan "@interface identifier (" must start "@interface identifier ( 5640169689Skan identifier ) ...": objc-methodprotolist in the first production may 5641169689Skan not start with a parenthesized identifier as a declarator of a data 5642169689Skan definition with no declaration specifiers if the objc-superclass, 5643169689Skan objc-protocol-refs and objc-class-instance-variables are omitted. */ 5644169689Skan 5645169689Skanstatic void 5646169689Skanc_parser_objc_class_definition (c_parser *parser) 5647169689Skan{ 5648169689Skan bool iface_p; 5649169689Skan tree id1; 5650169689Skan tree superclass; 5651169689Skan if (c_parser_next_token_is_keyword (parser, RID_AT_INTERFACE)) 5652169689Skan iface_p = true; 5653169689Skan else if (c_parser_next_token_is_keyword (parser, RID_AT_IMPLEMENTATION)) 5654169689Skan iface_p = false; 5655169689Skan else 5656169689Skan gcc_unreachable (); 5657169689Skan c_parser_consume_token (parser); 5658169689Skan if (c_parser_next_token_is_not (parser, CPP_NAME)) 5659169689Skan { 5660169689Skan c_parser_error (parser, "expected identifier"); 5661169689Skan return; 5662169689Skan } 5663169689Skan id1 = c_parser_peek_token (parser)->value; 5664169689Skan c_parser_consume_token (parser); 5665169689Skan if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)) 5666169689Skan { 5667169689Skan tree id2; 5668169689Skan tree proto = NULL_TREE; 5669169689Skan c_parser_consume_token (parser); 5670169689Skan if (c_parser_next_token_is_not (parser, CPP_NAME)) 5671169689Skan { 5672169689Skan c_parser_error (parser, "expected identifier"); 5673169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); 5674169689Skan return; 5675169689Skan } 5676169689Skan id2 = c_parser_peek_token (parser)->value; 5677169689Skan c_parser_consume_token (parser); 5678169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>"); 5679169689Skan if (!iface_p) 5680169689Skan { 5681169689Skan objc_start_category_implementation (id1, id2); 5682169689Skan return; 5683169689Skan } 5684169689Skan if (c_parser_next_token_is (parser, CPP_LESS)) 5685169689Skan proto = c_parser_objc_protocol_refs (parser); 5686169689Skan objc_start_category_interface (id1, id2, proto); 5687169689Skan c_parser_objc_methodprotolist (parser); 5688169689Skan c_parser_require_keyword (parser, RID_AT_END, "expected %<@end%>"); 5689169689Skan objc_finish_interface (); 5690169689Skan return; 5691169689Skan } 5692169689Skan if (c_parser_next_token_is (parser, CPP_COLON)) 5693169689Skan { 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 superclass = c_parser_peek_token (parser)->value; 5701169689Skan c_parser_consume_token (parser); 5702169689Skan } 5703169689Skan else 5704169689Skan superclass = NULL_TREE; 5705169689Skan if (iface_p) 5706169689Skan { 5707169689Skan tree proto = NULL_TREE; 5708169689Skan if (c_parser_next_token_is (parser, CPP_LESS)) 5709169689Skan proto = c_parser_objc_protocol_refs (parser); 5710169689Skan objc_start_class_interface (id1, superclass, proto); 5711169689Skan } 5712169689Skan else 5713169689Skan objc_start_class_implementation (id1, superclass); 5714169689Skan if (c_parser_next_token_is (parser, CPP_OPEN_BRACE)) 5715169689Skan c_parser_objc_class_instance_variables (parser); 5716169689Skan if (iface_p) 5717169689Skan { 5718169689Skan objc_continue_interface (); 5719169689Skan c_parser_objc_methodprotolist (parser); 5720169689Skan c_parser_require_keyword (parser, RID_AT_END, "expected %<@end%>"); 5721169689Skan objc_finish_interface (); 5722169689Skan } 5723169689Skan else 5724169689Skan { 5725169689Skan objc_continue_implementation (); 5726169689Skan return; 5727169689Skan } 5728169689Skan} 5729169689Skan 5730169689Skan/* Parse objc-class-instance-variables. 5731169689Skan 5732169689Skan objc-class-instance-variables: 5733169689Skan { objc-instance-variable-decl-list[opt] } 5734169689Skan 5735169689Skan objc-instance-variable-decl-list: 5736169689Skan objc-visibility-spec 5737169689Skan objc-instance-variable-decl ; 5738169689Skan ; 5739169689Skan objc-instance-variable-decl-list objc-visibility-spec 5740169689Skan objc-instance-variable-decl-list objc-instance-variable-decl ; 5741169689Skan objc-instance-variable-decl-list ; 5742169689Skan 5743169689Skan objc-visibility-spec: 5744169689Skan @private 5745169689Skan @protected 5746169689Skan @public 5747169689Skan 5748169689Skan objc-instance-variable-decl: 5749169689Skan struct-declaration 5750169689Skan*/ 5751169689Skan 5752169689Skanstatic void 5753169689Skanc_parser_objc_class_instance_variables (c_parser *parser) 5754169689Skan{ 5755169689Skan gcc_assert (c_parser_next_token_is (parser, CPP_OPEN_BRACE)); 5756169689Skan c_parser_consume_token (parser); 5757169689Skan while (c_parser_next_token_is_not (parser, CPP_EOF)) 5758169689Skan { 5759169689Skan tree decls; 5760169689Skan /* Parse any stray semicolon. */ 5761169689Skan if (c_parser_next_token_is (parser, CPP_SEMICOLON)) 5762169689Skan { 5763169689Skan if (pedantic) 5764169689Skan pedwarn ("extra semicolon in struct or union specified"); 5765169689Skan c_parser_consume_token (parser); 5766169689Skan continue; 5767169689Skan } 5768169689Skan /* Stop if at the end of the instance variables. */ 5769169689Skan if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE)) 5770169689Skan { 5771169689Skan c_parser_consume_token (parser); 5772169689Skan break; 5773169689Skan } 5774169689Skan /* Parse any objc-visibility-spec. */ 5775169689Skan if (c_parser_next_token_is_keyword (parser, RID_AT_PRIVATE)) 5776169689Skan { 5777169689Skan c_parser_consume_token (parser); 5778169689Skan objc_set_visibility (2); 5779169689Skan continue; 5780169689Skan } 5781169689Skan else if (c_parser_next_token_is_keyword (parser, RID_AT_PROTECTED)) 5782169689Skan { 5783169689Skan c_parser_consume_token (parser); 5784169689Skan objc_set_visibility (0); 5785169689Skan continue; 5786169689Skan } 5787169689Skan else if (c_parser_next_token_is_keyword (parser, RID_AT_PUBLIC)) 5788169689Skan { 5789169689Skan c_parser_consume_token (parser); 5790169689Skan objc_set_visibility (1); 5791169689Skan continue; 5792169689Skan } 5793169689Skan else if (c_parser_next_token_is (parser, CPP_PRAGMA)) 5794169689Skan { 5795169689Skan c_parser_pragma (parser, pragma_external); 5796169689Skan continue; 5797169689Skan } 5798169689Skan 5799169689Skan /* Parse some comma-separated declarations. */ 5800169689Skan decls = c_parser_struct_declaration (parser); 5801169689Skan { 5802169689Skan /* Comma-separated instance variables are chained together in 5803169689Skan reverse order; add them one by one. */ 5804169689Skan tree ivar = nreverse (decls); 5805169689Skan for (; ivar; ivar = TREE_CHAIN (ivar)) 5806169689Skan objc_add_instance_variable (copy_node (ivar)); 5807169689Skan } 5808169689Skan c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>"); 5809169689Skan } 5810169689Skan} 5811169689Skan 5812169689Skan/* Parse an objc-class-declaration. 5813169689Skan 5814169689Skan objc-class-declaration: 5815169689Skan @class identifier-list ; 5816169689Skan*/ 5817169689Skan 5818169689Skanstatic void 5819169689Skanc_parser_objc_class_declaration (c_parser *parser) 5820169689Skan{ 5821169689Skan tree list = NULL_TREE; 5822169689Skan gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_CLASS)); 5823169689Skan c_parser_consume_token (parser); 5824169689Skan /* Any identifiers, including those declared as type names, are OK 5825169689Skan here. */ 5826169689Skan while (true) 5827169689Skan { 5828169689Skan tree id; 5829169689Skan if (c_parser_next_token_is_not (parser, CPP_NAME)) 5830169689Skan { 5831169689Skan c_parser_error (parser, "expected identifier"); 5832169689Skan break; 5833169689Skan } 5834169689Skan id = c_parser_peek_token (parser)->value; 5835169689Skan list = chainon (list, build_tree_list (NULL_TREE, id)); 5836169689Skan c_parser_consume_token (parser); 5837169689Skan if (c_parser_next_token_is (parser, CPP_COMMA)) 5838169689Skan c_parser_consume_token (parser); 5839169689Skan else 5840169689Skan break; 5841169689Skan } 5842169689Skan c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>"); 5843169689Skan objc_declare_class (list); 5844169689Skan} 5845169689Skan 5846169689Skan/* Parse an objc-alias-declaration. 5847169689Skan 5848169689Skan objc-alias-declaration: 5849169689Skan @compatibility_alias identifier identifier ; 5850169689Skan*/ 5851169689Skan 5852169689Skanstatic void 5853169689Skanc_parser_objc_alias_declaration (c_parser *parser) 5854169689Skan{ 5855169689Skan tree id1, id2; 5856169689Skan gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_ALIAS)); 5857169689Skan c_parser_consume_token (parser); 5858169689Skan if (c_parser_next_token_is_not (parser, CPP_NAME)) 5859169689Skan { 5860169689Skan c_parser_error (parser, "expected identifier"); 5861169689Skan c_parser_skip_until_found (parser, CPP_SEMICOLON, NULL); 5862169689Skan return; 5863169689Skan } 5864169689Skan id1 = c_parser_peek_token (parser)->value; 5865169689Skan c_parser_consume_token (parser); 5866169689Skan if (c_parser_next_token_is_not (parser, CPP_NAME)) 5867169689Skan { 5868169689Skan c_parser_error (parser, "expected identifier"); 5869169689Skan c_parser_skip_until_found (parser, CPP_SEMICOLON, NULL); 5870169689Skan return; 5871169689Skan } 5872169689Skan id2 = c_parser_peek_token (parser)->value; 5873169689Skan c_parser_consume_token (parser); 5874169689Skan c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>"); 5875169689Skan objc_declare_alias (id1, id2); 5876169689Skan} 5877169689Skan 5878169689Skan/* Parse an objc-protocol-definition. 5879169689Skan 5880169689Skan objc-protocol-definition: 5881169689Skan @protocol identifier objc-protocol-refs[opt] objc-methodprotolist @end 5882169689Skan @protocol identifier-list ; 5883169689Skan 5884169689Skan "@protocol identifier ;" should be resolved as "@protocol 5885169689Skan identifier-list ;": objc-methodprotolist may not start with a 5886169689Skan semicolon in the first alternative if objc-protocol-refs are 5887169689Skan omitted. */ 5888169689Skan 5889169689Skanstatic void 5890169689Skanc_parser_objc_protocol_definition (c_parser *parser) 5891169689Skan{ 5892169689Skan gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_PROTOCOL)); 5893169689Skan c_parser_consume_token (parser); 5894169689Skan if (c_parser_next_token_is_not (parser, CPP_NAME)) 5895169689Skan { 5896169689Skan c_parser_error (parser, "expected identifier"); 5897169689Skan return; 5898169689Skan } 5899169689Skan if (c_parser_peek_2nd_token (parser)->type == CPP_COMMA 5900169689Skan || c_parser_peek_2nd_token (parser)->type == CPP_SEMICOLON) 5901169689Skan { 5902169689Skan tree list = NULL_TREE; 5903169689Skan /* Any identifiers, including those declared as type names, are 5904169689Skan OK here. */ 5905169689Skan while (true) 5906169689Skan { 5907169689Skan tree id; 5908169689Skan if (c_parser_next_token_is_not (parser, CPP_NAME)) 5909169689Skan { 5910169689Skan c_parser_error (parser, "expected identifier"); 5911169689Skan break; 5912169689Skan } 5913169689Skan id = c_parser_peek_token (parser)->value; 5914169689Skan list = chainon (list, build_tree_list (NULL_TREE, id)); 5915169689Skan c_parser_consume_token (parser); 5916169689Skan if (c_parser_next_token_is (parser, CPP_COMMA)) 5917169689Skan c_parser_consume_token (parser); 5918169689Skan else 5919169689Skan break; 5920169689Skan } 5921169689Skan c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>"); 5922169689Skan objc_declare_protocols (list); 5923169689Skan } 5924169689Skan else 5925169689Skan { 5926169689Skan tree id = c_parser_peek_token (parser)->value; 5927169689Skan tree proto = NULL_TREE; 5928169689Skan c_parser_consume_token (parser); 5929169689Skan if (c_parser_next_token_is (parser, CPP_LESS)) 5930169689Skan proto = c_parser_objc_protocol_refs (parser); 5931169689Skan objc_pq_context = 1; 5932169689Skan objc_start_protocol (id, proto); 5933169689Skan c_parser_objc_methodprotolist (parser); 5934169689Skan c_parser_require_keyword (parser, RID_AT_END, "expected %<@end%>"); 5935169689Skan objc_pq_context = 0; 5936169689Skan objc_finish_interface (); 5937169689Skan } 5938169689Skan} 5939169689Skan 5940169689Skan/* Parse an objc-method-type. 5941169689Skan 5942169689Skan objc-method-type: 5943169689Skan + 5944169689Skan - 5945169689Skan*/ 5946169689Skan 5947169689Skanstatic enum tree_code 5948169689Skanc_parser_objc_method_type (c_parser *parser) 5949169689Skan{ 5950169689Skan switch (c_parser_peek_token (parser)->type) 5951169689Skan { 5952169689Skan case CPP_PLUS: 5953169689Skan c_parser_consume_token (parser); 5954169689Skan return PLUS_EXPR; 5955169689Skan case CPP_MINUS: 5956169689Skan c_parser_consume_token (parser); 5957169689Skan return MINUS_EXPR; 5958169689Skan default: 5959169689Skan gcc_unreachable (); 5960169689Skan } 5961169689Skan} 5962169689Skan 5963169689Skan/* Parse an objc-method-definition. 5964169689Skan 5965169689Skan objc-method-definition: 5966169689Skan objc-method-type objc-method-decl ;[opt] compound-statement 5967169689Skan*/ 5968169689Skan 5969169689Skanstatic void 5970169689Skanc_parser_objc_method_definition (c_parser *parser) 5971169689Skan{ 5972169689Skan enum tree_code type = c_parser_objc_method_type (parser); 5973169689Skan tree decl; 5974169689Skan objc_set_method_type (type); 5975169689Skan objc_pq_context = 1; 5976169689Skan decl = c_parser_objc_method_decl (parser); 5977169689Skan if (c_parser_next_token_is (parser, CPP_SEMICOLON)) 5978169689Skan { 5979169689Skan c_parser_consume_token (parser); 5980169689Skan if (pedantic) 5981169689Skan pedwarn ("extra semicolon in method definition specified"); 5982169689Skan } 5983169689Skan if (!c_parser_next_token_is (parser, CPP_OPEN_BRACE)) 5984169689Skan { 5985169689Skan c_parser_error (parser, "expected %<{%>"); 5986169689Skan return; 5987169689Skan } 5988169689Skan objc_pq_context = 0; 5989169689Skan objc_start_method_definition (decl); 5990169689Skan add_stmt (c_parser_compound_statement (parser)); 5991169689Skan objc_finish_method_definition (current_function_decl); 5992169689Skan} 5993169689Skan 5994169689Skan/* Parse an objc-methodprotolist. 5995169689Skan 5996169689Skan objc-methodprotolist: 5997169689Skan empty 5998169689Skan objc-methodprotolist objc-methodproto 5999169689Skan objc-methodprotolist declaration 6000169689Skan objc-methodprotolist ; 6001169689Skan 6002169689Skan The declaration is a data definition, which may be missing 6003169689Skan declaration specifiers under the same rules and diagnostics as 6004169689Skan other data definitions outside functions, and the stray semicolon 6005169689Skan is diagnosed the same way as a stray semicolon outside a 6006169689Skan function. */ 6007169689Skan 6008169689Skanstatic void 6009169689Skanc_parser_objc_methodprotolist (c_parser *parser) 6010169689Skan{ 6011169689Skan while (true) 6012169689Skan { 6013169689Skan /* The list is terminated by @end. */ 6014169689Skan switch (c_parser_peek_token (parser)->type) 6015169689Skan { 6016169689Skan case CPP_SEMICOLON: 6017169689Skan if (pedantic) 6018169689Skan pedwarn ("ISO C does not allow extra %<;%> outside of a function"); 6019169689Skan c_parser_consume_token (parser); 6020169689Skan break; 6021169689Skan case CPP_PLUS: 6022169689Skan case CPP_MINUS: 6023169689Skan c_parser_objc_methodproto (parser); 6024169689Skan break; 6025169689Skan case CPP_PRAGMA: 6026169689Skan c_parser_pragma (parser, pragma_external); 6027169689Skan break; 6028169689Skan case CPP_EOF: 6029169689Skan return; 6030169689Skan default: 6031169689Skan if (c_parser_next_token_is_keyword (parser, RID_AT_END)) 6032169689Skan return; 6033169689Skan c_parser_declaration_or_fndef (parser, false, true, false, true); 6034169689Skan break; 6035169689Skan } 6036169689Skan } 6037169689Skan} 6038169689Skan 6039169689Skan/* Parse an objc-methodproto. 6040169689Skan 6041169689Skan objc-methodproto: 6042169689Skan objc-method-type objc-method-decl ; 6043169689Skan*/ 6044169689Skan 6045169689Skanstatic void 6046169689Skanc_parser_objc_methodproto (c_parser *parser) 6047169689Skan{ 6048169689Skan enum tree_code type = c_parser_objc_method_type (parser); 6049169689Skan tree decl; 6050169689Skan objc_set_method_type (type); 6051169689Skan /* Remember protocol qualifiers in prototypes. */ 6052169689Skan objc_pq_context = 1; 6053169689Skan decl = c_parser_objc_method_decl (parser); 6054169689Skan /* Forget protocol qualifiers here. */ 6055169689Skan objc_pq_context = 0; 6056169689Skan objc_add_method_declaration (decl); 6057169689Skan c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>"); 6058169689Skan} 6059169689Skan 6060169689Skan/* Parse an objc-method-decl. 6061169689Skan 6062169689Skan objc-method-decl: 6063169689Skan ( objc-type-name ) objc-selector 6064169689Skan objc-selector 6065169689Skan ( objc-type-name ) objc-keyword-selector objc-optparmlist 6066169689Skan objc-keyword-selector objc-optparmlist 6067169689Skan 6068169689Skan objc-keyword-selector: 6069169689Skan objc-keyword-decl 6070169689Skan objc-keyword-selector objc-keyword-decl 6071169689Skan 6072169689Skan objc-keyword-decl: 6073169689Skan objc-selector : ( objc-type-name ) identifier 6074169689Skan objc-selector : identifier 6075169689Skan : ( objc-type-name ) identifier 6076169689Skan : identifier 6077169689Skan 6078169689Skan objc-optparmlist: 6079169689Skan objc-optparms objc-optellipsis 6080169689Skan 6081169689Skan objc-optparms: 6082169689Skan empty 6083169689Skan objc-opt-parms , parameter-declaration 6084169689Skan 6085169689Skan objc-optellipsis: 6086169689Skan empty 6087169689Skan , ... 6088169689Skan*/ 6089169689Skan 6090169689Skanstatic tree 6091169689Skanc_parser_objc_method_decl (c_parser *parser) 6092169689Skan{ 6093169689Skan tree type = NULL_TREE; 6094169689Skan tree sel; 6095169689Skan tree parms = NULL_TREE; 6096169689Skan bool ellipsis = false; 6097169689Skan 6098169689Skan if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)) 6099169689Skan { 6100169689Skan c_parser_consume_token (parser); 6101169689Skan type = c_parser_objc_type_name (parser); 6102169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>"); 6103169689Skan } 6104169689Skan sel = c_parser_objc_selector (parser); 6105169689Skan /* If there is no selector, or a colon follows, we have an 6106169689Skan objc-keyword-selector. If there is a selector, and a colon does 6107169689Skan not follow, that selector ends the objc-method-decl. */ 6108169689Skan if (!sel || c_parser_next_token_is (parser, CPP_COLON)) 6109169689Skan { 6110169689Skan tree tsel = sel; 6111169689Skan tree list = NULL_TREE; 6112169689Skan while (true) 6113169689Skan { 6114169689Skan tree atype = NULL_TREE, id, keyworddecl; 6115169689Skan if (!c_parser_require (parser, CPP_COLON, "expected %<:%>")) 6116169689Skan break; 6117169689Skan if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)) 6118169689Skan { 6119169689Skan c_parser_consume_token (parser); 6120169689Skan atype = c_parser_objc_type_name (parser); 6121169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 6122169689Skan "expected %<)%>"); 6123169689Skan } 6124169689Skan if (c_parser_next_token_is_not (parser, CPP_NAME)) 6125169689Skan { 6126169689Skan c_parser_error (parser, "expected identifier"); 6127169689Skan return error_mark_node; 6128169689Skan } 6129169689Skan id = c_parser_peek_token (parser)->value; 6130169689Skan c_parser_consume_token (parser); 6131169689Skan keyworddecl = objc_build_keyword_decl (tsel, atype, id); 6132169689Skan list = chainon (list, keyworddecl); 6133169689Skan tsel = c_parser_objc_selector (parser); 6134169689Skan if (!tsel && c_parser_next_token_is_not (parser, CPP_COLON)) 6135169689Skan break; 6136169689Skan } 6137169689Skan /* Parse the optional parameter list. Optional Objective-C 6138169689Skan method parameters follow the C syntax, and may include '...' 6139169689Skan to denote a variable number of arguments. */ 6140169689Skan parms = make_node (TREE_LIST); 6141169689Skan while (c_parser_next_token_is (parser, CPP_COMMA)) 6142169689Skan { 6143169689Skan struct c_parm *parm; 6144169689Skan c_parser_consume_token (parser); 6145169689Skan if (c_parser_next_token_is (parser, CPP_ELLIPSIS)) 6146169689Skan { 6147169689Skan ellipsis = true; 6148169689Skan c_parser_consume_token (parser); 6149169689Skan break; 6150169689Skan } 6151169689Skan parm = c_parser_parameter_declaration (parser, NULL_TREE); 6152169689Skan if (parm == NULL) 6153169689Skan break; 6154169689Skan parms = chainon (parms, 6155169689Skan build_tree_list (NULL_TREE, grokparm (parm))); 6156169689Skan } 6157169689Skan sel = list; 6158169689Skan } 6159169689Skan return objc_build_method_signature (type, sel, parms, ellipsis); 6160169689Skan} 6161169689Skan 6162169689Skan/* Parse an objc-type-name. 6163169689Skan 6164169689Skan objc-type-name: 6165169689Skan objc-type-qualifiers[opt] type-name 6166169689Skan objc-type-qualifiers[opt] 6167169689Skan 6168169689Skan objc-type-qualifiers: 6169169689Skan objc-type-qualifier 6170169689Skan objc-type-qualifiers objc-type-qualifier 6171169689Skan 6172169689Skan objc-type-qualifier: one of 6173169689Skan in out inout bycopy byref oneway 6174169689Skan*/ 6175169689Skan 6176169689Skanstatic tree 6177169689Skanc_parser_objc_type_name (c_parser *parser) 6178169689Skan{ 6179169689Skan tree quals = NULL_TREE; 6180169689Skan struct c_type_name *typename = NULL; 6181169689Skan tree type = NULL_TREE; 6182169689Skan while (true) 6183169689Skan { 6184169689Skan c_token *token = c_parser_peek_token (parser); 6185169689Skan if (token->type == CPP_KEYWORD 6186169689Skan && (token->keyword == RID_IN 6187169689Skan || token->keyword == RID_OUT 6188169689Skan || token->keyword == RID_INOUT 6189169689Skan || token->keyword == RID_BYCOPY 6190169689Skan || token->keyword == RID_BYREF 6191169689Skan || token->keyword == RID_ONEWAY)) 6192169689Skan { 6193169689Skan quals = chainon (quals, build_tree_list (NULL_TREE, token->value)); 6194169689Skan c_parser_consume_token (parser); 6195169689Skan } 6196169689Skan else 6197169689Skan break; 6198169689Skan } 6199169689Skan if (c_parser_next_token_starts_typename (parser)) 6200169689Skan typename = c_parser_type_name (parser); 6201169689Skan if (typename) 6202169689Skan type = groktypename (typename); 6203169689Skan return build_tree_list (quals, type); 6204169689Skan} 6205169689Skan 6206169689Skan/* Parse objc-protocol-refs. 6207169689Skan 6208169689Skan objc-protocol-refs: 6209169689Skan < identifier-list > 6210169689Skan*/ 6211169689Skan 6212169689Skanstatic tree 6213169689Skanc_parser_objc_protocol_refs (c_parser *parser) 6214169689Skan{ 6215169689Skan tree list = NULL_TREE; 6216169689Skan gcc_assert (c_parser_next_token_is (parser, CPP_LESS)); 6217169689Skan c_parser_consume_token (parser); 6218169689Skan /* Any identifiers, including those declared as type names, are OK 6219169689Skan here. */ 6220169689Skan while (true) 6221169689Skan { 6222169689Skan tree id; 6223169689Skan if (c_parser_next_token_is_not (parser, CPP_NAME)) 6224169689Skan { 6225169689Skan c_parser_error (parser, "expected identifier"); 6226169689Skan break; 6227169689Skan } 6228169689Skan id = c_parser_peek_token (parser)->value; 6229169689Skan list = chainon (list, build_tree_list (NULL_TREE, id)); 6230169689Skan c_parser_consume_token (parser); 6231169689Skan if (c_parser_next_token_is (parser, CPP_COMMA)) 6232169689Skan c_parser_consume_token (parser); 6233169689Skan else 6234169689Skan break; 6235169689Skan } 6236169689Skan c_parser_require (parser, CPP_GREATER, "expected %<>%>"); 6237169689Skan return list; 6238169689Skan} 6239169689Skan 6240169689Skan/* Parse an objc-try-catch-statement. 6241169689Skan 6242169689Skan objc-try-catch-statement: 6243169689Skan @try compound-statement objc-catch-list[opt] 6244169689Skan @try compound-statement objc-catch-list[opt] @finally compound-statement 6245169689Skan 6246169689Skan objc-catch-list: 6247169689Skan @catch ( parameter-declaration ) compound-statement 6248169689Skan objc-catch-list @catch ( parameter-declaration ) compound-statement 6249169689Skan*/ 6250169689Skan 6251169689Skanstatic void 6252169689Skanc_parser_objc_try_catch_statement (c_parser *parser) 6253169689Skan{ 6254169689Skan location_t loc; 6255169689Skan tree stmt; 6256169689Skan gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_TRY)); 6257169689Skan c_parser_consume_token (parser); 6258169689Skan loc = c_parser_peek_token (parser)->location; 6259169689Skan stmt = c_parser_compound_statement (parser); 6260169689Skan objc_begin_try_stmt (loc, stmt); 6261169689Skan while (c_parser_next_token_is_keyword (parser, RID_AT_CATCH)) 6262169689Skan { 6263169689Skan struct c_parm *parm; 6264169689Skan c_parser_consume_token (parser); 6265169689Skan if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 6266169689Skan break; 6267169689Skan parm = c_parser_parameter_declaration (parser, NULL_TREE); 6268169689Skan if (parm == NULL) 6269169689Skan { 6270169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); 6271169689Skan break; 6272169689Skan } 6273169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>"); 6274169689Skan objc_begin_catch_clause (grokparm (parm)); 6275169689Skan if (c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>")) 6276169689Skan c_parser_compound_statement_nostart (parser); 6277169689Skan objc_finish_catch_clause (); 6278169689Skan } 6279169689Skan if (c_parser_next_token_is_keyword (parser, RID_AT_FINALLY)) 6280169689Skan { 6281169689Skan location_t finloc; 6282169689Skan tree finstmt; 6283169689Skan c_parser_consume_token (parser); 6284169689Skan finloc = c_parser_peek_token (parser)->location; 6285169689Skan finstmt = c_parser_compound_statement (parser); 6286169689Skan objc_build_finally_clause (finloc, finstmt); 6287169689Skan } 6288169689Skan objc_finish_try_stmt (); 6289169689Skan} 6290169689Skan 6291169689Skan/* Parse an objc-synchronized-statement. 6292169689Skan 6293169689Skan objc-synchronized-statement: 6294169689Skan @synchronized ( expression ) compound-statement 6295169689Skan*/ 6296169689Skan 6297169689Skanstatic void 6298169689Skanc_parser_objc_synchronized_statement (c_parser *parser) 6299169689Skan{ 6300169689Skan location_t loc; 6301169689Skan tree expr, stmt; 6302169689Skan gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_SYNCHRONIZED)); 6303169689Skan c_parser_consume_token (parser); 6304169689Skan loc = c_parser_peek_token (parser)->location; 6305169689Skan if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 6306169689Skan { 6307169689Skan expr = c_parser_expression (parser).value; 6308169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>"); 6309169689Skan } 6310169689Skan else 6311169689Skan expr = error_mark_node; 6312169689Skan stmt = c_parser_compound_statement (parser); 6313169689Skan objc_build_synchronized (loc, expr, stmt); 6314169689Skan} 6315169689Skan 6316169689Skan/* Parse an objc-selector; return NULL_TREE without an error if the 6317169689Skan next token is not an objc-selector. 6318169689Skan 6319169689Skan objc-selector: 6320169689Skan identifier 6321169689Skan one of 6322169689Skan enum struct union if else while do for switch case default 6323169689Skan break continue return goto asm sizeof typeof __alignof 6324169689Skan unsigned long const short volatile signed restrict _Complex 6325169689Skan in out inout bycopy byref oneway int char float double void _Bool 6326169689Skan 6327169689Skan ??? Why this selection of keywords but not, for example, storage 6328169689Skan class specifiers? */ 6329169689Skan 6330169689Skanstatic tree 6331169689Skanc_parser_objc_selector (c_parser *parser) 6332169689Skan{ 6333169689Skan c_token *token = c_parser_peek_token (parser); 6334169689Skan tree value = token->value; 6335169689Skan if (token->type == CPP_NAME) 6336169689Skan { 6337169689Skan c_parser_consume_token (parser); 6338169689Skan return value; 6339169689Skan } 6340169689Skan if (token->type != CPP_KEYWORD) 6341169689Skan return NULL_TREE; 6342169689Skan switch (token->keyword) 6343169689Skan { 6344169689Skan case RID_ENUM: 6345169689Skan case RID_STRUCT: 6346169689Skan case RID_UNION: 6347169689Skan case RID_IF: 6348169689Skan case RID_ELSE: 6349169689Skan case RID_WHILE: 6350169689Skan case RID_DO: 6351169689Skan case RID_FOR: 6352169689Skan case RID_SWITCH: 6353169689Skan case RID_CASE: 6354169689Skan case RID_DEFAULT: 6355169689Skan case RID_BREAK: 6356169689Skan case RID_CONTINUE: 6357169689Skan case RID_RETURN: 6358169689Skan case RID_GOTO: 6359169689Skan case RID_ASM: 6360169689Skan case RID_SIZEOF: 6361169689Skan case RID_TYPEOF: 6362169689Skan case RID_ALIGNOF: 6363169689Skan case RID_UNSIGNED: 6364169689Skan case RID_LONG: 6365169689Skan case RID_CONST: 6366169689Skan case RID_SHORT: 6367169689Skan case RID_VOLATILE: 6368169689Skan case RID_SIGNED: 6369169689Skan case RID_RESTRICT: 6370169689Skan case RID_COMPLEX: 6371169689Skan case RID_IN: 6372169689Skan case RID_OUT: 6373169689Skan case RID_INOUT: 6374169689Skan case RID_BYCOPY: 6375169689Skan case RID_BYREF: 6376169689Skan case RID_ONEWAY: 6377169689Skan case RID_INT: 6378169689Skan case RID_CHAR: 6379169689Skan case RID_FLOAT: 6380169689Skan case RID_DOUBLE: 6381169689Skan case RID_VOID: 6382169689Skan case RID_BOOL: 6383169689Skan c_parser_consume_token (parser); 6384169689Skan return value; 6385169689Skan default: 6386169689Skan return NULL_TREE; 6387169689Skan } 6388169689Skan} 6389169689Skan 6390169689Skan/* Parse an objc-selector-arg. 6391169689Skan 6392169689Skan objc-selector-arg: 6393169689Skan objc-selector 6394169689Skan objc-keywordname-list 6395169689Skan 6396169689Skan objc-keywordname-list: 6397169689Skan objc-keywordname 6398169689Skan objc-keywordname-list objc-keywordname 6399169689Skan 6400169689Skan objc-keywordname: 6401169689Skan objc-selector : 6402169689Skan : 6403169689Skan*/ 6404169689Skan 6405169689Skanstatic tree 6406169689Skanc_parser_objc_selector_arg (c_parser *parser) 6407169689Skan{ 6408169689Skan tree sel = c_parser_objc_selector (parser); 6409169689Skan tree list = NULL_TREE; 6410169689Skan if (sel && c_parser_next_token_is_not (parser, CPP_COLON)) 6411169689Skan return sel; 6412169689Skan while (true) 6413169689Skan { 6414169689Skan if (!c_parser_require (parser, CPP_COLON, "expected %<:%>")) 6415169689Skan return list; 6416169689Skan list = chainon (list, build_tree_list (sel, NULL_TREE)); 6417169689Skan sel = c_parser_objc_selector (parser); 6418169689Skan if (!sel && c_parser_next_token_is_not (parser, CPP_COLON)) 6419169689Skan break; 6420169689Skan } 6421169689Skan return list; 6422169689Skan} 6423169689Skan 6424169689Skan/* Parse an objc-receiver. 6425169689Skan 6426169689Skan objc-receiver: 6427169689Skan expression 6428169689Skan class-name 6429169689Skan type-name 6430169689Skan*/ 6431169689Skan 6432169689Skanstatic tree 6433169689Skanc_parser_objc_receiver (c_parser *parser) 6434169689Skan{ 6435169689Skan if (c_parser_peek_token (parser)->type == CPP_NAME 6436169689Skan && (c_parser_peek_token (parser)->id_kind == C_ID_TYPENAME 6437169689Skan || c_parser_peek_token (parser)->id_kind == C_ID_CLASSNAME)) 6438169689Skan { 6439169689Skan tree id = c_parser_peek_token (parser)->value; 6440169689Skan c_parser_consume_token (parser); 6441169689Skan return objc_get_class_reference (id); 6442169689Skan } 6443169689Skan return c_parser_expression (parser).value; 6444169689Skan} 6445169689Skan 6446169689Skan/* Parse objc-message-args. 6447169689Skan 6448169689Skan objc-message-args: 6449169689Skan objc-selector 6450169689Skan objc-keywordarg-list 6451169689Skan 6452169689Skan objc-keywordarg-list: 6453169689Skan objc-keywordarg 6454169689Skan objc-keywordarg-list objc-keywordarg 6455169689Skan 6456169689Skan objc-keywordarg: 6457169689Skan objc-selector : objc-keywordexpr 6458169689Skan : objc-keywordexpr 6459169689Skan*/ 6460169689Skan 6461169689Skanstatic tree 6462169689Skanc_parser_objc_message_args (c_parser *parser) 6463169689Skan{ 6464169689Skan tree sel = c_parser_objc_selector (parser); 6465169689Skan tree list = NULL_TREE; 6466169689Skan if (sel && c_parser_next_token_is_not (parser, CPP_COLON)) 6467169689Skan return sel; 6468169689Skan while (true) 6469169689Skan { 6470169689Skan tree keywordexpr; 6471169689Skan if (!c_parser_require (parser, CPP_COLON, "expected %<:%>")) 6472169689Skan return list; 6473169689Skan keywordexpr = c_parser_objc_keywordexpr (parser); 6474169689Skan list = chainon (list, build_tree_list (sel, keywordexpr)); 6475169689Skan sel = c_parser_objc_selector (parser); 6476169689Skan if (!sel && c_parser_next_token_is_not (parser, CPP_COLON)) 6477169689Skan break; 6478169689Skan } 6479169689Skan return list; 6480169689Skan} 6481169689Skan 6482169689Skan/* Parse an objc-keywordexpr. 6483169689Skan 6484169689Skan objc-keywordexpr: 6485169689Skan nonempty-expr-list 6486169689Skan*/ 6487169689Skan 6488169689Skanstatic tree 6489169689Skanc_parser_objc_keywordexpr (c_parser *parser) 6490169689Skan{ 6491169689Skan tree list = c_parser_expr_list (parser, true); 6492169689Skan if (TREE_CHAIN (list) == NULL_TREE) 6493169689Skan { 6494169689Skan /* Just return the expression, remove a level of 6495169689Skan indirection. */ 6496169689Skan return TREE_VALUE (list); 6497169689Skan } 6498169689Skan else 6499169689Skan { 6500169689Skan /* We have a comma expression, we will collapse later. */ 6501169689Skan return list; 6502169689Skan } 6503169689Skan} 6504169689Skan 6505169689Skan 6506169689Skan/* Handle pragmas. Some OpenMP pragmas are associated with, and therefore 6507169689Skan should be considered, statements. ALLOW_STMT is true if we're within 6508169689Skan the context of a function and such pragmas are to be allowed. Returns 6509169689Skan true if we actually parsed such a pragma. */ 6510169689Skan 6511169689Skanstatic bool 6512169689Skanc_parser_pragma (c_parser *parser, enum pragma_context context) 6513169689Skan{ 6514169689Skan unsigned int id; 6515169689Skan 6516169689Skan id = c_parser_peek_token (parser)->pragma_kind; 6517169689Skan gcc_assert (id != PRAGMA_NONE); 6518169689Skan 6519169689Skan switch (id) 6520169689Skan { 6521169689Skan case PRAGMA_OMP_BARRIER: 6522169689Skan if (context != pragma_compound) 6523169689Skan { 6524169689Skan if (context == pragma_stmt) 6525169689Skan c_parser_error (parser, "%<#pragma omp barrier%> may only be " 6526169689Skan "used in compound statements"); 6527169689Skan goto bad_stmt; 6528169689Skan } 6529169689Skan c_parser_omp_barrier (parser); 6530169689Skan return false; 6531169689Skan 6532169689Skan case PRAGMA_OMP_FLUSH: 6533169689Skan if (context != pragma_compound) 6534169689Skan { 6535169689Skan if (context == pragma_stmt) 6536169689Skan c_parser_error (parser, "%<#pragma omp flush%> may only be " 6537169689Skan "used in compound statements"); 6538169689Skan goto bad_stmt; 6539169689Skan } 6540169689Skan c_parser_omp_flush (parser); 6541169689Skan return false; 6542169689Skan 6543169689Skan case PRAGMA_OMP_THREADPRIVATE: 6544169689Skan c_parser_omp_threadprivate (parser); 6545169689Skan return false; 6546169689Skan 6547169689Skan case PRAGMA_OMP_SECTION: 6548169689Skan error ("%<#pragma omp section%> may only be used in " 6549169689Skan "%<#pragma omp sections%> construct"); 6550169689Skan c_parser_skip_until_found (parser, CPP_PRAGMA_EOL, NULL); 6551169689Skan return false; 6552169689Skan 6553169689Skan case PRAGMA_GCC_PCH_PREPROCESS: 6554169689Skan c_parser_error (parser, "%<#pragma GCC pch_preprocess%> must be first"); 6555169689Skan c_parser_skip_until_found (parser, CPP_PRAGMA_EOL, NULL); 6556169689Skan return false; 6557169689Skan 6558169689Skan default: 6559169689Skan if (id < PRAGMA_FIRST_EXTERNAL) 6560169689Skan { 6561169689Skan if (context == pragma_external) 6562169689Skan { 6563169689Skan bad_stmt: 6564169689Skan c_parser_error (parser, "expected declaration specifiers"); 6565169689Skan c_parser_skip_until_found (parser, CPP_PRAGMA_EOL, NULL); 6566169689Skan return false; 6567169689Skan } 6568169689Skan c_parser_omp_construct (parser); 6569169689Skan return true; 6570169689Skan } 6571169689Skan break; 6572169689Skan } 6573169689Skan 6574169689Skan c_parser_consume_pragma (parser); 6575169689Skan c_invoke_pragma_handler (id); 6576169689Skan 6577169689Skan /* Skip to EOL, but suppress any error message. Those will have been 6578169689Skan generated by the handler routine through calling error, as opposed 6579169689Skan to calling c_parser_error. */ 6580169689Skan parser->error = true; 6581169689Skan c_parser_skip_to_pragma_eol (parser); 6582169689Skan 6583169689Skan return false; 6584169689Skan} 6585169689Skan 6586169689Skan/* The interface the pragma parsers have to the lexer. */ 6587169689Skan 6588169689Skanenum cpp_ttype 6589169689Skanpragma_lex (tree *value) 6590169689Skan{ 6591169689Skan c_token *tok = c_parser_peek_token (the_parser); 6592169689Skan enum cpp_ttype ret = tok->type; 6593169689Skan 6594169689Skan *value = tok->value; 6595169689Skan if (ret == CPP_PRAGMA_EOL || ret == CPP_EOF) 6596169689Skan ret = CPP_EOF; 6597169689Skan else 6598169689Skan { 6599169689Skan if (ret == CPP_KEYWORD) 6600169689Skan ret = CPP_NAME; 6601169689Skan c_parser_consume_token (the_parser); 6602169689Skan } 6603169689Skan 6604169689Skan return ret; 6605169689Skan} 6606169689Skan 6607169689Skanstatic void 6608169689Skanc_parser_pragma_pch_preprocess (c_parser *parser) 6609169689Skan{ 6610169689Skan tree name = NULL; 6611169689Skan 6612169689Skan c_parser_consume_pragma (parser); 6613169689Skan if (c_parser_next_token_is (parser, CPP_STRING)) 6614169689Skan { 6615169689Skan name = c_parser_peek_token (parser)->value; 6616169689Skan c_parser_consume_token (parser); 6617169689Skan } 6618169689Skan else 6619169689Skan c_parser_error (parser, "expected string literal"); 6620169689Skan c_parser_skip_to_pragma_eol (parser); 6621169689Skan 6622169689Skan if (name) 6623169689Skan c_common_pch_pragma (parse_in, TREE_STRING_POINTER (name)); 6624169689Skan} 6625169689Skan 6626169689Skan/* OpenMP 2.5 parsing routines. */ 6627169689Skan 6628169689Skan/* Returns name of the next clause. 6629169689Skan If the clause is not recognized PRAGMA_OMP_CLAUSE_NONE is returned and 6630169689Skan the token is not consumed. Otherwise appropriate pragma_omp_clause is 6631169689Skan returned and the token is consumed. */ 6632169689Skan 6633169689Skanstatic pragma_omp_clause 6634169689Skanc_parser_omp_clause_name (c_parser *parser) 6635169689Skan{ 6636169689Skan pragma_omp_clause result = PRAGMA_OMP_CLAUSE_NONE; 6637169689Skan 6638169689Skan if (c_parser_next_token_is_keyword (parser, RID_IF)) 6639169689Skan result = PRAGMA_OMP_CLAUSE_IF; 6640169689Skan else if (c_parser_next_token_is_keyword (parser, RID_DEFAULT)) 6641169689Skan result = PRAGMA_OMP_CLAUSE_DEFAULT; 6642169689Skan else if (c_parser_next_token_is (parser, CPP_NAME)) 6643169689Skan { 6644169689Skan const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value); 6645169689Skan 6646169689Skan switch (p[0]) 6647169689Skan { 6648169689Skan case 'c': 6649169689Skan if (!strcmp ("copyin", p)) 6650169689Skan result = PRAGMA_OMP_CLAUSE_COPYIN; 6651169689Skan else if (!strcmp ("copyprivate", p)) 6652169689Skan result = PRAGMA_OMP_CLAUSE_COPYPRIVATE; 6653169689Skan break; 6654169689Skan case 'f': 6655169689Skan if (!strcmp ("firstprivate", p)) 6656169689Skan result = PRAGMA_OMP_CLAUSE_FIRSTPRIVATE; 6657169689Skan break; 6658169689Skan case 'l': 6659169689Skan if (!strcmp ("lastprivate", p)) 6660169689Skan result = PRAGMA_OMP_CLAUSE_LASTPRIVATE; 6661169689Skan break; 6662169689Skan case 'n': 6663169689Skan if (!strcmp ("nowait", p)) 6664169689Skan result = PRAGMA_OMP_CLAUSE_NOWAIT; 6665169689Skan else if (!strcmp ("num_threads", p)) 6666169689Skan result = PRAGMA_OMP_CLAUSE_NUM_THREADS; 6667169689Skan break; 6668169689Skan case 'o': 6669169689Skan if (!strcmp ("ordered", p)) 6670169689Skan result = PRAGMA_OMP_CLAUSE_ORDERED; 6671169689Skan break; 6672169689Skan case 'p': 6673169689Skan if (!strcmp ("private", p)) 6674169689Skan result = PRAGMA_OMP_CLAUSE_PRIVATE; 6675169689Skan break; 6676169689Skan case 'r': 6677169689Skan if (!strcmp ("reduction", p)) 6678169689Skan result = PRAGMA_OMP_CLAUSE_REDUCTION; 6679169689Skan break; 6680169689Skan case 's': 6681169689Skan if (!strcmp ("schedule", p)) 6682169689Skan result = PRAGMA_OMP_CLAUSE_SCHEDULE; 6683169689Skan else if (!strcmp ("shared", p)) 6684169689Skan result = PRAGMA_OMP_CLAUSE_SHARED; 6685169689Skan break; 6686169689Skan } 6687169689Skan } 6688169689Skan 6689169689Skan if (result != PRAGMA_OMP_CLAUSE_NONE) 6690169689Skan c_parser_consume_token (parser); 6691169689Skan 6692169689Skan return result; 6693169689Skan} 6694169689Skan 6695169689Skan/* Validate that a clause of the given type does not already exist. */ 6696169689Skan 6697169689Skanstatic void 6698169689Skancheck_no_duplicate_clause (tree clauses, enum tree_code code, const char *name) 6699169689Skan{ 6700169689Skan tree c; 6701169689Skan 6702169689Skan for (c = clauses; c ; c = OMP_CLAUSE_CHAIN (c)) 6703169689Skan if (OMP_CLAUSE_CODE (c) == code) 6704169689Skan { 6705169689Skan error ("too many %qs clauses", name); 6706169689Skan break; 6707169689Skan } 6708169689Skan} 6709169689Skan 6710169689Skan/* OpenMP 2.5: 6711169689Skan variable-list: 6712169689Skan identifier 6713169689Skan variable-list , identifier 6714169689Skan 6715169689Skan If KIND is nonzero, create the appropriate node and install the decl 6716169689Skan in OMP_CLAUSE_DECL and add the node to the head of the list. 6717169689Skan 6718169689Skan If KIND is zero, create a TREE_LIST with the decl in TREE_PURPOSE; 6719169689Skan return the list created. */ 6720169689Skan 6721169689Skanstatic tree 6722169689Skanc_parser_omp_variable_list (c_parser *parser, enum omp_clause_code kind, 6723169689Skan tree list) 6724169689Skan{ 6725169689Skan if (c_parser_next_token_is_not (parser, CPP_NAME) 6726169689Skan || c_parser_peek_token (parser)->id_kind != C_ID_ID) 6727169689Skan c_parser_error (parser, "expected identifier"); 6728169689Skan 6729169689Skan while (c_parser_next_token_is (parser, CPP_NAME) 6730169689Skan && c_parser_peek_token (parser)->id_kind == C_ID_ID) 6731169689Skan { 6732169689Skan tree t = lookup_name (c_parser_peek_token (parser)->value); 6733169689Skan 6734169689Skan if (t == NULL_TREE) 6735169689Skan undeclared_variable (c_parser_peek_token (parser)->value, 6736169689Skan c_parser_peek_token (parser)->location); 6737169689Skan else if (t == error_mark_node) 6738169689Skan ; 6739169689Skan else if (kind != 0) 6740169689Skan { 6741169689Skan tree u = build_omp_clause (kind); 6742169689Skan OMP_CLAUSE_DECL (u) = t; 6743169689Skan OMP_CLAUSE_CHAIN (u) = list; 6744169689Skan list = u; 6745169689Skan } 6746169689Skan else 6747169689Skan list = tree_cons (t, NULL_TREE, list); 6748169689Skan 6749169689Skan c_parser_consume_token (parser); 6750169689Skan 6751169689Skan if (c_parser_next_token_is_not (parser, CPP_COMMA)) 6752169689Skan break; 6753169689Skan 6754169689Skan c_parser_consume_token (parser); 6755169689Skan } 6756169689Skan 6757169689Skan return list; 6758169689Skan} 6759169689Skan 6760169689Skan/* Similarly, but expect leading and trailing parenthesis. This is a very 6761169689Skan common case for omp clauses. */ 6762169689Skan 6763169689Skanstatic tree 6764169689Skanc_parser_omp_var_list_parens (c_parser *parser, enum tree_code kind, tree list) 6765169689Skan{ 6766169689Skan if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 6767169689Skan { 6768169689Skan list = c_parser_omp_variable_list (parser, kind, list); 6769169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>"); 6770169689Skan } 6771169689Skan return list; 6772169689Skan} 6773169689Skan 6774169689Skan/* OpenMP 2.5: 6775169689Skan copyin ( variable-list ) */ 6776169689Skan 6777169689Skanstatic tree 6778169689Skanc_parser_omp_clause_copyin (c_parser *parser, tree list) 6779169689Skan{ 6780169689Skan return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_COPYIN, list); 6781169689Skan} 6782169689Skan 6783169689Skan/* OpenMP 2.5: 6784169689Skan copyprivate ( variable-list ) */ 6785169689Skan 6786169689Skanstatic tree 6787169689Skanc_parser_omp_clause_copyprivate (c_parser *parser, tree list) 6788169689Skan{ 6789169689Skan return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_COPYPRIVATE, list); 6790169689Skan} 6791169689Skan 6792169689Skan/* OpenMP 2.5: 6793169689Skan default ( shared | none ) */ 6794169689Skan 6795169689Skanstatic tree 6796169689Skanc_parser_omp_clause_default (c_parser *parser, tree list) 6797169689Skan{ 6798169689Skan enum omp_clause_default_kind kind = OMP_CLAUSE_DEFAULT_UNSPECIFIED; 6799169689Skan tree c; 6800169689Skan 6801169689Skan if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 6802169689Skan return list; 6803169689Skan if (c_parser_next_token_is (parser, CPP_NAME)) 6804169689Skan { 6805169689Skan const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value); 6806169689Skan 6807169689Skan switch (p[0]) 6808169689Skan { 6809169689Skan case 'n': 6810169689Skan if (strcmp ("none", p) != 0) 6811169689Skan goto invalid_kind; 6812169689Skan kind = OMP_CLAUSE_DEFAULT_NONE; 6813169689Skan break; 6814169689Skan 6815169689Skan case 's': 6816169689Skan if (strcmp ("shared", p) != 0) 6817169689Skan goto invalid_kind; 6818169689Skan kind = OMP_CLAUSE_DEFAULT_SHARED; 6819169689Skan break; 6820169689Skan 6821169689Skan default: 6822169689Skan goto invalid_kind; 6823169689Skan } 6824169689Skan 6825169689Skan c_parser_consume_token (parser); 6826169689Skan } 6827169689Skan else 6828169689Skan { 6829169689Skan invalid_kind: 6830169689Skan c_parser_error (parser, "expected %<none%> or %<shared%>"); 6831169689Skan } 6832169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>"); 6833169689Skan 6834169689Skan if (kind == OMP_CLAUSE_DEFAULT_UNSPECIFIED) 6835169689Skan return list; 6836169689Skan 6837169689Skan check_no_duplicate_clause (list, OMP_CLAUSE_DEFAULT, "default"); 6838169689Skan c = build_omp_clause (OMP_CLAUSE_DEFAULT); 6839169689Skan OMP_CLAUSE_CHAIN (c) = list; 6840169689Skan OMP_CLAUSE_DEFAULT_KIND (c) = kind; 6841169689Skan 6842169689Skan return c; 6843169689Skan} 6844169689Skan 6845169689Skan/* OpenMP 2.5: 6846169689Skan firstprivate ( variable-list ) */ 6847169689Skan 6848169689Skanstatic tree 6849169689Skanc_parser_omp_clause_firstprivate (c_parser *parser, tree list) 6850169689Skan{ 6851169689Skan return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_FIRSTPRIVATE, list); 6852169689Skan} 6853169689Skan 6854169689Skan/* OpenMP 2.5: 6855169689Skan if ( expression ) */ 6856169689Skan 6857169689Skanstatic tree 6858169689Skanc_parser_omp_clause_if (c_parser *parser, tree list) 6859169689Skan{ 6860169689Skan if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)) 6861169689Skan { 6862169689Skan tree t = c_parser_paren_condition (parser); 6863169689Skan tree c; 6864169689Skan 6865169689Skan check_no_duplicate_clause (list, OMP_CLAUSE_IF, "if"); 6866169689Skan 6867169689Skan c = build_omp_clause (OMP_CLAUSE_IF); 6868169689Skan OMP_CLAUSE_IF_EXPR (c) = t; 6869169689Skan OMP_CLAUSE_CHAIN (c) = list; 6870169689Skan list = c; 6871169689Skan } 6872169689Skan else 6873169689Skan c_parser_error (parser, "expected %<(%>"); 6874169689Skan 6875169689Skan return list; 6876169689Skan} 6877169689Skan 6878169689Skan/* OpenMP 2.5: 6879169689Skan lastprivate ( variable-list ) */ 6880169689Skan 6881169689Skanstatic tree 6882169689Skanc_parser_omp_clause_lastprivate (c_parser *parser, tree list) 6883169689Skan{ 6884169689Skan return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_LASTPRIVATE, list); 6885169689Skan} 6886169689Skan 6887169689Skan/* OpenMP 2.5: 6888169689Skan nowait */ 6889169689Skan 6890169689Skanstatic tree 6891169689Skanc_parser_omp_clause_nowait (c_parser *parser ATTRIBUTE_UNUSED, tree list) 6892169689Skan{ 6893169689Skan tree c; 6894169689Skan 6895169689Skan check_no_duplicate_clause (list, OMP_CLAUSE_NOWAIT, "nowait"); 6896169689Skan 6897169689Skan c = build_omp_clause (OMP_CLAUSE_NOWAIT); 6898169689Skan OMP_CLAUSE_CHAIN (c) = list; 6899169689Skan return c; 6900169689Skan} 6901169689Skan 6902169689Skan/* OpenMP 2.5: 6903169689Skan num_threads ( expression ) */ 6904169689Skan 6905169689Skanstatic tree 6906169689Skanc_parser_omp_clause_num_threads (c_parser *parser, tree list) 6907169689Skan{ 6908169689Skan if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 6909169689Skan { 6910169689Skan tree c, t = c_parser_expression (parser).value; 6911169689Skan 6912169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>"); 6913169689Skan 6914169689Skan if (!INTEGRAL_TYPE_P (TREE_TYPE (t))) 6915169689Skan { 6916169689Skan c_parser_error (parser, "expected integer expression"); 6917169689Skan return list; 6918169689Skan } 6919169689Skan 6920169689Skan /* Attempt to statically determine when the number isn't positive. */ 6921169689Skan c = fold_build2 (LE_EXPR, boolean_type_node, t, 6922169689Skan build_int_cst (TREE_TYPE (t), 0)); 6923169689Skan if (c == boolean_true_node) 6924169689Skan { 6925169689Skan warning (0, "%<num_threads%> value must be positive"); 6926169689Skan t = integer_one_node; 6927169689Skan } 6928169689Skan 6929169689Skan check_no_duplicate_clause (list, OMP_CLAUSE_NUM_THREADS, "num_threads"); 6930169689Skan 6931169689Skan c = build_omp_clause (OMP_CLAUSE_NUM_THREADS); 6932169689Skan OMP_CLAUSE_NUM_THREADS_EXPR (c) = t; 6933169689Skan OMP_CLAUSE_CHAIN (c) = list; 6934169689Skan list = c; 6935169689Skan } 6936169689Skan 6937169689Skan return list; 6938169689Skan} 6939169689Skan 6940169689Skan/* OpenMP 2.5: 6941169689Skan ordered */ 6942169689Skan 6943169689Skanstatic tree 6944169689Skanc_parser_omp_clause_ordered (c_parser *parser ATTRIBUTE_UNUSED, tree list) 6945169689Skan{ 6946169689Skan tree c; 6947169689Skan 6948169689Skan check_no_duplicate_clause (list, OMP_CLAUSE_ORDERED, "ordered"); 6949169689Skan 6950169689Skan c = build_omp_clause (OMP_CLAUSE_ORDERED); 6951169689Skan OMP_CLAUSE_CHAIN (c) = list; 6952169689Skan return c; 6953169689Skan} 6954169689Skan 6955169689Skan/* OpenMP 2.5: 6956169689Skan private ( variable-list ) */ 6957169689Skan 6958169689Skanstatic tree 6959169689Skanc_parser_omp_clause_private (c_parser *parser, tree list) 6960169689Skan{ 6961169689Skan return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_PRIVATE, list); 6962169689Skan} 6963169689Skan 6964169689Skan/* OpenMP 2.5: 6965169689Skan reduction ( reduction-operator : variable-list ) 6966169689Skan 6967169689Skan reduction-operator: 6968169689Skan One of: + * - & ^ | && || */ 6969169689Skan 6970169689Skanstatic tree 6971169689Skanc_parser_omp_clause_reduction (c_parser *parser, tree list) 6972169689Skan{ 6973169689Skan if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 6974169689Skan { 6975169689Skan enum tree_code code; 6976169689Skan 6977169689Skan switch (c_parser_peek_token (parser)->type) 6978169689Skan { 6979169689Skan case CPP_PLUS: 6980169689Skan code = PLUS_EXPR; 6981169689Skan break; 6982169689Skan case CPP_MULT: 6983169689Skan code = MULT_EXPR; 6984169689Skan break; 6985169689Skan case CPP_MINUS: 6986169689Skan code = MINUS_EXPR; 6987169689Skan break; 6988169689Skan case CPP_AND: 6989169689Skan code = BIT_AND_EXPR; 6990169689Skan break; 6991169689Skan case CPP_XOR: 6992169689Skan code = BIT_XOR_EXPR; 6993169689Skan break; 6994169689Skan case CPP_OR: 6995169689Skan code = BIT_IOR_EXPR; 6996169689Skan break; 6997169689Skan case CPP_AND_AND: 6998169689Skan code = TRUTH_ANDIF_EXPR; 6999169689Skan break; 7000169689Skan case CPP_OR_OR: 7001169689Skan code = TRUTH_ORIF_EXPR; 7002169689Skan break; 7003169689Skan default: 7004169689Skan c_parser_error (parser, 7005169689Skan "expected %<+%>, %<*%>, %<-%>, %<&%>, " 7006169689Skan "%<^%>, %<|%>, %<&&%>, or %<||%>"); 7007169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 0); 7008169689Skan return list; 7009169689Skan } 7010169689Skan c_parser_consume_token (parser); 7011169689Skan if (c_parser_require (parser, CPP_COLON, "expected %<:%>")) 7012169689Skan { 7013169689Skan tree nl, c; 7014169689Skan 7015169689Skan nl = c_parser_omp_variable_list (parser, OMP_CLAUSE_REDUCTION, list); 7016169689Skan for (c = nl; c != list; c = OMP_CLAUSE_CHAIN (c)) 7017169689Skan OMP_CLAUSE_REDUCTION_CODE (c) = code; 7018169689Skan 7019169689Skan list = nl; 7020169689Skan } 7021169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>"); 7022169689Skan } 7023169689Skan return list; 7024169689Skan} 7025169689Skan 7026169689Skan/* OpenMP 2.5: 7027169689Skan schedule ( schedule-kind ) 7028169689Skan schedule ( schedule-kind , expression ) 7029169689Skan 7030169689Skan schedule-kind: 7031169689Skan static | dynamic | guided | runtime 7032169689Skan*/ 7033169689Skan 7034169689Skanstatic tree 7035169689Skanc_parser_omp_clause_schedule (c_parser *parser, tree list) 7036169689Skan{ 7037169689Skan tree c, t; 7038169689Skan 7039169689Skan if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 7040169689Skan return list; 7041169689Skan 7042169689Skan c = build_omp_clause (OMP_CLAUSE_SCHEDULE); 7043169689Skan 7044169689Skan if (c_parser_next_token_is (parser, CPP_NAME)) 7045169689Skan { 7046169689Skan tree kind = c_parser_peek_token (parser)->value; 7047169689Skan const char *p = IDENTIFIER_POINTER (kind); 7048169689Skan 7049169689Skan switch (p[0]) 7050169689Skan { 7051169689Skan case 'd': 7052169689Skan if (strcmp ("dynamic", p) != 0) 7053169689Skan goto invalid_kind; 7054169689Skan OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_DYNAMIC; 7055169689Skan break; 7056169689Skan 7057169689Skan case 'g': 7058169689Skan if (strcmp ("guided", p) != 0) 7059169689Skan goto invalid_kind; 7060169689Skan OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_GUIDED; 7061169689Skan break; 7062169689Skan 7063169689Skan case 'r': 7064169689Skan if (strcmp ("runtime", p) != 0) 7065169689Skan goto invalid_kind; 7066169689Skan OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_RUNTIME; 7067169689Skan break; 7068169689Skan 7069169689Skan default: 7070169689Skan goto invalid_kind; 7071169689Skan } 7072169689Skan } 7073169689Skan else if (c_parser_next_token_is_keyword (parser, RID_STATIC)) 7074169689Skan OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_STATIC; 7075169689Skan else 7076169689Skan goto invalid_kind; 7077169689Skan 7078169689Skan c_parser_consume_token (parser); 7079169689Skan if (c_parser_next_token_is (parser, CPP_COMMA)) 7080169689Skan { 7081169689Skan c_parser_consume_token (parser); 7082169689Skan 7083169689Skan t = c_parser_expr_no_commas (parser, NULL).value; 7084169689Skan 7085169689Skan if (OMP_CLAUSE_SCHEDULE_KIND (c) == OMP_CLAUSE_SCHEDULE_RUNTIME) 7086169689Skan error ("schedule %<runtime%> does not take " 7087169689Skan "a %<chunk_size%> parameter"); 7088169689Skan else if (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE) 7089169689Skan OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c) = t; 7090169689Skan else 7091169689Skan c_parser_error (parser, "expected integer expression"); 7092169689Skan 7093169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>"); 7094169689Skan } 7095169689Skan else 7096169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 7097169689Skan "expected %<,%> or %<)%>"); 7098169689Skan 7099169689Skan check_no_duplicate_clause (list, OMP_CLAUSE_SCHEDULE, "schedule"); 7100169689Skan OMP_CLAUSE_CHAIN (c) = list; 7101169689Skan return c; 7102169689Skan 7103169689Skan invalid_kind: 7104169689Skan c_parser_error (parser, "invalid schedule kind"); 7105169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, 0); 7106169689Skan return list; 7107169689Skan} 7108169689Skan 7109169689Skan/* OpenMP 2.5: 7110169689Skan shared ( variable-list ) */ 7111169689Skan 7112169689Skanstatic tree 7113169689Skanc_parser_omp_clause_shared (c_parser *parser, tree list) 7114169689Skan{ 7115169689Skan return c_parser_omp_var_list_parens (parser, OMP_CLAUSE_SHARED, list); 7116169689Skan} 7117169689Skan 7118169689Skan/* Parse all OpenMP clauses. The set clauses allowed by the directive 7119169689Skan is a bitmask in MASK. Return the list of clauses found; the result 7120169689Skan of clause default goes in *pdefault. */ 7121169689Skan 7122169689Skanstatic tree 7123169689Skanc_parser_omp_all_clauses (c_parser *parser, unsigned int mask, 7124169689Skan const char *where) 7125169689Skan{ 7126169689Skan tree clauses = NULL; 7127169689Skan 7128169689Skan while (c_parser_next_token_is_not (parser, CPP_PRAGMA_EOL)) 7129169689Skan { 7130169689Skan const pragma_omp_clause c_kind = c_parser_omp_clause_name (parser); 7131169689Skan const char *c_name; 7132169689Skan tree prev = clauses; 7133169689Skan 7134169689Skan switch (c_kind) 7135169689Skan { 7136169689Skan case PRAGMA_OMP_CLAUSE_COPYIN: 7137169689Skan clauses = c_parser_omp_clause_copyin (parser, clauses); 7138169689Skan c_name = "copyin"; 7139169689Skan break; 7140169689Skan case PRAGMA_OMP_CLAUSE_COPYPRIVATE: 7141169689Skan clauses = c_parser_omp_clause_copyprivate (parser, clauses); 7142169689Skan c_name = "copyprivate"; 7143169689Skan break; 7144169689Skan case PRAGMA_OMP_CLAUSE_DEFAULT: 7145169689Skan clauses = c_parser_omp_clause_default (parser, clauses); 7146169689Skan c_name = "default"; 7147169689Skan break; 7148169689Skan case PRAGMA_OMP_CLAUSE_FIRSTPRIVATE: 7149169689Skan clauses = c_parser_omp_clause_firstprivate (parser, clauses); 7150169689Skan c_name = "firstprivate"; 7151169689Skan break; 7152169689Skan case PRAGMA_OMP_CLAUSE_IF: 7153169689Skan clauses = c_parser_omp_clause_if (parser, clauses); 7154169689Skan c_name = "if"; 7155169689Skan break; 7156169689Skan case PRAGMA_OMP_CLAUSE_LASTPRIVATE: 7157169689Skan clauses = c_parser_omp_clause_lastprivate (parser, clauses); 7158169689Skan c_name = "lastprivate"; 7159169689Skan break; 7160169689Skan case PRAGMA_OMP_CLAUSE_NOWAIT: 7161169689Skan clauses = c_parser_omp_clause_nowait (parser, clauses); 7162169689Skan c_name = "nowait"; 7163169689Skan break; 7164169689Skan case PRAGMA_OMP_CLAUSE_NUM_THREADS: 7165169689Skan clauses = c_parser_omp_clause_num_threads (parser, clauses); 7166169689Skan c_name = "num_threads"; 7167169689Skan break; 7168169689Skan case PRAGMA_OMP_CLAUSE_ORDERED: 7169169689Skan clauses = c_parser_omp_clause_ordered (parser, clauses); 7170169689Skan c_name = "ordered"; 7171169689Skan break; 7172169689Skan case PRAGMA_OMP_CLAUSE_PRIVATE: 7173169689Skan clauses = c_parser_omp_clause_private (parser, clauses); 7174169689Skan c_name = "private"; 7175169689Skan break; 7176169689Skan case PRAGMA_OMP_CLAUSE_REDUCTION: 7177169689Skan clauses = c_parser_omp_clause_reduction (parser, clauses); 7178169689Skan c_name = "reduction"; 7179169689Skan break; 7180169689Skan case PRAGMA_OMP_CLAUSE_SCHEDULE: 7181169689Skan clauses = c_parser_omp_clause_schedule (parser, clauses); 7182169689Skan c_name = "schedule"; 7183169689Skan break; 7184169689Skan case PRAGMA_OMP_CLAUSE_SHARED: 7185169689Skan clauses = c_parser_omp_clause_shared (parser, clauses); 7186169689Skan c_name = "shared"; 7187169689Skan break; 7188169689Skan default: 7189169689Skan c_parser_error (parser, "expected %<#pragma omp%> clause"); 7190169689Skan goto saw_error; 7191169689Skan } 7192169689Skan 7193169689Skan if (((mask >> c_kind) & 1) == 0 && !parser->error) 7194169689Skan { 7195169689Skan /* Remove the invalid clause(s) from the list to avoid 7196169689Skan confusing the rest of the compiler. */ 7197169689Skan clauses = prev; 7198169689Skan error ("%qs is not valid for %qs", c_name, where); 7199169689Skan } 7200169689Skan } 7201169689Skan 7202169689Skan saw_error: 7203169689Skan c_parser_skip_to_pragma_eol (parser); 7204169689Skan 7205169689Skan return c_finish_omp_clauses (clauses); 7206169689Skan} 7207169689Skan 7208169689Skan/* OpenMP 2.5: 7209169689Skan structured-block: 7210169689Skan statement 7211169689Skan 7212169689Skan In practice, we're also interested in adding the statement to an 7213169689Skan outer node. So it is convenient if we work around the fact that 7214169689Skan c_parser_statement calls add_stmt. */ 7215169689Skan 7216169689Skanstatic tree 7217169689Skanc_parser_omp_structured_block (c_parser *parser) 7218169689Skan{ 7219169689Skan tree stmt = push_stmt_list (); 7220169689Skan c_parser_statement (parser); 7221169689Skan return pop_stmt_list (stmt); 7222169689Skan} 7223169689Skan 7224169689Skan/* OpenMP 2.5: 7225169689Skan # pragma omp atomic new-line 7226169689Skan expression-stmt 7227169689Skan 7228169689Skan expression-stmt: 7229169689Skan x binop= expr | x++ | ++x | x-- | --x 7230169689Skan binop: 7231169689Skan +, *, -, /, &, ^, |, <<, >> 7232169689Skan 7233169689Skan where x is an lvalue expression with scalar type. */ 7234169689Skan 7235169689Skanstatic void 7236169689Skanc_parser_omp_atomic (c_parser *parser) 7237169689Skan{ 7238169689Skan tree lhs, rhs; 7239169689Skan tree stmt; 7240169689Skan enum tree_code code; 7241169689Skan 7242169689Skan c_parser_skip_to_pragma_eol (parser); 7243169689Skan 7244169689Skan lhs = c_parser_unary_expression (parser).value; 7245169689Skan switch (TREE_CODE (lhs)) 7246169689Skan { 7247169689Skan case ERROR_MARK: 7248169689Skan saw_error: 7249169689Skan c_parser_skip_to_end_of_block_or_statement (parser); 7250169689Skan return; 7251169689Skan 7252169689Skan case PREINCREMENT_EXPR: 7253169689Skan case POSTINCREMENT_EXPR: 7254169689Skan lhs = TREE_OPERAND (lhs, 0); 7255169689Skan code = PLUS_EXPR; 7256169689Skan rhs = integer_one_node; 7257169689Skan break; 7258169689Skan 7259169689Skan case PREDECREMENT_EXPR: 7260169689Skan case POSTDECREMENT_EXPR: 7261169689Skan lhs = TREE_OPERAND (lhs, 0); 7262169689Skan code = MINUS_EXPR; 7263169689Skan rhs = integer_one_node; 7264169689Skan break; 7265169689Skan 7266169689Skan default: 7267169689Skan switch (c_parser_peek_token (parser)->type) 7268169689Skan { 7269169689Skan case CPP_MULT_EQ: 7270169689Skan code = MULT_EXPR; 7271169689Skan break; 7272169689Skan case CPP_DIV_EQ: 7273169689Skan code = TRUNC_DIV_EXPR; 7274169689Skan break; 7275169689Skan case CPP_PLUS_EQ: 7276169689Skan code = PLUS_EXPR; 7277169689Skan break; 7278169689Skan case CPP_MINUS_EQ: 7279169689Skan code = MINUS_EXPR; 7280169689Skan break; 7281169689Skan case CPP_LSHIFT_EQ: 7282169689Skan code = LSHIFT_EXPR; 7283169689Skan break; 7284169689Skan case CPP_RSHIFT_EQ: 7285169689Skan code = RSHIFT_EXPR; 7286169689Skan break; 7287169689Skan case CPP_AND_EQ: 7288169689Skan code = BIT_AND_EXPR; 7289169689Skan break; 7290169689Skan case CPP_OR_EQ: 7291169689Skan code = BIT_IOR_EXPR; 7292169689Skan break; 7293169689Skan case CPP_XOR_EQ: 7294169689Skan code = BIT_XOR_EXPR; 7295169689Skan break; 7296169689Skan default: 7297169689Skan c_parser_error (parser, 7298169689Skan "invalid operator for %<#pragma omp atomic%>"); 7299169689Skan goto saw_error; 7300169689Skan } 7301169689Skan 7302169689Skan c_parser_consume_token (parser); 7303169689Skan rhs = c_parser_expression (parser).value; 7304169689Skan break; 7305169689Skan } 7306169689Skan stmt = c_finish_omp_atomic (code, lhs, rhs); 7307169689Skan if (stmt != error_mark_node) 7308169689Skan add_stmt (stmt); 7309169689Skan c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>"); 7310169689Skan} 7311169689Skan 7312169689Skan 7313169689Skan/* OpenMP 2.5: 7314169689Skan # pragma omp barrier new-line 7315169689Skan*/ 7316169689Skan 7317169689Skanstatic void 7318169689Skanc_parser_omp_barrier (c_parser *parser) 7319169689Skan{ 7320169689Skan c_parser_consume_pragma (parser); 7321169689Skan c_parser_skip_to_pragma_eol (parser); 7322169689Skan 7323169689Skan c_finish_omp_barrier (); 7324169689Skan} 7325169689Skan 7326169689Skan/* OpenMP 2.5: 7327169689Skan # pragma omp critical [(name)] new-line 7328169689Skan structured-block 7329169689Skan*/ 7330169689Skan 7331169689Skanstatic tree 7332169689Skanc_parser_omp_critical (c_parser *parser) 7333169689Skan{ 7334169689Skan tree stmt, name = NULL; 7335169689Skan 7336169689Skan if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)) 7337169689Skan { 7338169689Skan c_parser_consume_token (parser); 7339169689Skan if (c_parser_next_token_is (parser, CPP_NAME)) 7340169689Skan { 7341169689Skan name = c_parser_peek_token (parser)->value; 7342169689Skan c_parser_consume_token (parser); 7343169689Skan c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"); 7344169689Skan } 7345169689Skan else 7346169689Skan c_parser_error (parser, "expected identifier"); 7347169689Skan } 7348169689Skan else if (c_parser_next_token_is_not (parser, CPP_PRAGMA_EOL)) 7349169689Skan c_parser_error (parser, "expected %<(%> or end of line"); 7350169689Skan c_parser_skip_to_pragma_eol (parser); 7351169689Skan 7352169689Skan stmt = c_parser_omp_structured_block (parser); 7353169689Skan return c_finish_omp_critical (stmt, name); 7354169689Skan} 7355169689Skan 7356169689Skan/* OpenMP 2.5: 7357169689Skan # pragma omp flush flush-vars[opt] new-line 7358169689Skan 7359169689Skan flush-vars: 7360169689Skan ( variable-list ) */ 7361169689Skan 7362169689Skanstatic void 7363169689Skanc_parser_omp_flush (c_parser *parser) 7364169689Skan{ 7365169689Skan c_parser_consume_pragma (parser); 7366169689Skan if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)) 7367169689Skan c_parser_omp_var_list_parens (parser, 0, NULL); 7368169689Skan else if (c_parser_next_token_is_not (parser, CPP_PRAGMA_EOL)) 7369169689Skan c_parser_error (parser, "expected %<(%> or end of line"); 7370169689Skan c_parser_skip_to_pragma_eol (parser); 7371169689Skan 7372169689Skan c_finish_omp_flush (); 7373169689Skan} 7374169689Skan 7375169689Skan/* Parse the restricted form of the for statment allowed by OpenMP. 7376169689Skan The real trick here is to determine the loop control variable early 7377169689Skan so that we can push a new decl if necessary to make it private. */ 7378169689Skan 7379169689Skanstatic tree 7380169689Skanc_parser_omp_for_loop (c_parser *parser) 7381169689Skan{ 7382169689Skan tree decl, cond, incr, save_break, save_cont, body, init; 7383169689Skan location_t loc; 7384169689Skan 7385169689Skan if (!c_parser_next_token_is_keyword (parser, RID_FOR)) 7386169689Skan { 7387169689Skan c_parser_error (parser, "for statement expected"); 7388169689Skan return NULL; 7389169689Skan } 7390169689Skan loc = c_parser_peek_token (parser)->location; 7391169689Skan c_parser_consume_token (parser); 7392169689Skan 7393169689Skan if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) 7394169689Skan return NULL; 7395169689Skan 7396169689Skan /* Parse the initialization declaration or expression. */ 7397169689Skan if (c_parser_next_token_starts_declspecs (parser)) 7398169689Skan { 7399169689Skan c_parser_declaration_or_fndef (parser, true, true, true, true); 7400169689Skan decl = check_for_loop_decls (); 7401169689Skan if (decl == NULL) 7402169689Skan goto error_init; 7403169689Skan init = decl; 7404169689Skan } 7405169689Skan else if (c_parser_next_token_is (parser, CPP_NAME) 7406169689Skan && c_parser_peek_2nd_token (parser)->type == CPP_EQ) 7407169689Skan { 7408169689Skan decl = c_parser_postfix_expression (parser).value; 7409169689Skan 7410169689Skan c_parser_require (parser, CPP_EQ, "expected %<=%>"); 7411169689Skan 7412169689Skan init = c_parser_expr_no_commas (parser, NULL).value; 7413169689Skan init = build_modify_expr (decl, NOP_EXPR, init); 7414169689Skan init = c_process_expr_stmt (init); 7415169689Skan 7416169689Skan c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>"); 7417169689Skan } 7418169689Skan else 7419169689Skan goto error_init; 7420169689Skan 7421169689Skan /* Parse the loop condition. */ 7422169689Skan cond = NULL_TREE; 7423169689Skan if (c_parser_next_token_is_not (parser, CPP_SEMICOLON)) 7424169689Skan { 7425169689Skan cond = c_parser_expression_conv (parser).value; 7426169689Skan cond = c_objc_common_truthvalue_conversion (cond); 7427169689Skan if (EXPR_P (cond)) 7428169689Skan SET_EXPR_LOCATION (cond, input_location); 7429169689Skan } 7430169689Skan c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>"); 7431169689Skan 7432169689Skan /* Parse the increment expression. */ 7433169689Skan incr = NULL_TREE; 7434169689Skan if (c_parser_next_token_is_not (parser, CPP_CLOSE_PAREN)) 7435169689Skan incr = c_process_expr_stmt (c_parser_expression (parser).value); 7436169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>"); 7437169689Skan 7438169689Skan parse_body: 7439169689Skan save_break = c_break_label; 7440169689Skan c_break_label = size_one_node; 7441169689Skan save_cont = c_cont_label; 7442169689Skan c_cont_label = NULL_TREE; 7443169689Skan body = push_stmt_list (); 7444169689Skan 7445169689Skan add_stmt (c_parser_c99_block_statement (parser)); 7446169689Skan if (c_cont_label) 7447169689Skan add_stmt (build1 (LABEL_EXPR, void_type_node, c_cont_label)); 7448169689Skan 7449169689Skan body = pop_stmt_list (body); 7450169689Skan c_break_label = save_break; 7451169689Skan c_cont_label = save_cont; 7452169689Skan 7453169689Skan /* Only bother calling c_finish_omp_for if we havn't already generated 7454169689Skan an error from the initialization parsing. */ 7455169689Skan if (decl != NULL && decl != error_mark_node && init != error_mark_node) 7456169689Skan return c_finish_omp_for (loc, decl, init, cond, incr, body, NULL); 7457169689Skan return NULL; 7458169689Skan 7459169689Skan error_init: 7460169689Skan c_parser_error (parser, "expected iteration declaration or initialization"); 7461169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>"); 7462169689Skan decl = init = cond = incr = NULL_TREE; 7463169689Skan goto parse_body; 7464169689Skan} 7465169689Skan 7466169689Skan/* OpenMP 2.5: 7467169689Skan #pragma omp for for-clause[optseq] new-line 7468169689Skan for-loop 7469169689Skan*/ 7470169689Skan 7471169689Skan#define OMP_FOR_CLAUSE_MASK \ 7472169689Skan ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \ 7473169689Skan | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \ 7474169689Skan | (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \ 7475169689Skan | (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \ 7476169689Skan | (1u << PRAGMA_OMP_CLAUSE_ORDERED) \ 7477169689Skan | (1u << PRAGMA_OMP_CLAUSE_SCHEDULE) \ 7478169689Skan | (1u << PRAGMA_OMP_CLAUSE_NOWAIT)) 7479169689Skan 7480169689Skanstatic tree 7481169689Skanc_parser_omp_for (c_parser *parser) 7482169689Skan{ 7483169689Skan tree block, clauses, ret; 7484169689Skan 7485169689Skan clauses = c_parser_omp_all_clauses (parser, OMP_FOR_CLAUSE_MASK, 7486169689Skan "#pragma omp for"); 7487169689Skan 7488169689Skan block = c_begin_compound_stmt (true); 7489169689Skan ret = c_parser_omp_for_loop (parser); 7490169689Skan if (ret) 7491169689Skan OMP_FOR_CLAUSES (ret) = clauses; 7492169689Skan block = c_end_compound_stmt (block, true); 7493169689Skan add_stmt (block); 7494169689Skan 7495169689Skan return ret; 7496169689Skan} 7497169689Skan 7498169689Skan/* OpenMP 2.5: 7499169689Skan # pragma omp master new-line 7500169689Skan structured-block 7501169689Skan*/ 7502169689Skan 7503169689Skanstatic tree 7504169689Skanc_parser_omp_master (c_parser *parser) 7505169689Skan{ 7506169689Skan c_parser_skip_to_pragma_eol (parser); 7507169689Skan return c_finish_omp_master (c_parser_omp_structured_block (parser)); 7508169689Skan} 7509169689Skan 7510169689Skan/* OpenMP 2.5: 7511169689Skan # pragma omp ordered new-line 7512169689Skan structured-block 7513169689Skan*/ 7514169689Skan 7515169689Skanstatic tree 7516169689Skanc_parser_omp_ordered (c_parser *parser) 7517169689Skan{ 7518169689Skan c_parser_skip_to_pragma_eol (parser); 7519169689Skan return c_finish_omp_ordered (c_parser_omp_structured_block (parser)); 7520169689Skan} 7521169689Skan 7522169689Skan/* OpenMP 2.5: 7523169689Skan 7524169689Skan section-scope: 7525169689Skan { section-sequence } 7526169689Skan 7527169689Skan section-sequence: 7528169689Skan section-directive[opt] structured-block 7529169689Skan section-sequence section-directive structured-block */ 7530169689Skan 7531169689Skanstatic tree 7532169689Skanc_parser_omp_sections_scope (c_parser *parser) 7533169689Skan{ 7534169689Skan tree stmt, substmt; 7535169689Skan bool error_suppress = false; 7536169689Skan location_t loc; 7537169689Skan 7538169689Skan if (!c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>")) 7539169689Skan { 7540169689Skan /* Avoid skipping until the end of the block. */ 7541169689Skan parser->error = false; 7542169689Skan return NULL_TREE; 7543169689Skan } 7544169689Skan 7545169689Skan stmt = push_stmt_list (); 7546169689Skan 7547169689Skan loc = c_parser_peek_token (parser)->location; 7548169689Skan if (c_parser_peek_token (parser)->pragma_kind != PRAGMA_OMP_SECTION) 7549169689Skan { 7550169689Skan substmt = push_stmt_list (); 7551169689Skan 7552169689Skan while (1) 7553169689Skan { 7554169689Skan c_parser_statement (parser); 7555169689Skan 7556169689Skan if (c_parser_peek_token (parser)->pragma_kind == PRAGMA_OMP_SECTION) 7557169689Skan break; 7558169689Skan if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE)) 7559169689Skan break; 7560169689Skan if (c_parser_next_token_is (parser, CPP_EOF)) 7561169689Skan break; 7562169689Skan } 7563169689Skan 7564169689Skan substmt = pop_stmt_list (substmt); 7565169689Skan substmt = build1 (OMP_SECTION, void_type_node, substmt); 7566169689Skan SET_EXPR_LOCATION (substmt, loc); 7567169689Skan add_stmt (substmt); 7568169689Skan } 7569169689Skan 7570169689Skan while (1) 7571169689Skan { 7572169689Skan if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE)) 7573169689Skan break; 7574169689Skan if (c_parser_next_token_is (parser, CPP_EOF)) 7575169689Skan break; 7576169689Skan 7577169689Skan loc = c_parser_peek_token (parser)->location; 7578169689Skan if (c_parser_peek_token (parser)->pragma_kind == PRAGMA_OMP_SECTION) 7579169689Skan { 7580169689Skan c_parser_consume_pragma (parser); 7581169689Skan c_parser_skip_to_pragma_eol (parser); 7582169689Skan error_suppress = false; 7583169689Skan } 7584169689Skan else if (!error_suppress) 7585169689Skan { 7586169689Skan error ("expected %<#pragma omp section%> or %<}%>"); 7587169689Skan error_suppress = true; 7588169689Skan } 7589169689Skan 7590169689Skan substmt = c_parser_omp_structured_block (parser); 7591169689Skan substmt = build1 (OMP_SECTION, void_type_node, substmt); 7592169689Skan SET_EXPR_LOCATION (substmt, loc); 7593169689Skan add_stmt (substmt); 7594169689Skan } 7595169689Skan c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, 7596169689Skan "expected %<#pragma omp section%> or %<}%>"); 7597169689Skan 7598169689Skan substmt = pop_stmt_list (stmt); 7599169689Skan 7600169689Skan stmt = make_node (OMP_SECTIONS); 7601169689Skan TREE_TYPE (stmt) = void_type_node; 7602169689Skan OMP_SECTIONS_BODY (stmt) = substmt; 7603169689Skan 7604169689Skan return add_stmt (stmt); 7605169689Skan} 7606169689Skan 7607169689Skan/* OpenMP 2.5: 7608169689Skan # pragma omp sections sections-clause[optseq] newline 7609169689Skan sections-scope 7610169689Skan*/ 7611169689Skan 7612169689Skan#define OMP_SECTIONS_CLAUSE_MASK \ 7613169689Skan ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \ 7614169689Skan | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \ 7615169689Skan | (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \ 7616169689Skan | (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \ 7617169689Skan | (1u << PRAGMA_OMP_CLAUSE_NOWAIT)) 7618169689Skan 7619169689Skanstatic tree 7620169689Skanc_parser_omp_sections (c_parser *parser) 7621169689Skan{ 7622169689Skan tree block, clauses, ret; 7623169689Skan 7624169689Skan clauses = c_parser_omp_all_clauses (parser, OMP_SECTIONS_CLAUSE_MASK, 7625169689Skan "#pragma omp sections"); 7626169689Skan 7627169689Skan block = c_begin_compound_stmt (true); 7628169689Skan ret = c_parser_omp_sections_scope (parser); 7629169689Skan if (ret) 7630169689Skan OMP_SECTIONS_CLAUSES (ret) = clauses; 7631169689Skan block = c_end_compound_stmt (block, true); 7632169689Skan add_stmt (block); 7633169689Skan 7634169689Skan return ret; 7635169689Skan} 7636169689Skan 7637169689Skan/* OpenMP 2.5: 7638169689Skan # pragma parallel parallel-clause new-line 7639169689Skan # pragma parallel for parallel-for-clause new-line 7640169689Skan # pragma parallel sections parallel-sections-clause new-line 7641169689Skan*/ 7642169689Skan 7643169689Skan#define OMP_PARALLEL_CLAUSE_MASK \ 7644169689Skan ( (1u << PRAGMA_OMP_CLAUSE_IF) \ 7645169689Skan | (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \ 7646169689Skan | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \ 7647169689Skan | (1u << PRAGMA_OMP_CLAUSE_DEFAULT) \ 7648169689Skan | (1u << PRAGMA_OMP_CLAUSE_SHARED) \ 7649169689Skan | (1u << PRAGMA_OMP_CLAUSE_COPYIN) \ 7650169689Skan | (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \ 7651169689Skan | (1u << PRAGMA_OMP_CLAUSE_NUM_THREADS)) 7652169689Skan 7653169689Skanstatic tree 7654169689Skanc_parser_omp_parallel (c_parser *parser) 7655169689Skan{ 7656169689Skan enum pragma_kind p_kind = PRAGMA_OMP_PARALLEL; 7657169689Skan const char *p_name = "#pragma omp parallel"; 7658169689Skan tree stmt, clauses, par_clause, ws_clause, block; 7659169689Skan unsigned int mask = OMP_PARALLEL_CLAUSE_MASK; 7660169689Skan 7661169689Skan if (c_parser_next_token_is_keyword (parser, RID_FOR)) 7662169689Skan { 7663169689Skan c_parser_consume_token (parser); 7664169689Skan p_kind = PRAGMA_OMP_PARALLEL_FOR; 7665169689Skan p_name = "#pragma omp parallel for"; 7666169689Skan mask |= OMP_FOR_CLAUSE_MASK; 7667169689Skan mask &= ~(1u << PRAGMA_OMP_CLAUSE_NOWAIT); 7668169689Skan } 7669169689Skan else if (c_parser_next_token_is (parser, CPP_NAME)) 7670169689Skan { 7671169689Skan const char *p = IDENTIFIER_POINTER (c_parser_peek_token (parser)->value); 7672169689Skan if (strcmp (p, "sections") == 0) 7673169689Skan { 7674169689Skan c_parser_consume_token (parser); 7675169689Skan p_kind = PRAGMA_OMP_PARALLEL_SECTIONS; 7676169689Skan p_name = "#pragma omp parallel sections"; 7677169689Skan mask |= OMP_SECTIONS_CLAUSE_MASK; 7678169689Skan mask &= ~(1u << PRAGMA_OMP_CLAUSE_NOWAIT); 7679169689Skan } 7680169689Skan } 7681169689Skan 7682169689Skan clauses = c_parser_omp_all_clauses (parser, mask, p_name); 7683169689Skan 7684169689Skan switch (p_kind) 7685169689Skan { 7686169689Skan case PRAGMA_OMP_PARALLEL: 7687169689Skan block = c_begin_omp_parallel (); 7688169689Skan c_parser_statement (parser); 7689169689Skan stmt = c_finish_omp_parallel (clauses, block); 7690169689Skan break; 7691169689Skan 7692169689Skan case PRAGMA_OMP_PARALLEL_FOR: 7693169689Skan block = c_begin_omp_parallel (); 7694169689Skan c_split_parallel_clauses (clauses, &par_clause, &ws_clause); 7695169689Skan stmt = c_parser_omp_for_loop (parser); 7696169689Skan if (stmt) 7697169689Skan OMP_FOR_CLAUSES (stmt) = ws_clause; 7698169689Skan stmt = c_finish_omp_parallel (par_clause, block); 7699169689Skan OMP_PARALLEL_COMBINED (stmt) = 1; 7700169689Skan break; 7701169689Skan 7702169689Skan case PRAGMA_OMP_PARALLEL_SECTIONS: 7703169689Skan block = c_begin_omp_parallel (); 7704169689Skan c_split_parallel_clauses (clauses, &par_clause, &ws_clause); 7705169689Skan stmt = c_parser_omp_sections_scope (parser); 7706169689Skan if (stmt) 7707169689Skan OMP_SECTIONS_CLAUSES (stmt) = ws_clause; 7708169689Skan stmt = c_finish_omp_parallel (par_clause, block); 7709169689Skan OMP_PARALLEL_COMBINED (stmt) = 1; 7710169689Skan break; 7711169689Skan 7712169689Skan default: 7713169689Skan gcc_unreachable (); 7714169689Skan } 7715169689Skan 7716169689Skan return stmt; 7717169689Skan} 7718169689Skan 7719169689Skan/* OpenMP 2.5: 7720169689Skan # pragma omp single single-clause[optseq] new-line 7721169689Skan structured-block 7722169689Skan*/ 7723169689Skan 7724169689Skan#define OMP_SINGLE_CLAUSE_MASK \ 7725169689Skan ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \ 7726169689Skan | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \ 7727169689Skan | (1u << PRAGMA_OMP_CLAUSE_COPYPRIVATE) \ 7728169689Skan | (1u << PRAGMA_OMP_CLAUSE_NOWAIT)) 7729169689Skan 7730169689Skanstatic tree 7731169689Skanc_parser_omp_single (c_parser *parser) 7732169689Skan{ 7733169689Skan tree stmt = make_node (OMP_SINGLE); 7734169689Skan TREE_TYPE (stmt) = void_type_node; 7735169689Skan 7736169689Skan OMP_SINGLE_CLAUSES (stmt) 7737169689Skan = c_parser_omp_all_clauses (parser, OMP_SINGLE_CLAUSE_MASK, 7738169689Skan "#pragma omp single"); 7739169689Skan OMP_SINGLE_BODY (stmt) = c_parser_omp_structured_block (parser); 7740169689Skan 7741169689Skan return add_stmt (stmt); 7742169689Skan} 7743169689Skan 7744169689Skan 7745169689Skan/* Main entry point to parsing most OpenMP pragmas. */ 7746169689Skan 7747169689Skanstatic void 7748169689Skanc_parser_omp_construct (c_parser *parser) 7749169689Skan{ 7750169689Skan enum pragma_kind p_kind; 7751169689Skan location_t loc; 7752169689Skan tree stmt; 7753169689Skan 7754169689Skan loc = c_parser_peek_token (parser)->location; 7755169689Skan p_kind = c_parser_peek_token (parser)->pragma_kind; 7756169689Skan c_parser_consume_pragma (parser); 7757169689Skan 7758169689Skan /* For all constructs below except #pragma omp atomic 7759169689Skan MUST_NOT_THROW catch handlers are needed when exceptions 7760169689Skan are enabled. */ 7761169689Skan if (p_kind != PRAGMA_OMP_ATOMIC) 7762169689Skan c_maybe_initialize_eh (); 7763169689Skan 7764169689Skan switch (p_kind) 7765169689Skan { 7766169689Skan case PRAGMA_OMP_ATOMIC: 7767169689Skan c_parser_omp_atomic (parser); 7768169689Skan return; 7769169689Skan case PRAGMA_OMP_CRITICAL: 7770169689Skan stmt = c_parser_omp_critical (parser); 7771169689Skan break; 7772169689Skan case PRAGMA_OMP_FOR: 7773169689Skan stmt = c_parser_omp_for (parser); 7774169689Skan break; 7775169689Skan case PRAGMA_OMP_MASTER: 7776169689Skan stmt = c_parser_omp_master (parser); 7777169689Skan break; 7778169689Skan case PRAGMA_OMP_ORDERED: 7779169689Skan stmt = c_parser_omp_ordered (parser); 7780169689Skan break; 7781169689Skan case PRAGMA_OMP_PARALLEL: 7782169689Skan stmt = c_parser_omp_parallel (parser); 7783169689Skan break; 7784169689Skan case PRAGMA_OMP_SECTIONS: 7785169689Skan stmt = c_parser_omp_sections (parser); 7786169689Skan break; 7787169689Skan case PRAGMA_OMP_SINGLE: 7788169689Skan stmt = c_parser_omp_single (parser); 7789169689Skan break; 7790169689Skan default: 7791169689Skan gcc_unreachable (); 7792169689Skan } 7793169689Skan 7794169689Skan if (stmt) 7795169689Skan SET_EXPR_LOCATION (stmt, loc); 7796169689Skan} 7797169689Skan 7798169689Skan 7799169689Skan/* OpenMP 2.5: 7800169689Skan # pragma omp threadprivate (variable-list) */ 7801169689Skan 7802169689Skanstatic void 7803169689Skanc_parser_omp_threadprivate (c_parser *parser) 7804169689Skan{ 7805169689Skan tree vars, t; 7806169689Skan 7807169689Skan c_parser_consume_pragma (parser); 7808169689Skan vars = c_parser_omp_var_list_parens (parser, 0, NULL); 7809169689Skan 7810169689Skan if (!targetm.have_tls) 7811169689Skan sorry ("threadprivate variables not supported in this target"); 7812169689Skan 7813169689Skan /* Mark every variable in VARS to be assigned thread local storage. */ 7814169689Skan for (t = vars; t; t = TREE_CHAIN (t)) 7815169689Skan { 7816169689Skan tree v = TREE_PURPOSE (t); 7817169689Skan 7818169689Skan /* If V had already been marked threadprivate, it doesn't matter 7819169689Skan whether it had been used prior to this point. */ 7820169689Skan if (TREE_USED (v) && !C_DECL_THREADPRIVATE_P (v)) 7821169689Skan error ("%qE declared %<threadprivate%> after first use", v); 7822169689Skan else if (! TREE_STATIC (v) && ! DECL_EXTERNAL (v)) 7823169689Skan error ("automatic variable %qE cannot be %<threadprivate%>", v); 7824169689Skan else if (! COMPLETE_TYPE_P (TREE_TYPE (v))) 7825169689Skan error ("%<threadprivate%> %qE has incomplete type", v); 7826169689Skan else 7827169689Skan { 7828169689Skan if (! DECL_THREAD_LOCAL_P (v)) 7829169689Skan { 7830169689Skan DECL_TLS_MODEL (v) = decl_default_tls_model (v); 7831169689Skan /* If rtl has been already set for this var, call 7832169689Skan make_decl_rtl once again, so that encode_section_info 7833169689Skan has a chance to look at the new decl flags. */ 7834169689Skan if (DECL_RTL_SET_P (v)) 7835169689Skan make_decl_rtl (v); 7836169689Skan } 7837169689Skan C_DECL_THREADPRIVATE_P (v) = 1; 7838169689Skan } 7839169689Skan } 7840169689Skan 7841169689Skan c_parser_skip_to_pragma_eol (parser); 7842169689Skan} 7843169689Skan 7844169689Skan 7845169689Skan/* Parse a single source file. */ 7846169689Skan 7847169689Skanvoid 7848169689Skanc_parse_file (void) 7849169689Skan{ 7850169689Skan /* Use local storage to begin. If the first token is a pragma, parse it. 7851169689Skan If it is #pragma GCC pch_preprocess, then this will load a PCH file 7852169689Skan which will cause garbage collection. */ 7853169689Skan c_parser tparser; 7854169689Skan 7855169689Skan memset (&tparser, 0, sizeof tparser); 7856169689Skan the_parser = &tparser; 7857169689Skan 7858169689Skan if (c_parser_peek_token (&tparser)->pragma_kind == PRAGMA_GCC_PCH_PREPROCESS) 7859169689Skan c_parser_pragma_pch_preprocess (&tparser); 7860169689Skan 7861169689Skan the_parser = GGC_NEW (c_parser); 7862169689Skan *the_parser = tparser; 7863169689Skan 7864169689Skan c_parser_translation_unit (the_parser); 7865169689Skan the_parser = NULL; 7866169689Skan} 7867169689Skan 7868169689Skan#include "gt-c-parser.h" 7869