* sv.po, zh_CN.po: Update.
[official-gcc.git] / gcc / c-parser.c
blob9a6799435e105e80931fd40f48a5af4cafc1c3bc
1 /* Parser for C and Objective-C.
2 Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
5 Parser actions based on the old Bison parser; structure somewhat
6 influenced by and fragments based on the C++ parser.
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify it under
11 the terms of the GNU General Public License as published by the Free
12 Software Foundation; either version 2, or (at your option) any later
13 version.
15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 for more details.
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING. If not, write to the Free
22 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
23 02110-1301, USA. */
25 /* TODO:
27 Make sure all relevant comments, and all relevant code from all
28 actions, brought over from old parser. Verify exact correspondence
29 of syntax accepted.
31 Add testcases covering every input symbol in every state in old and
32 new parsers.
34 Include full syntax for GNU C, including erroneous cases accepted
35 with error messages, in syntax productions in comments.
37 Make more diagnostics in the front end generally take an explicit
38 location rather than implicitly using input_location. */
40 #include "config.h"
41 #include "system.h"
42 #include "coretypes.h"
43 #include "tm.h"
44 #include "tree.h"
45 #include "langhooks.h"
46 #include "input.h"
47 #include "cpplib.h"
48 #include "timevar.h"
49 #include "c-pragma.h"
50 #include "c-tree.h"
51 #include "flags.h"
52 #include "output.h"
53 #include "toplev.h"
54 #include "ggc.h"
55 #include "c-common.h"
58 /* Miscellaneous data and functions needed for the parser. */
60 int yydebug;
62 /* Objective-C specific parser/lexer information. */
64 static int objc_pq_context = 0;
66 /* The following flag is needed to contextualize Objective-C lexical
67 analysis. In some cases (e.g., 'int NSObject;'), it is undesirable
68 to bind an identifier to an Objective-C class, even if a class with
69 that name exists. */
70 static int objc_need_raw_identifier = 0;
71 #define OBJC_NEED_RAW_IDENTIFIER(VAL) \
72 do { \
73 if (c_dialect_objc ()) \
74 objc_need_raw_identifier = VAL; \
75 } while (0)
77 /* The reserved keyword table. */
78 struct resword
80 const char *word;
81 ENUM_BITFIELD(rid) rid : 16;
82 unsigned int disable : 16;
85 /* Disable mask. Keywords are disabled if (reswords[i].disable &
86 mask) is _true_. */
87 #define D_C89 0x01 /* not in C89 */
88 #define D_EXT 0x02 /* GCC extension */
89 #define D_EXT89 0x04 /* GCC extension incorporated in C99 */
90 #define D_OBJC 0x08 /* Objective C only */
92 static const struct resword reswords[] =
94 { "_Bool", RID_BOOL, 0 },
95 { "_Complex", RID_COMPLEX, 0 },
96 { "__FUNCTION__", RID_FUNCTION_NAME, 0 },
97 { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 },
98 { "__alignof", RID_ALIGNOF, 0 },
99 { "__alignof__", RID_ALIGNOF, 0 },
100 { "__asm", RID_ASM, 0 },
101 { "__asm__", RID_ASM, 0 },
102 { "__attribute", RID_ATTRIBUTE, 0 },
103 { "__attribute__", RID_ATTRIBUTE, 0 },
104 { "__builtin_choose_expr", RID_CHOOSE_EXPR, 0 },
105 { "__builtin_offsetof", RID_OFFSETOF, 0 },
106 { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P, 0 },
107 { "__builtin_va_arg", RID_VA_ARG, 0 },
108 { "__complex", RID_COMPLEX, 0 },
109 { "__complex__", RID_COMPLEX, 0 },
110 { "__const", RID_CONST, 0 },
111 { "__const__", RID_CONST, 0 },
112 { "__extension__", RID_EXTENSION, 0 },
113 { "__func__", RID_C99_FUNCTION_NAME, 0 },
114 { "__imag", RID_IMAGPART, 0 },
115 { "__imag__", RID_IMAGPART, 0 },
116 { "__inline", RID_INLINE, 0 },
117 { "__inline__", RID_INLINE, 0 },
118 { "__label__", RID_LABEL, 0 },
119 { "__real", RID_REALPART, 0 },
120 { "__real__", RID_REALPART, 0 },
121 { "__restrict", RID_RESTRICT, 0 },
122 { "__restrict__", RID_RESTRICT, 0 },
123 { "__signed", RID_SIGNED, 0 },
124 { "__signed__", RID_SIGNED, 0 },
125 { "__thread", RID_THREAD, 0 },
126 { "__typeof", RID_TYPEOF, 0 },
127 { "__typeof__", RID_TYPEOF, 0 },
128 { "__volatile", RID_VOLATILE, 0 },
129 { "__volatile__", RID_VOLATILE, 0 },
130 { "asm", RID_ASM, D_EXT },
131 { "auto", RID_AUTO, 0 },
132 { "break", RID_BREAK, 0 },
133 { "case", RID_CASE, 0 },
134 { "char", RID_CHAR, 0 },
135 { "const", RID_CONST, 0 },
136 { "continue", RID_CONTINUE, 0 },
137 { "default", RID_DEFAULT, 0 },
138 { "do", RID_DO, 0 },
139 { "double", RID_DOUBLE, 0 },
140 { "else", RID_ELSE, 0 },
141 { "enum", RID_ENUM, 0 },
142 { "extern", RID_EXTERN, 0 },
143 { "float", RID_FLOAT, 0 },
144 { "for", RID_FOR, 0 },
145 { "goto", RID_GOTO, 0 },
146 { "if", RID_IF, 0 },
147 { "inline", RID_INLINE, D_EXT89 },
148 { "int", RID_INT, 0 },
149 { "long", RID_LONG, 0 },
150 { "register", RID_REGISTER, 0 },
151 { "restrict", RID_RESTRICT, D_C89 },
152 { "return", RID_RETURN, 0 },
153 { "short", RID_SHORT, 0 },
154 { "signed", RID_SIGNED, 0 },
155 { "sizeof", RID_SIZEOF, 0 },
156 { "static", RID_STATIC, 0 },
157 { "struct", RID_STRUCT, 0 },
158 { "switch", RID_SWITCH, 0 },
159 { "typedef", RID_TYPEDEF, 0 },
160 { "typeof", RID_TYPEOF, D_EXT },
161 { "union", RID_UNION, 0 },
162 { "unsigned", RID_UNSIGNED, 0 },
163 { "void", RID_VOID, 0 },
164 { "volatile", RID_VOLATILE, 0 },
165 { "while", RID_WHILE, 0 },
166 /* These Objective-C keywords are recognized only immediately after
167 an '@'. */
168 { "class", RID_AT_CLASS, D_OBJC },
169 { "compatibility_alias", RID_AT_ALIAS, D_OBJC },
170 { "defs", RID_AT_DEFS, D_OBJC },
171 { "encode", RID_AT_ENCODE, D_OBJC },
172 { "end", RID_AT_END, D_OBJC },
173 { "implementation", RID_AT_IMPLEMENTATION, D_OBJC },
174 { "interface", RID_AT_INTERFACE, D_OBJC },
175 { "private", RID_AT_PRIVATE, D_OBJC },
176 { "protected", RID_AT_PROTECTED, D_OBJC },
177 { "protocol", RID_AT_PROTOCOL, D_OBJC },
178 { "public", RID_AT_PUBLIC, D_OBJC },
179 { "selector", RID_AT_SELECTOR, D_OBJC },
180 { "throw", RID_AT_THROW, D_OBJC },
181 { "try", RID_AT_TRY, D_OBJC },
182 { "catch", RID_AT_CATCH, D_OBJC },
183 { "finally", RID_AT_FINALLY, D_OBJC },
184 { "synchronized", RID_AT_SYNCHRONIZED, D_OBJC },
185 /* These are recognized only in protocol-qualifier context
186 (see above) */
187 { "bycopy", RID_BYCOPY, D_OBJC },
188 { "byref", RID_BYREF, D_OBJC },
189 { "in", RID_IN, D_OBJC },
190 { "inout", RID_INOUT, D_OBJC },
191 { "oneway", RID_ONEWAY, D_OBJC },
192 { "out", RID_OUT, D_OBJC },
194 #define N_reswords (sizeof reswords / sizeof (struct resword))
196 /* Initialization routine for this file. */
198 void
199 c_parse_init (void)
201 /* The only initialization required is of the reserved word
202 identifiers. */
203 unsigned int i;
204 tree id;
205 int mask = (flag_isoc99 ? 0 : D_C89)
206 | (flag_no_asm ? (flag_isoc99 ? D_EXT : D_EXT|D_EXT89) : 0);
208 if (!c_dialect_objc ())
209 mask |= D_OBJC;
211 ridpointers = GGC_CNEWVEC (tree, (int) RID_MAX);
212 for (i = 0; i < N_reswords; i++)
214 /* If a keyword is disabled, do not enter it into the table
215 and so create a canonical spelling that isn't a keyword. */
216 if (reswords[i].disable & mask)
217 continue;
219 id = get_identifier (reswords[i].word);
220 C_RID_CODE (id) = reswords[i].rid;
221 C_IS_RESERVED_WORD (id) = 1;
222 ridpointers [(int) reswords[i].rid] = id;
226 /* The C lexer intermediates between the lexer in cpplib and c-lex.c
227 and the C parser. Unlike the C++ lexer, the parser structure
228 stores the lexer information instead of using a separate structure.
229 Identifiers are separated into ordinary identifiers, type names,
230 keywords and some other Objective-C types of identifiers, and some
231 look-ahead is maintained.
233 ??? It might be a good idea to lex the whole file up front (as for
234 C++). It would then be possible to share more of the C and C++
235 lexer code, if desired. */
237 /* The following local token type is used. */
239 /* A keyword. */
240 #define CPP_KEYWORD ((enum cpp_ttype) (N_TTYPES + 1))
242 /* More information about the type of a CPP_NAME token. */
243 typedef enum c_id_kind {
244 /* An ordinary identifier. */
245 C_ID_ID,
246 /* An identifier declared as a typedef name. */
247 C_ID_TYPENAME,
248 /* An identifier declared as an Objective-C class name. */
249 C_ID_CLASSNAME,
250 /* Not an identifier. */
251 C_ID_NONE
252 } c_id_kind;
254 /* A single C token after string literal concatenation and conversion
255 of preprocessing tokens to tokens. */
256 typedef struct c_token GTY (())
258 /* The kind of token. */
259 ENUM_BITFIELD (cpp_ttype) type : 8;
260 /* If this token is a CPP_NAME, this value indicates whether also
261 declared as some kind of type. Otherwise, it is C_ID_NONE. */
262 ENUM_BITFIELD (c_id_kind) id_kind : 8;
263 /* If this token is a keyword, this value indicates which keyword.
264 Otherwise, this value is RID_MAX. */
265 ENUM_BITFIELD (rid) keyword : 8;
266 /* True if this token is from a system header. */
267 BOOL_BITFIELD in_system_header : 1;
268 /* The value associated with this token, if any. */
269 tree value;
270 /* The location at which this token was found. */
271 location_t location;
272 } c_token;
274 /* A parser structure recording information about the state and
275 context of parsing. Includes lexer information with up to two
276 tokens of look-ahead; more are not needed for C. */
277 typedef struct c_parser GTY(())
279 /* The look-ahead tokens. */
280 c_token tokens[2];
281 /* How many look-ahead tokens are available (0, 1 or 2). */
282 short tokens_avail;
283 /* True if a syntax error is being recovered from; false otherwise.
284 c_parser_error sets this flag. It should clear this flag when
285 enough tokens have been consumed to recover from the error. */
286 BOOL_BITFIELD error : 1;
287 } c_parser;
289 /* Read in and lex a single token, storing it in *TOKEN. */
291 static void
292 c_lex_one_token (c_token *token)
294 timevar_push (TV_LEX);
295 token->type = c_lex_with_flags (&token->value, &token->location, NULL);
296 token->in_system_header = in_system_header;
297 switch (token->type)
299 case CPP_NAME:
300 token->id_kind = C_ID_NONE;
301 token->keyword = RID_MAX;
303 tree decl;
305 int objc_force_identifier = objc_need_raw_identifier;
306 OBJC_NEED_RAW_IDENTIFIER (0);
308 if (C_IS_RESERVED_WORD (token->value))
310 enum rid rid_code = C_RID_CODE (token->value);
312 if (c_dialect_objc ())
314 if (!OBJC_IS_AT_KEYWORD (rid_code)
315 && (!OBJC_IS_PQ_KEYWORD (rid_code) || objc_pq_context))
317 /* Return the canonical spelling for this keyword. */
318 token->value = ridpointers[(int) rid_code];
319 token->type = CPP_KEYWORD;
320 token->keyword = rid_code;
321 break;
324 else
326 /* Return the canonical spelling for this keyword. */
327 token->value = ridpointers[(int) rid_code];
328 token->type = CPP_KEYWORD;
329 token->keyword = rid_code;
330 break;
334 decl = lookup_name (token->value);
335 if (decl)
337 if (TREE_CODE (decl) == TYPE_DECL)
339 token->id_kind = C_ID_TYPENAME;
340 break;
343 else if (c_dialect_objc ())
345 tree objc_interface_decl = objc_is_class_name (token->value);
346 /* Objective-C class names are in the same namespace as
347 variables and typedefs, and hence are shadowed by local
348 declarations. */
349 if (objc_interface_decl
350 && (global_bindings_p ()
351 || (!objc_force_identifier && !decl)))
353 token->value = objc_interface_decl;
354 token->id_kind = C_ID_CLASSNAME;
355 break;
359 token->id_kind = C_ID_ID;
360 break;
361 case CPP_AT_NAME:
362 /* This only happens in Objective-C; it must be a keyword. */
363 token->type = CPP_KEYWORD;
364 token->id_kind = C_ID_NONE;
365 token->keyword = C_RID_CODE (token->value);
366 break;
367 case CPP_COLON:
368 case CPP_COMMA:
369 case CPP_CLOSE_PAREN:
370 case CPP_SEMICOLON:
371 /* These tokens may affect the interpretation of any identifiers
372 following, if doing Objective-C. */
373 OBJC_NEED_RAW_IDENTIFIER (0);
374 token->id_kind = C_ID_NONE;
375 token->keyword = RID_MAX;
376 break;
377 default:
378 token->id_kind = C_ID_NONE;
379 token->keyword = RID_MAX;
380 break;
382 timevar_pop (TV_LEX);
385 /* Return a pointer to the next token from PARSER, reading it in if
386 necessary. */
388 static inline c_token *
389 c_parser_peek_token (c_parser *parser)
391 if (parser->tokens_avail == 0)
393 c_lex_one_token (&parser->tokens[0]);
394 parser->tokens_avail = 1;
396 return &parser->tokens[0];
399 /* Return true if the next token from PARSER has the indicated
400 TYPE. */
402 static inline bool
403 c_parser_next_token_is (c_parser *parser, enum cpp_ttype type)
405 return c_parser_peek_token (parser)->type == type;
408 /* Return true if the next token from PARSER does not have the
409 indicated TYPE. */
411 static inline bool
412 c_parser_next_token_is_not (c_parser *parser, enum cpp_ttype type)
414 return !c_parser_next_token_is (parser, type);
417 /* Return true if the next token from PARSER is the indicated
418 KEYWORD. */
420 static inline bool
421 c_parser_next_token_is_keyword (c_parser *parser, enum rid keyword)
423 c_token *token;
425 /* Peek at the next token. */
426 token = c_parser_peek_token (parser);
427 /* Check to see if it is the indicated keyword. */
428 return token->keyword == keyword;
431 /* Return true if TOKEN can start a type name,
432 false otherwise. */
433 static bool
434 c_token_starts_typename (c_token *token)
436 switch (token->type)
438 case CPP_NAME:
439 switch (token->id_kind)
441 case C_ID_ID:
442 return false;
443 case C_ID_TYPENAME:
444 return true;
445 case C_ID_CLASSNAME:
446 gcc_assert (c_dialect_objc ());
447 return true;
448 default:
449 gcc_unreachable ();
451 case CPP_KEYWORD:
452 switch (token->keyword)
454 case RID_UNSIGNED:
455 case RID_LONG:
456 case RID_SHORT:
457 case RID_SIGNED:
458 case RID_COMPLEX:
459 case RID_INT:
460 case RID_CHAR:
461 case RID_FLOAT:
462 case RID_DOUBLE:
463 case RID_VOID:
464 case RID_BOOL:
465 case RID_ENUM:
466 case RID_STRUCT:
467 case RID_UNION:
468 case RID_TYPEOF:
469 case RID_CONST:
470 case RID_VOLATILE:
471 case RID_RESTRICT:
472 case RID_ATTRIBUTE:
473 return true;
474 default:
475 return false;
477 case CPP_LESS:
478 if (c_dialect_objc ())
479 return true;
480 return false;
481 default:
482 return false;
486 /* Return true if the next token from PARSER can start a type name,
487 false otherwise. */
488 static inline bool
489 c_parser_next_token_starts_typename (c_parser *parser)
491 c_token *token = c_parser_peek_token (parser);
492 return c_token_starts_typename (token);
495 /* Return true if TOKEN can start declaration specifiers, false
496 otherwise. */
497 static bool
498 c_token_starts_declspecs (c_token *token)
500 switch (token->type)
502 case CPP_NAME:
503 switch (token->id_kind)
505 case C_ID_ID:
506 return false;
507 case C_ID_TYPENAME:
508 return true;
509 case C_ID_CLASSNAME:
510 gcc_assert (c_dialect_objc ());
511 return true;
512 default:
513 gcc_unreachable ();
515 case CPP_KEYWORD:
516 switch (token->keyword)
518 case RID_STATIC:
519 case RID_EXTERN:
520 case RID_REGISTER:
521 case RID_TYPEDEF:
522 case RID_INLINE:
523 case RID_AUTO:
524 case RID_THREAD:
525 case RID_UNSIGNED:
526 case RID_LONG:
527 case RID_SHORT:
528 case RID_SIGNED:
529 case RID_COMPLEX:
530 case RID_INT:
531 case RID_CHAR:
532 case RID_FLOAT:
533 case RID_DOUBLE:
534 case RID_VOID:
535 case RID_BOOL:
536 case RID_ENUM:
537 case RID_STRUCT:
538 case RID_UNION:
539 case RID_TYPEOF:
540 case RID_CONST:
541 case RID_VOLATILE:
542 case RID_RESTRICT:
543 case RID_ATTRIBUTE:
544 return true;
545 default:
546 return false;
548 case CPP_LESS:
549 if (c_dialect_objc ())
550 return true;
551 return false;
552 default:
553 return false;
557 /* Return true if the next token from PARSER can start declaration
558 specifiers, false otherwise. */
559 static inline bool
560 c_parser_next_token_starts_declspecs (c_parser *parser)
562 c_token *token = c_parser_peek_token (parser);
563 return c_token_starts_declspecs (token);
566 /* Return a pointer to the next-but-one token from PARSER, reading it
567 in if necessary. The next token is already read in. */
569 static c_token *
570 c_parser_peek_2nd_token (c_parser *parser)
572 if (parser->tokens_avail >= 2)
573 return &parser->tokens[1];
574 gcc_assert (parser->tokens_avail == 1);
575 gcc_assert (parser->tokens[0].type != CPP_EOF);
576 c_lex_one_token (&parser->tokens[1]);
577 parser->tokens_avail = 2;
578 return &parser->tokens[1];
581 /* Consume the next token from PARSER. */
583 static void
584 c_parser_consume_token (c_parser *parser)
586 if (parser->tokens_avail == 2)
587 parser->tokens[0] = parser->tokens[1];
588 else
590 gcc_assert (parser->tokens_avail == 1);
591 gcc_assert (parser->tokens[0].type != CPP_EOF);
593 parser->tokens_avail--;
596 /* Update the globals input_location and in_system_header from
597 TOKEN. */
598 static inline void
599 c_parser_set_source_position_from_token (c_token *token)
601 if (token->type != CPP_EOF)
603 input_location = token->location;
604 in_system_header = token->in_system_header;
608 /* Allocate a new parser. */
610 static c_parser *
611 c_parser_new (void)
613 /* Use local storage to lex the first token because loading a PCH
614 file may cause garbage collection. */
615 c_parser tparser;
616 c_parser *ret;
617 memset (&tparser, 0, sizeof tparser);
618 c_lex_one_token (&tparser.tokens[0]);
619 tparser.tokens_avail = 1;
620 ret = GGC_NEW (c_parser);
621 memcpy (ret, &tparser, sizeof tparser);
622 return ret;
625 /* Issue a diagnostic of the form
626 FILE:LINE: MESSAGE before TOKEN
627 where TOKEN is the next token in the input stream of PARSER.
628 MESSAGE (specified by the caller) is usually of the form "expected
629 OTHER-TOKEN".
631 Do not issue a diagnostic if still recovering from an error.
633 ??? This is taken from the C++ parser, but building up messages in
634 this way is not i18n-friendly and some other approach should be
635 used. */
637 static void
638 c_parser_error (c_parser *parser, const char *gmsgid)
640 c_token *token = c_parser_peek_token (parser);
641 if (parser->error)
642 return;
643 parser->error = true;
644 if (!gmsgid)
645 return;
646 /* This diagnostic makes more sense if it is tagged to the line of
647 the token we just peeked at. */
648 c_parser_set_source_position_from_token (token);
649 c_parse_error (gmsgid,
650 /* Because c_parse_error does not understand
651 CPP_KEYWORD, keywords are treated like
652 identifiers. */
653 (token->type == CPP_KEYWORD ? CPP_NAME : token->type),
654 token->value);
657 /* If the next token is of the indicated TYPE, consume it. Otherwise,
658 issue the error MSGID. If MSGID is NULL then a message has already
659 been produced and no message will be produced this time. Returns
660 true if found, false otherwise. */
662 static bool
663 c_parser_require (c_parser *parser,
664 enum cpp_ttype type,
665 const char *msgid)
667 if (c_parser_next_token_is (parser, type))
669 c_parser_consume_token (parser);
670 return true;
672 else
674 c_parser_error (parser, msgid);
675 return false;
679 /* If the next token is the indicated keyword, consume it. Otherwise,
680 issue the error MSGID. Returns true if found, false otherwise. */
682 static bool
683 c_parser_require_keyword (c_parser *parser,
684 enum rid keyword,
685 const char *msgid)
687 if (c_parser_next_token_is_keyword (parser, keyword))
689 c_parser_consume_token (parser);
690 return true;
692 else
694 c_parser_error (parser, msgid);
695 return false;
699 /* Like c_parser_require, except that tokens will be skipped until the
700 desired token is found. An error message is still produced if the
701 next token is not as expected. If MSGID is NULL then a message has
702 already been produced and no message will be produced this
703 time. */
705 static void
706 c_parser_skip_until_found (c_parser *parser,
707 enum cpp_ttype type,
708 const char *msgid)
710 unsigned nesting_depth = 0;
712 if (c_parser_require (parser, type, msgid))
713 return;
715 /* Skip tokens until the desired token is found. */
716 while (true)
718 /* Peek at the next token. */
719 c_token *token = c_parser_peek_token (parser);
720 /* If we've reached the token we want, consume it and stop. */
721 if (token->type == type && !nesting_depth)
723 c_parser_consume_token (parser);
724 break;
726 /* If we've run out of tokens, stop. */
727 if (token->type == CPP_EOF)
728 return;
729 if (token->type == CPP_OPEN_BRACE
730 || token->type == CPP_OPEN_PAREN
731 || token->type == CPP_OPEN_SQUARE)
732 ++nesting_depth;
733 else if (token->type == CPP_CLOSE_BRACE
734 || token->type == CPP_CLOSE_PAREN
735 || token->type == CPP_CLOSE_SQUARE)
737 if (nesting_depth-- == 0)
738 break;
740 /* Consume this token. */
741 c_parser_consume_token (parser);
743 parser->error = false;
746 /* Skip tokens until the end of a parameter is found, but do not
747 consume the comma, semicolon or closing delimiter. */
749 static void
750 c_parser_skip_to_end_of_parameter (c_parser *parser)
752 unsigned nesting_depth = 0;
754 while (true)
756 c_token *token = c_parser_peek_token (parser);
757 if ((token->type == CPP_COMMA || token->type == CPP_SEMICOLON)
758 && !nesting_depth)
759 break;
760 /* If we've run out of tokens, stop. */
761 if (token->type == CPP_EOF)
762 return;
763 if (token->type == CPP_OPEN_BRACE
764 || token->type == CPP_OPEN_PAREN
765 || token->type == CPP_OPEN_SQUARE)
766 ++nesting_depth;
767 else if (token->type == CPP_CLOSE_BRACE
768 || token->type == CPP_CLOSE_PAREN
769 || token->type == CPP_CLOSE_SQUARE)
771 if (nesting_depth-- == 0)
772 break;
774 /* Consume this token. */
775 c_parser_consume_token (parser);
777 parser->error = false;
780 /* Skip tokens until we have consumed an entire block, or until we
781 have consumed a non-nested ';'. */
783 static void
784 c_parser_skip_to_end_of_block_or_statement (c_parser *parser)
786 unsigned nesting_depth = 0;
788 while (true)
790 c_token *token;
792 /* Peek at the next token. */
793 token = c_parser_peek_token (parser);
794 /* If we've run out of tokens, stop. */
795 if (token->type == CPP_EOF)
796 return;
797 /* If the next token is a ';', we have reached the end of the
798 statement. */
799 if (token->type == CPP_SEMICOLON && !nesting_depth)
801 /* Consume the ';'. */
802 c_parser_consume_token (parser);
803 break;
805 /* If the next token is a non-nested '}', then we have reached
806 the end of the current block. */
807 if (token->type == CPP_CLOSE_BRACE
808 && (nesting_depth == 0 || --nesting_depth == 0))
810 c_parser_consume_token (parser);
811 break;
813 /* If it the next token is a '{', then we are entering a new
814 block. Consume the entire block. */
815 if (token->type == CPP_OPEN_BRACE)
816 ++nesting_depth;
817 c_parser_consume_token (parser);
819 parser->error = false;
823 /* Save the warning flags which are controlled by __extension__. */
825 static inline int
826 disable_extension_diagnostics (void)
828 int ret = (pedantic
829 | (warn_pointer_arith << 1)
830 | (warn_traditional << 2)
831 | (flag_iso << 3));
832 pedantic = 0;
833 warn_pointer_arith = 0;
834 warn_traditional = 0;
835 flag_iso = 0;
836 return ret;
839 /* Restore the warning flags which are controlled by __extension__.
840 FLAGS is the return value from disable_extension_diagnostics. */
842 static inline void
843 restore_extension_diagnostics (int flags)
845 pedantic = flags & 1;
846 warn_pointer_arith = (flags >> 1) & 1;
847 warn_traditional = (flags >> 2) & 1;
848 flag_iso = (flags >> 3) & 1;
851 /* Possibly kinds of declarator to parse. */
852 typedef enum c_dtr_syn {
853 /* A normal declarator with an identifier. */
854 C_DTR_NORMAL,
855 /* An abstract declarator (maybe empty). */
856 C_DTR_ABSTRACT,
857 /* A parameter declarator: may be either, but after a type name does
858 not redeclare a typedef name as an identifier if it can
859 alternatively be interpreted as a typedef name; see DR#009,
860 applied in C90 TC1, omitted from C99 and reapplied in C99 TC2
861 following DR#249. For example, given a typedef T, "int T" and
862 "int *T" are valid parameter declarations redeclaring T, while
863 "int (T)" and "int * (T)" and "int (T[])" and "int (T (int))" are
864 abstract declarators rather than involving redundant parentheses;
865 the same applies with attributes inside the parentheses before
866 "T". */
867 C_DTR_PARM
868 } c_dtr_syn;
870 static void c_parser_external_declaration (c_parser *);
871 static void c_parser_asm_definition (c_parser *);
872 static void c_parser_declaration_or_fndef (c_parser *, bool, bool, bool, bool);
873 static void c_parser_declspecs (c_parser *, struct c_declspecs *, bool, bool,
874 bool);
875 static struct c_typespec c_parser_enum_specifier (c_parser *);
876 static struct c_typespec c_parser_struct_or_union_specifier (c_parser *);
877 static tree c_parser_struct_declaration (c_parser *);
878 static struct c_typespec c_parser_typeof_specifier (c_parser *);
879 static struct c_declarator *c_parser_declarator (c_parser *, bool, c_dtr_syn,
880 bool *);
881 static struct c_declarator *c_parser_direct_declarator (c_parser *, bool,
882 c_dtr_syn, bool *);
883 static struct c_declarator *c_parser_direct_declarator_inner (c_parser *,
884 bool,
885 struct c_declarator *);
886 static struct c_arg_info *c_parser_parms_declarator (c_parser *, bool, tree);
887 static struct c_arg_info *c_parser_parms_list_declarator (c_parser *, tree);
888 static struct c_parm *c_parser_parameter_declaration (c_parser *, tree);
889 static tree c_parser_simple_asm_expr (c_parser *);
890 static tree c_parser_attributes (c_parser *);
891 static struct c_type_name *c_parser_type_name (c_parser *);
892 static struct c_expr c_parser_initializer (c_parser *);
893 static struct c_expr c_parser_braced_init (c_parser *, tree, bool);
894 static void c_parser_initelt (c_parser *);
895 static void c_parser_initval (c_parser *, struct c_expr *);
896 static tree c_parser_compound_statement (c_parser *);
897 static void c_parser_compound_statement_nostart (c_parser *);
898 static void c_parser_label (c_parser *);
899 static void c_parser_statement (c_parser *);
900 static void c_parser_statement_after_labels (c_parser *);
901 static void c_parser_if_statement (c_parser *);
902 static void c_parser_switch_statement (c_parser *);
903 static void c_parser_while_statement (c_parser *);
904 static void c_parser_do_statement (c_parser *);
905 static void c_parser_for_statement (c_parser *);
906 static tree c_parser_asm_statement (c_parser *);
907 static tree c_parser_asm_operands (c_parser *, bool);
908 static tree c_parser_asm_clobbers (c_parser *);
909 static struct c_expr c_parser_expr_no_commas (c_parser *, struct c_expr *);
910 static struct c_expr c_parser_conditional_expression (c_parser *,
911 struct c_expr *);
912 static struct c_expr c_parser_binary_expression (c_parser *, struct c_expr *);
913 static struct c_expr c_parser_cast_expression (c_parser *, struct c_expr *);
914 static struct c_expr c_parser_unary_expression (c_parser *);
915 static struct c_expr c_parser_sizeof_expression (c_parser *);
916 static struct c_expr c_parser_alignof_expression (c_parser *);
917 static struct c_expr c_parser_postfix_expression (c_parser *);
918 static struct c_expr c_parser_postfix_expression_after_paren_type (c_parser *,
919 struct c_type_name *);
920 static struct c_expr c_parser_postfix_expression_after_primary (c_parser *,
921 struct c_expr);
922 static struct c_expr c_parser_expression (c_parser *);
923 static struct c_expr c_parser_expression_conv (c_parser *);
924 static tree c_parser_expr_list (c_parser *, bool);
926 /* These Objective-C parser functions are only ever called when
927 compiling Objective-C. */
928 static void c_parser_objc_class_definition (c_parser *);
929 static void c_parser_objc_class_instance_variables (c_parser *);
930 static void c_parser_objc_class_declaration (c_parser *);
931 static void c_parser_objc_alias_declaration (c_parser *);
932 static void c_parser_objc_protocol_definition (c_parser *);
933 static enum tree_code c_parser_objc_method_type (c_parser *);
934 static void c_parser_objc_method_definition (c_parser *);
935 static void c_parser_objc_methodprotolist (c_parser *);
936 static void c_parser_objc_methodproto (c_parser *);
937 static tree c_parser_objc_method_decl (c_parser *);
938 static tree c_parser_objc_type_name (c_parser *);
939 static tree c_parser_objc_protocol_refs (c_parser *);
940 static void c_parser_objc_try_catch_statement (c_parser *);
941 static void c_parser_objc_synchronized_statement (c_parser *);
942 static tree c_parser_objc_selector (c_parser *);
943 static tree c_parser_objc_selector_arg (c_parser *);
944 static tree c_parser_objc_receiver (c_parser *);
945 static tree c_parser_objc_message_args (c_parser *);
946 static tree c_parser_objc_keywordexpr (c_parser *);
948 /* Parse a translation unit (C90 6.7, C99 6.9).
950 translation-unit:
951 external-declarations
953 external-declarations:
954 external-declaration
955 external-declarations external-declaration
957 GNU extensions:
959 translation-unit:
960 empty
963 static void
964 c_parser_translation_unit (c_parser *parser)
966 if (c_parser_next_token_is (parser, CPP_EOF))
968 if (pedantic)
969 pedwarn ("ISO C forbids an empty source file");
971 else
973 void *obstack_position = obstack_alloc (&parser_obstack, 0);
976 ggc_collect ();
977 c_parser_external_declaration (parser);
978 obstack_free (&parser_obstack, obstack_position);
980 while (c_parser_next_token_is_not (parser, CPP_EOF));
984 /* Parse an external declaration (C90 6.7, C99 6.9).
986 external-declaration:
987 function-definition
988 declaration
990 GNU extensions:
992 external-declaration:
993 asm-definition
995 __extension__ external-declaration
997 Objective-C:
999 external-declaration:
1000 objc-class-definition
1001 objc-class-declaration
1002 objc-alias-declaration
1003 objc-protocol-definition
1004 objc-method-definition
1005 @end
1008 static void
1009 c_parser_external_declaration (c_parser *parser)
1011 int ext;
1012 switch (c_parser_peek_token (parser)->type)
1014 case CPP_KEYWORD:
1015 switch (c_parser_peek_token (parser)->keyword)
1017 case RID_EXTENSION:
1018 ext = disable_extension_diagnostics ();
1019 c_parser_consume_token (parser);
1020 c_parser_external_declaration (parser);
1021 restore_extension_diagnostics (ext);
1022 break;
1023 case RID_ASM:
1024 c_parser_asm_definition (parser);
1025 break;
1026 case RID_AT_INTERFACE:
1027 case RID_AT_IMPLEMENTATION:
1028 gcc_assert (c_dialect_objc ());
1029 c_parser_objc_class_definition (parser);
1030 break;
1031 case RID_AT_CLASS:
1032 gcc_assert (c_dialect_objc ());
1033 c_parser_objc_class_declaration (parser);
1034 break;
1035 case RID_AT_ALIAS:
1036 gcc_assert (c_dialect_objc ());
1037 c_parser_objc_alias_declaration (parser);
1038 break;
1039 case RID_AT_PROTOCOL:
1040 gcc_assert (c_dialect_objc ());
1041 c_parser_objc_protocol_definition (parser);
1042 break;
1043 case RID_AT_END:
1044 gcc_assert (c_dialect_objc ());
1045 c_parser_consume_token (parser);
1046 objc_finish_implementation ();
1047 break;
1048 default:
1049 goto decl_or_fndef;
1051 break;
1052 case CPP_SEMICOLON:
1053 if (pedantic)
1054 pedwarn ("ISO C does not allow extra %<;%> outside of a function");
1055 c_parser_consume_token (parser);
1056 break;
1057 case CPP_PLUS:
1058 case CPP_MINUS:
1059 if (c_dialect_objc ())
1061 c_parser_objc_method_definition (parser);
1062 break;
1064 /* Else fall through, and yield a syntax error trying to parse
1065 as a declaration or function definition. */
1066 default:
1067 decl_or_fndef:
1068 /* A declaration or a function definition. We can only tell
1069 which after parsing the declaration specifiers, if any, and
1070 the first declarator. */
1071 c_parser_declaration_or_fndef (parser, true, true, false, true);
1072 break;
1076 /* Parse a declaration or function definition (C90 6.5, 6.7.1, C99
1077 6.7, 6.9.1). If FNDEF_OK is true, a function definition is
1078 accepted; otherwise (old-style parameter declarations) only other
1079 declarations are accepted. If NESTED is true, we are inside a
1080 function or parsing old-style parameter declarations; any functions
1081 encountered are nested functions and declaration specifiers are
1082 required; otherwise we are at top level and functions are normal
1083 functions and declaration specifiers may be optional. If EMPTY_OK
1084 is true, empty declarations are OK (subject to all other
1085 constraints); otherwise (old-style parameter declarations) they are
1086 diagnosed. If START_ATTR_OK is true, the declaration specifiers
1087 may start with attributes; otherwise they may not.
1089 declaration:
1090 declaration-specifiers init-declarator-list[opt] ;
1092 function-definition:
1093 declaration-specifiers[opt] declarator declaration-list[opt]
1094 compound-statement
1096 declaration-list:
1097 declaration
1098 declaration-list declaration
1100 init-declarator-list:
1101 init-declarator
1102 init-declarator-list , init-declarator
1104 init-declarator:
1105 declarator simple-asm-expr[opt] attributes[opt]
1106 declarator simple-asm-expr[opt] attributes[opt] = initializer
1108 GNU extensions:
1110 nested-function-definition:
1111 declaration-specifiers declarator declaration-list[opt]
1112 compound-statement
1114 The simple-asm-expr and attributes are GNU extensions.
1116 This function does not handle __extension__; that is handled in its
1117 callers. ??? Following the old parser, __extension__ may start
1118 external declarations, declarations in functions and declarations
1119 at the start of "for" loops, but not old-style parameter
1120 declarations.
1122 C99 requires declaration specifiers in a function definition; the
1123 absence is diagnosed through the diagnosis of implicit int. In GNU
1124 C we also allow but diagnose declarations without declaration
1125 specifiers, but only at top level (elsewhere they conflict with
1126 other syntax). */
1128 static void
1129 c_parser_declaration_or_fndef (c_parser *parser, bool fndef_ok, bool empty_ok,
1130 bool nested, bool start_attr_ok)
1132 struct c_declspecs *specs;
1133 tree prefix_attrs;
1134 tree all_prefix_attrs;
1135 bool diagnosed_no_specs = false;
1136 specs = build_null_declspecs ();
1137 c_parser_declspecs (parser, specs, true, true, start_attr_ok);
1138 if (parser->error)
1140 c_parser_skip_to_end_of_block_or_statement (parser);
1141 return;
1143 if (nested && !specs->declspecs_seen_p)
1145 c_parser_error (parser, "expected declaration specifiers");
1146 c_parser_skip_to_end_of_block_or_statement (parser);
1147 return;
1149 finish_declspecs (specs);
1150 if (c_parser_next_token_is (parser, CPP_SEMICOLON))
1152 if (empty_ok)
1153 shadow_tag (specs);
1154 else
1156 shadow_tag_warned (specs, 1);
1157 pedwarn ("empty declaration");
1159 c_parser_consume_token (parser);
1160 return;
1162 pending_xref_error ();
1163 prefix_attrs = specs->attrs;
1164 all_prefix_attrs = prefix_attrs;
1165 specs->attrs = NULL_TREE;
1166 while (true)
1168 struct c_declarator *declarator;
1169 bool dummy = false;
1170 tree fnbody;
1171 /* Declaring either one or more declarators (in which case we
1172 should diagnose if there were no declaration specifiers) or a
1173 function definition (in which case the diagnostic for
1174 implicit int suffices). */
1175 declarator = c_parser_declarator (parser, specs->type_seen_p,
1176 C_DTR_NORMAL, &dummy);
1177 if (declarator == NULL)
1179 c_parser_skip_to_end_of_block_or_statement (parser);
1180 return;
1182 if (c_parser_next_token_is (parser, CPP_EQ)
1183 || c_parser_next_token_is (parser, CPP_COMMA)
1184 || c_parser_next_token_is (parser, CPP_SEMICOLON)
1185 || c_parser_next_token_is_keyword (parser, RID_ASM)
1186 || c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
1188 tree asm_name = NULL_TREE;
1189 tree postfix_attrs = NULL_TREE;
1190 if (!diagnosed_no_specs && !specs->declspecs_seen_p)
1192 diagnosed_no_specs = true;
1193 pedwarn ("data definition has no type or storage class");
1195 /* Having seen a data definition, there cannot now be a
1196 function definition. */
1197 fndef_ok = false;
1198 if (c_parser_next_token_is_keyword (parser, RID_ASM))
1199 asm_name = c_parser_simple_asm_expr (parser);
1200 if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
1201 postfix_attrs = c_parser_attributes (parser);
1202 if (c_parser_next_token_is (parser, CPP_EQ))
1204 tree d;
1205 struct c_expr init;
1206 c_parser_consume_token (parser);
1207 /* The declaration of the variable is in effect while
1208 its initializer is parsed. */
1209 d = start_decl (declarator, specs, true,
1210 chainon (postfix_attrs, all_prefix_attrs));
1211 if (!d)
1212 d = error_mark_node;
1213 start_init (d, asm_name, global_bindings_p ());
1214 init = c_parser_initializer (parser);
1215 finish_init ();
1216 if (d != error_mark_node)
1218 maybe_warn_string_init (TREE_TYPE (d), init);
1219 finish_decl (d, init.value, asm_name);
1222 else
1224 tree d = start_decl (declarator, specs, false,
1225 chainon (postfix_attrs,
1226 all_prefix_attrs));
1227 if (d)
1228 finish_decl (d, NULL_TREE, asm_name);
1230 if (c_parser_next_token_is (parser, CPP_COMMA))
1232 c_parser_consume_token (parser);
1233 if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
1234 all_prefix_attrs = chainon (c_parser_attributes (parser),
1235 prefix_attrs);
1236 else
1237 all_prefix_attrs = prefix_attrs;
1238 continue;
1240 else if (c_parser_next_token_is (parser, CPP_SEMICOLON))
1242 c_parser_consume_token (parser);
1243 return;
1245 else
1247 c_parser_error (parser, "expected %<,%> or %<;%>");
1248 c_parser_skip_to_end_of_block_or_statement (parser);
1249 return;
1252 else if (!fndef_ok)
1254 c_parser_error (parser, "expected %<=%>, %<,%>, %<;%>, "
1255 "%<asm%> or %<__attribute__%>");
1256 c_parser_skip_to_end_of_block_or_statement (parser);
1257 return;
1259 /* Function definition (nested or otherwise). */
1260 if (nested)
1262 if (pedantic)
1263 pedwarn ("ISO C forbids nested functions");
1264 push_function_context ();
1266 if (!start_function (specs, declarator, all_prefix_attrs))
1268 /* This can appear in many cases looking nothing like a
1269 function definition, so we don't give a more specific
1270 error suggesting there was one. */
1271 c_parser_error (parser, "expected %<=%>, %<,%>, %<;%>, %<asm%> "
1272 "or %<__attribute__%>");
1273 if (nested)
1274 pop_function_context ();
1275 break;
1277 /* Parse old-style parameter declarations. ??? Attributes are
1278 not allowed to start declaration specifiers here because of a
1279 syntax conflict between a function declaration with attribute
1280 suffix and a function definition with an attribute prefix on
1281 first old-style parameter declaration. Following the old
1282 parser, they are not accepted on subsequent old-style
1283 parameter declarations either. However, there is no
1284 ambiguity after the first declaration, nor indeed on the
1285 first as long as we don't allow postfix attributes after a
1286 declarator with a nonempty identifier list in a definition;
1287 and postfix attributes have never been accepted here in
1288 function definitions either. */
1289 while (c_parser_next_token_is_not (parser, CPP_EOF)
1290 && c_parser_next_token_is_not (parser, CPP_OPEN_BRACE))
1291 c_parser_declaration_or_fndef (parser, false, false, true, false);
1292 DECL_SOURCE_LOCATION (current_function_decl)
1293 = c_parser_peek_token (parser)->location;
1294 store_parm_decls ();
1295 fnbody = c_parser_compound_statement (parser);
1296 if (nested)
1298 tree decl = current_function_decl;
1299 add_stmt (fnbody);
1300 finish_function ();
1301 pop_function_context ();
1302 add_stmt (build_stmt (DECL_EXPR, decl));
1304 else
1306 add_stmt (fnbody);
1307 finish_function ();
1309 break;
1313 /* Parse an asm-definition (asm() outside a function body). This is a
1314 GNU extension.
1316 asm-definition:
1317 simple-asm-expr ;
1320 static void
1321 c_parser_asm_definition (c_parser *parser)
1323 tree asm_str = c_parser_simple_asm_expr (parser);
1324 /* ??? This only works sensibly in the presence of
1325 -fno-unit-at-a-time; file-scope asms really need to be passed to
1326 cgraph which needs to preserve the order of functions and
1327 file-scope asms. */
1328 if (asm_str)
1329 assemble_asm (asm_str);
1330 c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
1333 /* Parse some declaration specifiers (possibly none) (C90 6.5, C99
1334 6.7), adding them to SPECS (which may already include some).
1335 Storage class specifiers are accepted iff SCSPEC_OK; type
1336 specifiers are accepted iff TYPESPEC_OK; attributes are accepted at
1337 the start iff START_ATTR_OK.
1339 declaration-specifiers:
1340 storage-class-specifier declaration-specifiers[opt]
1341 type-specifier declaration-specifiers[opt]
1342 type-qualifier declaration-specifiers[opt]
1343 function-specifier declaration-specifiers[opt]
1345 Function specifiers (inline) are from C99, and are currently
1346 handled as storage class specifiers, as is __thread.
1348 C90 6.5.1, C99 6.7.1:
1349 storage-class-specifier:
1350 typedef
1351 extern
1352 static
1353 auto
1354 register
1356 C99 6.7.4:
1357 function-specifier:
1358 inline
1360 C90 6.5.2, C99 6.7.2:
1361 type-specifier:
1362 void
1363 char
1364 short
1366 long
1367 float
1368 double
1369 signed
1370 unsigned
1371 _Bool
1372 _Complex
1373 [_Imaginary removed in C99 TC2]
1374 struct-or-union-specifier
1375 enum-specifier
1376 typedef-name
1378 (_Bool and _Complex are new in C99.)
1380 C90 6.5.3, C99 6.7.3:
1382 type-qualifier:
1383 const
1384 restrict
1385 volatile
1387 (restrict is new in C99.)
1389 GNU extensions:
1391 declaration-specifiers:
1392 attributes declaration-specifiers[opt]
1394 storage-class-specifier:
1395 __thread
1397 type-specifier:
1398 typeof-specifier
1400 Objective-C:
1402 type-specifier:
1403 class-name objc-protocol-refs[opt]
1404 typedef-name objc-protocol-refs
1405 objc-protocol-refs
1408 static void
1409 c_parser_declspecs (c_parser *parser, struct c_declspecs *specs,
1410 bool scspec_ok, bool typespec_ok, bool start_attr_ok)
1412 bool attrs_ok = start_attr_ok;
1413 bool seen_type = specs->type_seen_p;
1414 while (c_parser_next_token_is (parser, CPP_NAME)
1415 || c_parser_next_token_is (parser, CPP_KEYWORD)
1416 || (c_dialect_objc () && c_parser_next_token_is (parser, CPP_LESS)))
1418 struct c_typespec t;
1419 tree attrs;
1420 if (c_parser_next_token_is (parser, CPP_NAME))
1422 tree value = c_parser_peek_token (parser)->value;
1423 c_id_kind kind = c_parser_peek_token (parser)->id_kind;
1424 /* This finishes the specifiers unless a type name is OK, it
1425 is declared as a type name and a type name hasn't yet
1426 been seen. */
1427 if (!typespec_ok || seen_type
1428 || (kind != C_ID_TYPENAME && kind != C_ID_CLASSNAME))
1429 break;
1430 c_parser_consume_token (parser);
1431 seen_type = true;
1432 attrs_ok = true;
1433 if (kind == C_ID_TYPENAME
1434 && (!c_dialect_objc ()
1435 || c_parser_next_token_is_not (parser, CPP_LESS)))
1437 t.kind = ctsk_typedef;
1438 /* For a typedef name, record the meaning, not the name.
1439 In case of 'foo foo, bar;'. */
1440 t.spec = lookup_name (value);
1442 else
1444 tree proto = NULL_TREE;
1445 gcc_assert (c_dialect_objc ());
1446 t.kind = ctsk_objc;
1447 if (c_parser_next_token_is (parser, CPP_LESS))
1448 proto = c_parser_objc_protocol_refs (parser);
1449 t.spec = objc_get_protocol_qualified_type (value, proto);
1451 declspecs_add_type (specs, t);
1452 continue;
1454 if (c_parser_next_token_is (parser, CPP_LESS))
1456 /* Make "<SomeProtocol>" equivalent to "id <SomeProtocol>" -
1457 nisse@lysator.liu.se. */
1458 tree proto;
1459 gcc_assert (c_dialect_objc ());
1460 if (!typespec_ok || seen_type)
1461 break;
1462 proto = c_parser_objc_protocol_refs (parser);
1463 t.kind = ctsk_objc;
1464 t.spec = objc_get_protocol_qualified_type (NULL_TREE, proto);
1465 declspecs_add_type (specs, t);
1466 continue;
1468 gcc_assert (c_parser_next_token_is (parser, CPP_KEYWORD));
1469 switch (c_parser_peek_token (parser)->keyword)
1471 case RID_STATIC:
1472 case RID_EXTERN:
1473 case RID_REGISTER:
1474 case RID_TYPEDEF:
1475 case RID_INLINE:
1476 case RID_AUTO:
1477 case RID_THREAD:
1478 if (!scspec_ok)
1479 goto out;
1480 attrs_ok = true;
1481 /* TODO: Distinguish between function specifiers (inline)
1482 and storage class specifiers, either here or in
1483 declspecs_add_scspec. */
1484 declspecs_add_scspec (specs, c_parser_peek_token (parser)->value);
1485 c_parser_consume_token (parser);
1486 break;
1487 case RID_UNSIGNED:
1488 case RID_LONG:
1489 case RID_SHORT:
1490 case RID_SIGNED:
1491 case RID_COMPLEX:
1492 case RID_INT:
1493 case RID_CHAR:
1494 case RID_FLOAT:
1495 case RID_DOUBLE:
1496 case RID_VOID:
1497 case RID_BOOL:
1498 if (!typespec_ok)
1499 goto out;
1500 attrs_ok = true;
1501 seen_type = true;
1502 OBJC_NEED_RAW_IDENTIFIER (1);
1503 t.kind = ctsk_resword;
1504 t.spec = c_parser_peek_token (parser)->value;
1505 declspecs_add_type (specs, t);
1506 c_parser_consume_token (parser);
1507 break;
1508 case RID_ENUM:
1509 if (!typespec_ok)
1510 goto out;
1511 attrs_ok = true;
1512 seen_type = true;
1513 t = c_parser_enum_specifier (parser);
1514 declspecs_add_type (specs, t);
1515 break;
1516 case RID_STRUCT:
1517 case RID_UNION:
1518 if (!typespec_ok)
1519 goto out;
1520 attrs_ok = true;
1521 seen_type = true;
1522 t = c_parser_struct_or_union_specifier (parser);
1523 declspecs_add_type (specs, t);
1524 break;
1525 case RID_TYPEOF:
1526 /* ??? The old parser rejected typeof after other type
1527 specifiers, but is a syntax error the best way of
1528 handling this? */
1529 if (!typespec_ok || seen_type)
1530 goto out;
1531 attrs_ok = true;
1532 seen_type = true;
1533 t = c_parser_typeof_specifier (parser);
1534 declspecs_add_type (specs, t);
1535 break;
1536 case RID_CONST:
1537 case RID_VOLATILE:
1538 case RID_RESTRICT:
1539 attrs_ok = true;
1540 declspecs_add_qual (specs, c_parser_peek_token (parser)->value);
1541 c_parser_consume_token (parser);
1542 break;
1543 case RID_ATTRIBUTE:
1544 if (!attrs_ok)
1545 goto out;
1546 attrs = c_parser_attributes (parser);
1547 declspecs_add_attrs (specs, attrs);
1548 break;
1549 default:
1550 goto out;
1553 out: ;
1556 /* Parse an enum specifier (C90 6.5.2.2, C99 6.7.2.2).
1558 enum-specifier:
1559 enum attributes[opt] identifier[opt] { enumerator-list } attributes[opt]
1560 enum attributes[opt] identifier[opt] { enumerator-list , } attributes[opt]
1561 enum attributes[opt] identifier
1563 The form with trailing comma is new in C99. The forms with
1564 attributes are GNU extensions. In GNU C, we accept any expression
1565 without commas in the syntax (assignment expressions, not just
1566 conditional expressions); assignment expressions will be diagnosed
1567 as non-constant.
1569 enumerator-list:
1570 enumerator
1571 enumerator-list , enumerator
1573 enumerator:
1574 enumeration-constant
1575 enumeration-constant = constant-expression
1578 static struct c_typespec
1579 c_parser_enum_specifier (c_parser *parser)
1581 struct c_typespec ret;
1582 tree attrs;
1583 tree ident = NULL_TREE;
1584 gcc_assert (c_parser_next_token_is_keyword (parser, RID_ENUM));
1585 c_parser_consume_token (parser);
1586 attrs = c_parser_attributes (parser);
1587 if (c_parser_next_token_is (parser, CPP_NAME))
1589 ident = c_parser_peek_token (parser)->value;
1590 c_parser_consume_token (parser);
1592 if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
1594 /* Parse an enum definition. */
1595 tree type = start_enum (ident);
1596 tree postfix_attrs;
1597 /* We chain the enumerators in reverse order, then put them in
1598 forward order at the end. */
1599 tree values = NULL_TREE;
1600 c_parser_consume_token (parser);
1601 while (true)
1603 tree enum_id;
1604 tree enum_value;
1605 tree enum_decl;
1606 bool seen_comma;
1607 if (c_parser_next_token_is_not (parser, CPP_NAME))
1609 c_parser_error (parser, "expected identifier");
1610 c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL);
1611 values = error_mark_node;
1612 break;
1614 enum_id = c_parser_peek_token (parser)->value;
1615 c_parser_consume_token (parser);
1616 if (c_parser_next_token_is (parser, CPP_EQ))
1618 c_parser_consume_token (parser);
1619 enum_value = c_parser_expr_no_commas (parser, NULL).value;
1621 else
1622 enum_value = NULL_TREE;
1623 enum_decl = build_enumerator (enum_id, enum_value);
1624 TREE_CHAIN (enum_decl) = values;
1625 values = enum_decl;
1626 seen_comma = false;
1627 if (c_parser_next_token_is (parser, CPP_COMMA))
1629 seen_comma = true;
1630 c_parser_consume_token (parser);
1632 if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
1634 if (seen_comma && pedantic && !flag_isoc99)
1635 pedwarn ("comma at end of enumerator list");
1636 c_parser_consume_token (parser);
1637 break;
1639 if (!seen_comma)
1641 c_parser_error (parser, "expected %<,%> or %<}%>");
1642 c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL);
1643 values = error_mark_node;
1644 break;
1647 postfix_attrs = c_parser_attributes (parser);
1648 ret.spec = finish_enum (type, nreverse (values),
1649 chainon (attrs, postfix_attrs));
1650 ret.kind = ctsk_tagdef;
1651 return ret;
1653 else if (!ident)
1655 c_parser_error (parser, "expected %<{%>");
1656 ret.spec = error_mark_node;
1657 ret.kind = ctsk_tagref;
1658 return ret;
1660 ret = parser_xref_tag (ENUMERAL_TYPE, ident);
1661 /* In ISO C, enumerated types can be referred to only if already
1662 defined. */
1663 if (pedantic && !COMPLETE_TYPE_P (ret.spec))
1664 pedwarn ("ISO C forbids forward references to %<enum%> types");
1665 return ret;
1668 /* Parse a struct or union specifier (C90 6.5.2.1, C99 6.7.2.1).
1670 struct-or-union-specifier:
1671 struct-or-union attributes[opt] identifier[opt]
1672 { struct-contents } attributes[opt]
1673 struct-or-union attributes[opt] identifier
1675 struct-contents:
1676 struct-declaration-list
1678 struct-declaration-list:
1679 struct-declaration ;
1680 struct-declaration-list struct-declaration ;
1682 GNU extensions:
1684 struct-contents:
1685 empty
1686 struct-declaration
1687 struct-declaration-list struct-declaration
1689 struct-declaration-list:
1690 struct-declaration-list ;
1693 (Note that in the syntax here, unlike that in ISO C, the semicolons
1694 are included here rather than in struct-declaration, in order to
1695 describe the syntax with extra semicolons and missing semicolon at
1696 end.)
1698 Objective-C:
1700 struct-declaration-list:
1701 @defs ( class-name )
1703 (Note this does not include a trailing semicolon, but can be
1704 followed by further declarations, and gets a pedwarn-if-pedantic
1705 when followed by a semicolon.) */
1707 static struct c_typespec
1708 c_parser_struct_or_union_specifier (c_parser *parser)
1710 struct c_typespec ret;
1711 tree attrs;
1712 tree ident = NULL_TREE;
1713 enum tree_code code;
1714 switch (c_parser_peek_token (parser)->keyword)
1716 case RID_STRUCT:
1717 code = RECORD_TYPE;
1718 break;
1719 case RID_UNION:
1720 code = UNION_TYPE;
1721 break;
1722 default:
1723 gcc_unreachable ();
1725 c_parser_consume_token (parser);
1726 attrs = c_parser_attributes (parser);
1727 if (c_parser_next_token_is (parser, CPP_NAME))
1729 ident = c_parser_peek_token (parser)->value;
1730 c_parser_consume_token (parser);
1732 if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
1734 /* Parse a struct or union definition. Start the scope of the
1735 tag before parsing components. */
1736 tree type = start_struct (code, ident);
1737 tree postfix_attrs;
1738 /* We chain the components in reverse order, then put them in
1739 forward order at the end. Each struct-declaration may
1740 declare multiple components (comma-separated), so we must use
1741 chainon to join them, although when parsing each
1742 struct-declaration we can use TREE_CHAIN directly.
1744 The theory behind all this is that there will be more
1745 semicolon separated fields than comma separated fields, and
1746 so we'll be minimizing the number of node traversals required
1747 by chainon. */
1748 tree contents = NULL_TREE;
1749 c_parser_consume_token (parser);
1750 /* Handle the Objective-C @defs construct,
1751 e.g. foo(sizeof(struct{ @defs(ClassName) }));. */
1752 if (c_parser_next_token_is_keyword (parser, RID_AT_DEFS))
1754 tree name;
1755 gcc_assert (c_dialect_objc ());
1756 c_parser_consume_token (parser);
1757 if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
1758 goto end_at_defs;
1759 if (c_parser_next_token_is (parser, CPP_NAME)
1760 && c_parser_peek_token (parser)->id_kind == C_ID_CLASSNAME)
1762 name = c_parser_peek_token (parser)->value;
1763 c_parser_consume_token (parser);
1765 else
1767 c_parser_error (parser, "expected class name");
1768 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
1769 goto end_at_defs;
1771 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
1772 "expected %<)%>");
1773 contents = nreverse (objc_get_class_ivars (name));
1775 end_at_defs:
1776 /* Parse the struct-declarations and semicolons. Problems with
1777 semicolons are diagnosed here; empty structures are diagnosed
1778 elsewhere. */
1779 while (true)
1781 tree decls;
1782 /* Parse any stray semicolon. */
1783 if (c_parser_next_token_is (parser, CPP_SEMICOLON))
1785 if (pedantic)
1786 pedwarn ("extra semicolon in struct or union specified");
1787 c_parser_consume_token (parser);
1788 continue;
1790 /* Stop if at the end of the struct or union contents. */
1791 if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
1793 c_parser_consume_token (parser);
1794 break;
1796 /* Parse some comma-separated declarations, but not the
1797 trailing semicolon if any. */
1798 decls = c_parser_struct_declaration (parser);
1799 contents = chainon (decls, contents);
1800 /* If no semicolon follows, either we have a parse error or
1801 are at the end of the struct or union and should
1802 pedwarn. */
1803 if (c_parser_next_token_is (parser, CPP_SEMICOLON))
1804 c_parser_consume_token (parser);
1805 else
1807 if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
1808 pedwarn ("no semicolon at end of struct or union");
1809 else
1811 c_parser_error (parser, "expected %<;%>");
1812 c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL);
1813 break;
1817 postfix_attrs = c_parser_attributes (parser);
1818 ret.spec = finish_struct (type, nreverse (contents),
1819 chainon (attrs, postfix_attrs));
1820 ret.kind = ctsk_tagdef;
1821 return ret;
1823 else if (!ident)
1825 c_parser_error (parser, "expected %<{%>");
1826 ret.spec = error_mark_node;
1827 ret.kind = ctsk_tagref;
1828 return ret;
1830 ret = parser_xref_tag (code, ident);
1831 return ret;
1834 /* Parse a struct-declaration (C90 6.5.2.1, C99 6.7.2.1), *without*
1835 the trailing semicolon.
1837 struct-declaration:
1838 specifier-qualifier-list struct-declarator-list
1840 specifier-qualifier-list:
1841 type-specifier specifier-qualifier-list[opt]
1842 type-qualifier specifier-qualifier-list[opt]
1843 attributes specifier-qualifier-list[opt]
1845 struct-declarator-list:
1846 struct-declarator
1847 struct-declarator-list , attributes[opt] struct-declarator
1849 struct-declarator:
1850 declarator attributes[opt]
1851 declarator[opt] : constant-expression attributes[opt]
1853 GNU extensions:
1855 struct-declaration:
1856 __extension__ struct-declaration
1857 specifier-qualifier-list
1859 Unlike the ISO C syntax, semicolons are handled elsewhere. The use
1860 of attributes where shown is a GNU extension. In GNU C, we accept
1861 any expression without commas in the syntax (assignment
1862 expressions, not just conditional expressions); assignment
1863 expressions will be diagnosed as non-constant. */
1865 static tree
1866 c_parser_struct_declaration (c_parser *parser)
1868 struct c_declspecs *specs;
1869 tree prefix_attrs;
1870 tree all_prefix_attrs;
1871 tree decls;
1872 if (c_parser_next_token_is_keyword (parser, RID_EXTENSION))
1874 int ext;
1875 tree decl;
1876 ext = disable_extension_diagnostics ();
1877 c_parser_consume_token (parser);
1878 decl = c_parser_struct_declaration (parser);
1879 restore_extension_diagnostics (ext);
1880 return decl;
1882 specs = build_null_declspecs ();
1883 c_parser_declspecs (parser, specs, false, true, true);
1884 if (parser->error)
1885 return NULL_TREE;
1886 if (!specs->declspecs_seen_p)
1888 c_parser_error (parser, "expected specifier-qualifier-list");
1889 return NULL_TREE;
1891 finish_declspecs (specs);
1892 if (c_parser_next_token_is (parser, CPP_SEMICOLON))
1894 tree ret;
1895 if (!specs->type_seen_p)
1897 if (pedantic)
1898 pedwarn ("ISO C forbids member declarations with no members");
1899 shadow_tag_warned (specs, pedantic);
1900 ret = NULL_TREE;
1902 else
1904 /* Support for unnamed structs or unions as members of
1905 structs or unions (which is [a] useful and [b] supports
1906 MS P-SDK). */
1907 ret = grokfield (build_id_declarator (NULL_TREE), specs, NULL_TREE);
1909 return ret;
1911 pending_xref_error ();
1912 prefix_attrs = specs->attrs;
1913 all_prefix_attrs = prefix_attrs;
1914 specs->attrs = NULL_TREE;
1915 decls = NULL_TREE;
1916 while (true)
1918 /* Declaring one or more declarators or un-named bit-fields. */
1919 struct c_declarator *declarator;
1920 bool dummy = false;
1921 if (c_parser_next_token_is (parser, CPP_COLON))
1922 declarator = build_id_declarator (NULL_TREE);
1923 else
1924 declarator = c_parser_declarator (parser, specs->type_seen_p,
1925 C_DTR_NORMAL, &dummy);
1926 if (declarator == NULL)
1928 c_parser_skip_to_end_of_block_or_statement (parser);
1929 break;
1931 if (c_parser_next_token_is (parser, CPP_COLON)
1932 || c_parser_next_token_is (parser, CPP_COMMA)
1933 || c_parser_next_token_is (parser, CPP_SEMICOLON)
1934 || c_parser_next_token_is (parser, CPP_CLOSE_BRACE)
1935 || c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
1937 tree postfix_attrs = NULL_TREE;
1938 tree width = NULL_TREE;
1939 tree d;
1940 if (c_parser_next_token_is (parser, CPP_COLON))
1942 c_parser_consume_token (parser);
1943 width = c_parser_expr_no_commas (parser, NULL).value;
1945 if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
1946 postfix_attrs = c_parser_attributes (parser);
1947 d = grokfield (declarator, specs, width);
1948 decl_attributes (&d, chainon (postfix_attrs,
1949 all_prefix_attrs), 0);
1950 TREE_CHAIN (d) = decls;
1951 decls = d;
1952 if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
1953 all_prefix_attrs = chainon (c_parser_attributes (parser),
1954 prefix_attrs);
1955 else
1956 all_prefix_attrs = prefix_attrs;
1957 if (c_parser_next_token_is (parser, CPP_COMMA))
1958 c_parser_consume_token (parser);
1959 else if (c_parser_next_token_is (parser, CPP_SEMICOLON)
1960 || c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
1962 /* Semicolon consumed in caller. */
1963 break;
1965 else
1967 c_parser_error (parser, "expected %<,%>, %<;%> or %<}%>");
1968 break;
1971 else
1973 c_parser_error (parser,
1974 "expected %<:%>, %<,%>, %<;%>, %<}%> or "
1975 "%<__attribute__%>");
1976 break;
1979 return decls;
1982 /* Parse a typeof specifier (a GNU extension).
1984 typeof-specifier:
1985 typeof ( expression )
1986 typeof ( type-name )
1989 static struct c_typespec
1990 c_parser_typeof_specifier (c_parser *parser)
1992 struct c_typespec ret;
1993 ret.kind = ctsk_typeof;
1994 ret.spec = error_mark_node;
1995 gcc_assert (c_parser_next_token_is_keyword (parser, RID_TYPEOF));
1996 c_parser_consume_token (parser);
1997 skip_evaluation++;
1998 in_typeof++;
1999 if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
2001 skip_evaluation--;
2002 in_typeof--;
2003 return ret;
2005 if (c_parser_next_token_starts_typename (parser))
2007 struct c_type_name *type = c_parser_type_name (parser);
2008 skip_evaluation--;
2009 in_typeof--;
2010 if (type != NULL)
2012 ret.spec = groktypename (type);
2013 pop_maybe_used (variably_modified_type_p (ret.spec, NULL_TREE));
2016 else
2018 struct c_expr expr = c_parser_expression (parser);
2019 skip_evaluation--;
2020 in_typeof--;
2021 if (TREE_CODE (expr.value) == COMPONENT_REF
2022 && DECL_C_BIT_FIELD (TREE_OPERAND (expr.value, 1)))
2023 error ("%<typeof%> applied to a bit-field");
2024 ret.spec = TREE_TYPE (expr.value);
2025 pop_maybe_used (variably_modified_type_p (ret.spec, NULL_TREE));
2027 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
2028 return ret;
2031 /* Parse a declarator, possibly an abstract declarator (C90 6.5.4,
2032 6.5.5, C99 6.7.5, 6.7.6). If TYPE_SEEN_P then a typedef name may
2033 be redeclared; otherwise it may not. KIND indicates which kind of
2034 declarator is wanted. Returns a valid declarator except in the
2035 case of a syntax error in which case NULL is returned. *SEEN_ID is
2036 set to true if an identifier being declared is seen; this is used
2037 to diagnose bad forms of abstract array declarators and to
2038 determine whether an identifier list is syntactically permitted.
2040 declarator:
2041 pointer[opt] direct-declarator
2043 direct-declarator:
2044 identifier
2045 ( attributes[opt] declarator )
2046 direct-declarator array-declarator
2047 direct-declarator ( parameter-type-list )
2048 direct-declarator ( identifier-list[opt] )
2050 pointer:
2051 * type-qualifier-list[opt]
2052 * type-qualifier-list[opt] pointer
2054 type-qualifier-list:
2055 type-qualifier
2056 attributes
2057 type-qualifier-list type-qualifier
2058 type-qualifier-list attributes
2060 parameter-type-list:
2061 parameter-list
2062 parameter-list , ...
2064 parameter-list:
2065 parameter-declaration
2066 parameter-list , parameter-declaration
2068 parameter-declaration:
2069 declaration-specifiers declarator attributes[opt]
2070 declaration-specifiers abstract-declarator[opt] attributes[opt]
2072 identifier-list:
2073 identifier
2074 identifier-list , identifier
2076 abstract-declarator:
2077 pointer
2078 pointer[opt] direct-abstract-declarator
2080 direct-abstract-declarator:
2081 ( attributes[opt] abstract-declarator )
2082 direct-abstract-declarator[opt] array-declarator
2083 direct-abstract-declarator[opt] ( parameter-type-list[opt] )
2085 GNU extensions:
2087 direct-declarator:
2088 direct-declarator ( parameter-forward-declarations
2089 parameter-type-list[opt] )
2091 direct-abstract-declarator:
2092 direct-abstract-declarator[opt] ( parameter-forward-declarations
2093 parameter-type-list[opt] )
2095 parameter-forward-declarations:
2096 parameter-list ;
2097 parameter-forward-declarations parameter-list ;
2099 The uses of attributes shown above are GNU extensions.
2101 Some forms of array declarator are not included in C99 in the
2102 syntax for abstract declarators; these are disallowed elsewhere.
2103 This may be a defect (DR#289).
2105 This function also accepts an omitted abstract declarator as being
2106 an abstract declarator, although not part of the formal syntax. */
2108 static struct c_declarator *
2109 c_parser_declarator (c_parser *parser, bool type_seen_p, c_dtr_syn kind,
2110 bool *seen_id)
2112 /* Parse any initial pointer part. */
2113 if (c_parser_next_token_is (parser, CPP_MULT))
2115 struct c_declspecs *quals_attrs = build_null_declspecs ();
2116 struct c_declarator *inner;
2117 c_parser_consume_token (parser);
2118 c_parser_declspecs (parser, quals_attrs, false, false, true);
2119 inner = c_parser_declarator (parser, type_seen_p, kind, seen_id);
2120 if (inner == NULL)
2121 return NULL;
2122 else
2123 return make_pointer_declarator (quals_attrs, inner);
2125 /* Now we have a direct declarator, direct abstract declarator or
2126 nothing (which counts as a direct abstract declarator here). */
2127 return c_parser_direct_declarator (parser, type_seen_p, kind, seen_id);
2130 /* Parse a direct declarator or direct abstract declarator; arguments
2131 as c_parser_declarator. */
2133 static struct c_declarator *
2134 c_parser_direct_declarator (c_parser *parser, bool type_seen_p, c_dtr_syn kind,
2135 bool *seen_id)
2137 /* The direct declarator must start with an identifier (possibly
2138 omitted) or a parenthesized declarator (possibly abstract). In
2139 an ordinary declarator, initial parentheses must start a
2140 parenthesized declarator. In an abstract declarator or parameter
2141 declarator, they could start a parenthesized declarator or a
2142 parameter list. To tell which, the open parenthesis and any
2143 following attributes must be read. If a declaration specifier
2144 follows, then it is a parameter list; if the specifier is a
2145 typedef name, there might be an ambiguity about redeclaring it,
2146 which is resolved in the direction of treating it as a typedef
2147 name. If a close parenthesis follows, it is also an empty
2148 parameter list, as the syntax does not permit empty abstract
2149 declarators. Otherwise, it is a parenthesized declarator (in
2150 which case the analysis may be repeated inside it, recursively).
2152 ??? There is an ambiguity in a parameter declaration "int
2153 (__attribute__((foo)) x)", where x is not a typedef name: it
2154 could be an abstract declarator for a function, or declare x with
2155 parentheses. The proper resolution of this ambiguity needs
2156 documenting. At present we follow an accident of the old
2157 parser's implementation, whereby the first parameter must have
2158 some declaration specifiers other than just attributes. Thus as
2159 a parameter declaration it is treated as a parenthesized
2160 parameter named x, and as an abstract declarator it is
2161 rejected.
2163 ??? Also following the old parser, attributes inside an empty
2164 parameter list are ignored, making it a list not yielding a
2165 prototype, rather than giving an error or making it have one
2166 parameter with implicit type int.
2168 ??? Also following the old parser, typedef names may be
2169 redeclared in declarators, but not Objective-C class names. */
2171 if (kind != C_DTR_ABSTRACT
2172 && c_parser_next_token_is (parser, CPP_NAME)
2173 && ((type_seen_p
2174 && c_parser_peek_token (parser)->id_kind == C_ID_TYPENAME)
2175 || c_parser_peek_token (parser)->id_kind == C_ID_ID))
2177 struct c_declarator *inner
2178 = build_id_declarator (c_parser_peek_token (parser)->value);
2179 *seen_id = true;
2180 inner->id_loc = c_parser_peek_token (parser)->location;
2181 c_parser_consume_token (parser);
2182 return c_parser_direct_declarator_inner (parser, *seen_id, inner);
2185 if (kind != C_DTR_NORMAL
2186 && c_parser_next_token_is (parser, CPP_OPEN_SQUARE))
2188 struct c_declarator *inner = build_id_declarator (NULL_TREE);
2189 return c_parser_direct_declarator_inner (parser, *seen_id, inner);
2192 /* Either we are at the end of an abstract declarator, or we have
2193 parentheses. */
2195 if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
2197 tree attrs;
2198 struct c_declarator *inner;
2199 c_parser_consume_token (parser);
2200 attrs = c_parser_attributes (parser);
2201 if (kind != C_DTR_NORMAL
2202 && (c_parser_next_token_starts_declspecs (parser)
2203 || c_parser_next_token_is (parser, CPP_CLOSE_PAREN)))
2205 struct c_arg_info *args
2206 = c_parser_parms_declarator (parser, kind == C_DTR_NORMAL,
2207 attrs);
2208 if (args == NULL)
2209 return NULL;
2210 else
2212 inner
2213 = build_function_declarator (args,
2214 build_id_declarator (NULL_TREE));
2215 return c_parser_direct_declarator_inner (parser, *seen_id,
2216 inner);
2219 /* A parenthesized declarator. */
2220 inner = c_parser_declarator (parser, type_seen_p, kind, seen_id);
2221 if (inner != NULL && attrs != NULL)
2222 inner = build_attrs_declarator (attrs, inner);
2223 if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2225 c_parser_consume_token (parser);
2226 if (inner == NULL)
2227 return NULL;
2228 else
2229 return c_parser_direct_declarator_inner (parser, *seen_id, inner);
2231 else
2233 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2234 "expected %<)%>");
2235 return NULL;
2238 else
2240 if (kind == C_DTR_NORMAL)
2242 c_parser_error (parser, "expected identifier or %<(%>");
2243 return NULL;
2245 else
2246 return build_id_declarator (NULL_TREE);
2250 /* Parse part of a direct declarator or direct abstract declarator,
2251 given that some (in INNER) has already been parsed; ID_PRESENT is
2252 true if an identifier is present, false for an abstract
2253 declarator. */
2255 static struct c_declarator *
2256 c_parser_direct_declarator_inner (c_parser *parser, bool id_present,
2257 struct c_declarator *inner)
2259 /* Parse a sequence of array declarators and parameter lists. */
2260 if (c_parser_next_token_is (parser, CPP_OPEN_SQUARE))
2262 struct c_declarator *declarator;
2263 struct c_declspecs *quals_attrs = build_null_declspecs ();
2264 bool static_seen;
2265 bool star_seen;
2266 tree dimen;
2267 c_parser_consume_token (parser);
2268 c_parser_declspecs (parser, quals_attrs, false, false, true);
2269 static_seen = c_parser_next_token_is_keyword (parser, RID_STATIC);
2270 if (static_seen)
2271 c_parser_consume_token (parser);
2272 if (static_seen && !quals_attrs->declspecs_seen_p)
2273 c_parser_declspecs (parser, quals_attrs, false, false, true);
2274 if (!quals_attrs->declspecs_seen_p)
2275 quals_attrs = NULL;
2276 /* If "static" is present, there must be an array dimension.
2277 Otherwise, there may be a dimension, "*", or no
2278 dimension. */
2279 if (static_seen)
2281 star_seen = false;
2282 dimen = c_parser_expr_no_commas (parser, NULL).value;
2284 else
2286 if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
2288 dimen = NULL_TREE;
2289 star_seen = false;
2291 else if (c_parser_next_token_is (parser, CPP_MULT))
2293 if (c_parser_peek_2nd_token (parser)->type == CPP_CLOSE_SQUARE)
2295 dimen = NULL_TREE;
2296 star_seen = true;
2297 c_parser_consume_token (parser);
2299 else
2301 star_seen = false;
2302 dimen = c_parser_expr_no_commas (parser, NULL).value;
2305 else
2307 star_seen = false;
2308 dimen = c_parser_expr_no_commas (parser, NULL).value;
2311 if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
2312 c_parser_consume_token (parser);
2313 else
2315 c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
2316 "expected %<]%>");
2317 return NULL;
2319 declarator = build_array_declarator (dimen, quals_attrs, static_seen,
2320 star_seen);
2321 inner = set_array_declarator_inner (declarator, inner, !id_present);
2322 return c_parser_direct_declarator_inner (parser, id_present, inner);
2324 else if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
2326 tree attrs;
2327 struct c_arg_info *args;
2328 c_parser_consume_token (parser);
2329 attrs = c_parser_attributes (parser);
2330 args = c_parser_parms_declarator (parser, id_present, attrs);
2331 if (args == NULL)
2332 return NULL;
2333 else
2335 inner = build_function_declarator (args, inner);
2336 return c_parser_direct_declarator_inner (parser, id_present, inner);
2339 return inner;
2342 /* Parse a parameter list or identifier list, including the closing
2343 parenthesis but not the opening one. ATTRS are the attributes at
2344 the start of the list. ID_LIST_OK is true if an identifier list is
2345 acceptable; such a list must not have attributes at the start. */
2347 static struct c_arg_info *
2348 c_parser_parms_declarator (c_parser *parser, bool id_list_ok, tree attrs)
2350 push_scope ();
2351 declare_parm_level ();
2352 /* If the list starts with an identifier, it is an identifier list.
2353 Otherwise, it is either a prototype list or an empty list. */
2354 if (id_list_ok
2355 && !attrs
2356 && c_parser_next_token_is (parser, CPP_NAME)
2357 && c_parser_peek_token (parser)->id_kind == C_ID_ID)
2359 tree list = NULL_TREE, *nextp = &list;
2360 while (c_parser_next_token_is (parser, CPP_NAME)
2361 && c_parser_peek_token (parser)->id_kind == C_ID_ID)
2363 *nextp = build_tree_list (NULL_TREE,
2364 c_parser_peek_token (parser)->value);
2365 nextp = & TREE_CHAIN (*nextp);
2366 c_parser_consume_token (parser);
2367 if (c_parser_next_token_is_not (parser, CPP_COMMA))
2368 break;
2369 c_parser_consume_token (parser);
2370 if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2372 c_parser_error (parser, "expected identifier");
2373 break;
2376 if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2378 struct c_arg_info *ret = XOBNEW (&parser_obstack, struct c_arg_info);
2379 ret->parms = 0;
2380 ret->tags = 0;
2381 ret->types = list;
2382 ret->others = 0;
2383 c_parser_consume_token (parser);
2384 pop_scope ();
2385 return ret;
2387 else
2389 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2390 "expected %<)%>");
2391 pop_scope ();
2392 return NULL;
2395 else
2397 struct c_arg_info *ret = c_parser_parms_list_declarator (parser, attrs);
2398 pop_scope ();
2399 return ret;
2403 /* Parse a parameter list (possibly empty), including the closing
2404 parenthesis but not the opening one. ATTRS are the attributes at
2405 the start of the list. */
2407 static struct c_arg_info *
2408 c_parser_parms_list_declarator (c_parser *parser, tree attrs)
2410 bool good_parm = false;
2411 /* ??? Following the old parser, forward parameter declarations may
2412 use abstract declarators, and if no real parameter declarations
2413 follow the forward declarations then this is not diagnosed. Also
2414 note as above that attributes are ignored as the only contents of
2415 the parentheses, or as the only contents after forward
2416 declarations. */
2417 if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2419 struct c_arg_info *ret = XOBNEW (&parser_obstack, struct c_arg_info);
2420 ret->parms = 0;
2421 ret->tags = 0;
2422 ret->types = 0;
2423 ret->others = 0;
2424 c_parser_consume_token (parser);
2425 return ret;
2427 if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
2429 struct c_arg_info *ret = XOBNEW (&parser_obstack, struct c_arg_info);
2430 ret->parms = 0;
2431 ret->tags = 0;
2432 ret->others = 0;
2433 /* Suppress -Wold-style-definition for this case. */
2434 ret->types = error_mark_node;
2435 error ("ISO C requires a named argument before %<...%>");
2436 c_parser_consume_token (parser);
2437 if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2439 c_parser_consume_token (parser);
2440 return ret;
2442 else
2444 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2445 "expected %<)%>");
2446 return NULL;
2449 /* Nonempty list of parameters, either terminated with semicolon
2450 (forward declarations; recurse) or with close parenthesis (normal
2451 function) or with ", ... )" (variadic function). */
2452 while (true)
2454 /* Parse a parameter. */
2455 struct c_parm *parm = c_parser_parameter_declaration (parser, attrs);
2456 attrs = NULL_TREE;
2457 if (parm != NULL)
2459 good_parm = true;
2460 push_parm_decl (parm);
2462 if (c_parser_next_token_is (parser, CPP_SEMICOLON))
2464 tree new_attrs;
2465 c_parser_consume_token (parser);
2466 new_attrs = c_parser_attributes (parser);
2467 return c_parser_parms_list_declarator (parser, new_attrs);
2469 if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2471 c_parser_consume_token (parser);
2472 if (good_parm)
2473 return get_parm_info (false);
2474 else
2476 struct c_arg_info *ret
2477 = XOBNEW (&parser_obstack, struct c_arg_info);
2478 ret->parms = 0;
2479 ret->tags = 0;
2480 ret->types = 0;
2481 ret->others = 0;
2482 return ret;
2485 if (!c_parser_require (parser, CPP_COMMA,
2486 "expected %<;%>, %<,%> or %<)%>"))
2488 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
2489 return NULL;
2491 if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
2493 c_parser_consume_token (parser);
2494 if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2496 c_parser_consume_token (parser);
2497 if (good_parm)
2498 return get_parm_info (true);
2499 else
2501 struct c_arg_info *ret
2502 = XOBNEW (&parser_obstack, struct c_arg_info);
2503 ret->parms = 0;
2504 ret->tags = 0;
2505 ret->types = 0;
2506 ret->others = 0;
2507 return ret;
2510 else
2512 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2513 "expected %<)%>");
2514 return NULL;
2520 /* Parse a parameter declaration. ATTRS are the attributes at the
2521 start of the declaration if it is the first parameter. */
2523 static struct c_parm *
2524 c_parser_parameter_declaration (c_parser *parser, tree attrs)
2526 struct c_declspecs *specs;
2527 struct c_declarator *declarator;
2528 tree prefix_attrs;
2529 tree postfix_attrs = NULL_TREE;
2530 bool dummy = false;
2531 if (!c_parser_next_token_starts_declspecs (parser))
2533 /* ??? In some Objective-C cases '...' isn't applicable so there
2534 should be a different message. */
2535 c_parser_error (parser,
2536 "expected declaration specifiers or %<...%>");
2537 c_parser_skip_to_end_of_parameter (parser);
2538 return NULL;
2540 specs = build_null_declspecs ();
2541 if (attrs)
2543 declspecs_add_attrs (specs, attrs);
2544 attrs = NULL_TREE;
2546 c_parser_declspecs (parser, specs, true, true, true);
2547 finish_declspecs (specs);
2548 pending_xref_error ();
2549 prefix_attrs = specs->attrs;
2550 specs->attrs = NULL_TREE;
2551 declarator = c_parser_declarator (parser, specs->type_seen_p,
2552 C_DTR_PARM, &dummy);
2553 if (declarator == NULL)
2555 c_parser_skip_until_found (parser, CPP_COMMA, NULL);
2556 return NULL;
2558 if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
2559 postfix_attrs = c_parser_attributes (parser);
2560 return build_c_parm (specs, chainon (postfix_attrs, prefix_attrs),
2561 declarator);
2564 /* Parse a string literal in an asm expression. It should not be
2565 translated, and wide string literals are an error although
2566 permitted by the syntax. This is a GNU extension.
2568 asm-string-literal:
2569 string-literal
2571 ??? At present, following the old parser, the caller needs to have
2572 set c_lex_string_translate to 0. It would be better to follow the
2573 C++ parser rather than using the c_lex_string_translate kludge. */
2575 static tree
2576 c_parser_asm_string_literal (c_parser *parser)
2578 tree str;
2579 if (c_parser_next_token_is (parser, CPP_STRING))
2581 str = c_parser_peek_token (parser)->value;
2582 c_parser_consume_token (parser);
2584 else if (c_parser_next_token_is (parser, CPP_WSTRING))
2586 error ("wide string literal in %<asm%>");
2587 str = build_string (1, "");
2588 c_parser_consume_token (parser);
2590 else
2592 c_parser_error (parser, "expected string literal");
2593 str = NULL_TREE;
2595 return str;
2598 /* Parse a simple asm expression. This is used in restricted
2599 contexts, where a full expression with inputs and outputs does not
2600 make sense. This is a GNU extension.
2602 simple-asm-expr:
2603 asm ( asm-string-literal )
2606 static tree
2607 c_parser_simple_asm_expr (c_parser *parser)
2609 tree str;
2610 gcc_assert (c_parser_next_token_is_keyword (parser, RID_ASM));
2611 /* ??? Follow the C++ parser rather than using the
2612 c_lex_string_translate kludge. */
2613 c_lex_string_translate = 0;
2614 c_parser_consume_token (parser);
2615 if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
2617 c_lex_string_translate = 1;
2618 return NULL_TREE;
2620 str = c_parser_asm_string_literal (parser);
2621 c_lex_string_translate = 1;
2622 if (!c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
2624 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
2625 return NULL_TREE;
2627 return str;
2630 /* Parse (possibly empty) attributes. This is a GNU extension.
2632 attributes:
2633 empty
2634 attributes attribute
2636 attribute:
2637 __attribute__ ( ( attribute-list ) )
2639 attribute-list:
2640 attrib
2641 attribute_list , attrib
2643 attrib:
2644 empty
2645 any-word
2646 any-word ( identifier )
2647 any-word ( identifier , nonempty-expr-list )
2648 any-word ( expr-list )
2650 where the "identifier" must not be declared as a type, and
2651 "any-word" may be any identifier (including one declared as a
2652 type), a reserved word storage class specifier, type specifier or
2653 type qualifier. ??? This still leaves out most reserved keywords
2654 (following the old parser), shouldn't we include them, and why not
2655 allow identifiers declared as types to start the arguments? */
2657 static tree
2658 c_parser_attributes (c_parser *parser)
2660 tree attrs = NULL_TREE;
2661 while (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
2663 /* ??? Follow the C++ parser rather than using the
2664 c_lex_string_translate kludge. */
2665 c_lex_string_translate = 0;
2666 c_parser_consume_token (parser);
2667 if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
2669 c_lex_string_translate = 1;
2670 return attrs;
2672 if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
2674 c_lex_string_translate = 1;
2675 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
2676 return attrs;
2678 /* Parse the attribute list. */
2679 while (c_parser_next_token_is (parser, CPP_COMMA)
2680 || c_parser_next_token_is (parser, CPP_NAME)
2681 || c_parser_next_token_is (parser, CPP_KEYWORD))
2683 tree attr, attr_name, attr_args;
2684 if (c_parser_next_token_is (parser, CPP_COMMA))
2686 c_parser_consume_token (parser);
2687 continue;
2689 if (c_parser_next_token_is (parser, CPP_KEYWORD))
2691 /* ??? See comment above about what keywords are
2692 accepted here. */
2693 bool ok;
2694 switch (c_parser_peek_token (parser)->keyword)
2696 case RID_STATIC:
2697 case RID_UNSIGNED:
2698 case RID_LONG:
2699 case RID_CONST:
2700 case RID_EXTERN:
2701 case RID_REGISTER:
2702 case RID_TYPEDEF:
2703 case RID_SHORT:
2704 case RID_INLINE:
2705 case RID_VOLATILE:
2706 case RID_SIGNED:
2707 case RID_AUTO:
2708 case RID_RESTRICT:
2709 case RID_COMPLEX:
2710 case RID_THREAD:
2711 case RID_INT:
2712 case RID_CHAR:
2713 case RID_FLOAT:
2714 case RID_DOUBLE:
2715 case RID_VOID:
2716 case RID_BOOL:
2717 ok = true;
2718 break;
2719 default:
2720 ok = false;
2721 break;
2723 if (!ok)
2724 break;
2726 attr_name = c_parser_peek_token (parser)->value;
2727 c_parser_consume_token (parser);
2728 if (c_parser_next_token_is_not (parser, CPP_OPEN_PAREN))
2730 attr = build_tree_list (attr_name, NULL_TREE);
2731 attrs = chainon (attrs, attr);
2732 continue;
2734 c_parser_consume_token (parser);
2735 /* Parse the attribute contents. If they start with an
2736 identifier which is followed by a comma or close
2737 parenthesis, then the arguments start with that
2738 identifier; otherwise they are an expression list. */
2739 if (c_parser_next_token_is (parser, CPP_NAME)
2740 && c_parser_peek_token (parser)->id_kind == C_ID_ID
2741 && ((c_parser_peek_2nd_token (parser)->type == CPP_COMMA)
2742 || (c_parser_peek_2nd_token (parser)->type
2743 == CPP_CLOSE_PAREN)))
2745 tree arg1 = c_parser_peek_token (parser)->value;
2746 c_parser_consume_token (parser);
2747 if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2748 attr_args = build_tree_list (NULL_TREE, arg1);
2749 else
2751 c_parser_consume_token (parser);
2752 attr_args = tree_cons (NULL_TREE, arg1,
2753 c_parser_expr_list (parser, false));
2756 else
2758 if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2759 attr_args = NULL_TREE;
2760 else
2761 attr_args = c_parser_expr_list (parser, false);
2763 attr = build_tree_list (attr_name, attr_args);
2764 if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2765 c_parser_consume_token (parser);
2766 else
2768 c_lex_string_translate = 1;
2769 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2770 "expected %<)%>");
2771 return attrs;
2773 attrs = chainon (attrs, attr);
2775 if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2776 c_parser_consume_token (parser);
2777 else
2779 c_lex_string_translate = 1;
2780 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2781 "expected %<)%>");
2782 return attrs;
2784 if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2785 c_parser_consume_token (parser);
2786 else
2788 c_lex_string_translate = 1;
2789 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2790 "expected %<)%>");
2791 return attrs;
2793 c_lex_string_translate = 1;
2795 return attrs;
2798 /* Parse a type name (C90 6.5.5, C99 6.7.6).
2800 type-name:
2801 specifier-qualifier-list abstract-declarator[opt]
2804 static struct c_type_name *
2805 c_parser_type_name (c_parser *parser)
2807 struct c_declspecs *specs = build_null_declspecs ();
2808 struct c_declarator *declarator;
2809 struct c_type_name *ret;
2810 bool dummy = false;
2811 c_parser_declspecs (parser, specs, false, true, true);
2812 if (!specs->declspecs_seen_p)
2814 c_parser_error (parser, "expected specifier-qualifier-list");
2815 return NULL;
2817 pending_xref_error ();
2818 finish_declspecs (specs);
2819 declarator = c_parser_declarator (parser, specs->type_seen_p,
2820 C_DTR_ABSTRACT, &dummy);
2821 if (declarator == NULL)
2822 return NULL;
2823 ret = XOBNEW (&parser_obstack, struct c_type_name);
2824 ret->specs = specs;
2825 ret->declarator = declarator;
2826 return ret;
2829 /* Parse an initializer (C90 6.5.7, C99 6.7.8).
2831 initializer:
2832 assignment-expression
2833 { initializer-list }
2834 { initializer-list , }
2836 initializer-list:
2837 designation[opt] initializer
2838 initializer-list , designation[opt] initializer
2840 designation:
2841 designator-list =
2843 designator-list:
2844 designator
2845 designator-list designator
2847 designator:
2848 array-designator
2849 . identifier
2851 array-designator:
2852 [ constant-expression ]
2854 GNU extensions:
2856 initializer:
2859 designation:
2860 array-designator
2861 identifier :
2863 array-designator:
2864 [ constant-expression ... constant-expression ]
2866 Any expression without commas is accepted in the syntax for the
2867 constant-expressions, with non-constant expressions rejected later.
2869 This function is only used for top-level initializers; for nested
2870 ones, see c_parser_initval. */
2872 static struct c_expr
2873 c_parser_initializer (c_parser *parser)
2875 if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
2876 return c_parser_braced_init (parser, NULL_TREE, false);
2877 else
2879 struct c_expr ret;
2880 ret = c_parser_expr_no_commas (parser, NULL);
2881 if (TREE_CODE (ret.value) != STRING_CST
2882 && TREE_CODE (ret.value) != COMPOUND_LITERAL_EXPR)
2883 ret = default_function_array_conversion (ret);
2884 return ret;
2888 /* Parse a braced initializer list. TYPE is the type specified for a
2889 compound literal, and NULL_TREE for other initializers and for
2890 nested braced lists. NESTED_P is true for nested braced lists,
2891 false for the list of a compound literal or the list that is the
2892 top-level initializer in a declaration. */
2894 static struct c_expr
2895 c_parser_braced_init (c_parser *parser, tree type, bool nested_p)
2897 gcc_assert (c_parser_next_token_is (parser, CPP_OPEN_BRACE));
2898 c_parser_consume_token (parser);
2899 if (nested_p)
2900 push_init_level (0);
2901 else
2902 really_start_incremental_init (type);
2903 if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
2905 if (pedantic)
2906 pedwarn ("ISO C forbids empty initializer braces");
2908 else
2910 /* Parse a non-empty initializer list, possibly with a trailing
2911 comma. */
2912 while (true)
2914 c_parser_initelt (parser);
2915 if (parser->error)
2916 break;
2917 if (c_parser_next_token_is (parser, CPP_COMMA))
2918 c_parser_consume_token (parser);
2919 else
2920 break;
2921 if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
2922 break;
2925 if (c_parser_next_token_is_not (parser, CPP_CLOSE_BRACE))
2927 struct c_expr ret;
2928 ret.value = error_mark_node;
2929 ret.original_code = ERROR_MARK;
2930 c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, "expected %<}%>");
2931 return ret;
2933 c_parser_consume_token (parser);
2934 return pop_init_level (0);
2937 /* Parse a nested initializer, including designators. */
2939 static void
2940 c_parser_initelt (c_parser *parser)
2942 /* Parse any designator or designator list. A single array
2943 designator may have the subsequent "=" omitted in GNU C, but a
2944 longer list or a structure member designator may not. */
2945 if (c_parser_next_token_is (parser, CPP_NAME)
2946 && c_parser_peek_2nd_token (parser)->type == CPP_COLON)
2948 /* Old-style structure member designator. */
2949 set_init_label (c_parser_peek_token (parser)->value);
2950 if (pedantic)
2951 pedwarn ("obsolete use of designated initializer with %<:%>");
2952 c_parser_consume_token (parser);
2953 c_parser_consume_token (parser);
2955 else
2957 /* des_seen is 0 if there have been no designators, 1 if there
2958 has been a single array designator and 2 otherwise. */
2959 int des_seen = 0;
2960 while (c_parser_next_token_is (parser, CPP_OPEN_SQUARE)
2961 || c_parser_next_token_is (parser, CPP_DOT))
2963 int des_prev = des_seen;
2964 if (des_seen < 2)
2965 des_seen++;
2966 if (c_parser_next_token_is (parser, CPP_DOT))
2968 des_seen = 2;
2969 c_parser_consume_token (parser);
2970 if (c_parser_next_token_is (parser, CPP_NAME))
2972 set_init_label (c_parser_peek_token (parser)->value);
2973 c_parser_consume_token (parser);
2975 else
2977 struct c_expr init;
2978 init.value = error_mark_node;
2979 init.original_code = ERROR_MARK;
2980 c_parser_error (parser, "expected identifier");
2981 c_parser_skip_until_found (parser, CPP_COMMA, NULL);
2982 process_init_element (init);
2983 return;
2986 else
2988 tree first, second;
2989 /* ??? Following the old parser, [ objc-receiver
2990 objc-message-args ] is accepted as an initializer,
2991 being distinguished from a designator by what follows
2992 the first assignment expression inside the square
2993 brackets, but after a first array designator a
2994 subsequent square bracket is for Objective-C taken to
2995 start an expression, using the obsolete form of
2996 designated initializer without '=', rather than
2997 possibly being a second level of designation: in LALR
2998 terms, the '[' is shifted rather than reducing
2999 designator to designator-list. */
3000 if (des_prev == 1 && c_dialect_objc ())
3002 des_seen = des_prev;
3003 break;
3005 if (des_prev == 0 && c_dialect_objc ())
3007 /* This might be an array designator or an
3008 Objective-C message expression. If the former,
3009 continue parsing here; if the latter, parse the
3010 remainder of the initializer given the starting
3011 primary-expression. ??? It might make sense to
3012 distinguish when des_prev == 1 as well; see
3013 previous comment. */
3014 tree rec, args;
3015 struct c_expr mexpr;
3016 c_parser_consume_token (parser);
3017 if (c_parser_peek_token (parser)->type == CPP_NAME
3018 && ((c_parser_peek_token (parser)->id_kind
3019 == C_ID_TYPENAME)
3020 || (c_parser_peek_token (parser)->id_kind
3021 == C_ID_CLASSNAME)))
3023 /* Type name receiver. */
3024 tree id = c_parser_peek_token (parser)->value;
3025 c_parser_consume_token (parser);
3026 rec = objc_get_class_reference (id);
3027 goto parse_message_args;
3029 first = c_parser_expr_no_commas (parser, NULL).value;
3030 if (c_parser_next_token_is (parser, CPP_ELLIPSIS)
3031 || c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
3032 goto array_desig_after_first;
3033 /* Expression receiver. So far only one part
3034 without commas has been parsed; there might be
3035 more of the expression. */
3036 rec = first;
3037 while (c_parser_next_token_is (parser, CPP_COMMA))
3039 struct c_expr next;
3040 c_parser_consume_token (parser);
3041 next = c_parser_expr_no_commas (parser, NULL);
3042 next = default_function_array_conversion (next);
3043 rec = build_compound_expr (rec, next.value);
3045 parse_message_args:
3046 /* Now parse the objc-message-args. */
3047 args = c_parser_objc_message_args (parser);
3048 c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
3049 "expected %<]%>");
3050 mexpr.value
3051 = objc_build_message_expr (build_tree_list (rec, args));
3052 mexpr.original_code = ERROR_MARK;
3053 /* Now parse and process the remainder of the
3054 initializer, starting with this message
3055 expression as a primary-expression. */
3056 c_parser_initval (parser, &mexpr);
3057 return;
3059 c_parser_consume_token (parser);
3060 first = c_parser_expr_no_commas (parser, NULL).value;
3061 array_desig_after_first:
3062 if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
3064 c_parser_consume_token (parser);
3065 second = c_parser_expr_no_commas (parser, NULL).value;
3067 else
3068 second = NULL_TREE;
3069 if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
3071 c_parser_consume_token (parser);
3072 set_init_index (first, second);
3073 if (pedantic && second)
3074 pedwarn ("ISO C forbids specifying range of "
3075 "elements to initialize");
3077 else
3078 c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
3079 "expected %<]%>");
3082 if (des_seen >= 1)
3084 if (c_parser_next_token_is (parser, CPP_EQ))
3086 if (pedantic && !flag_isoc99)
3087 pedwarn ("ISO C90 forbids specifying subobject to initialize");
3088 c_parser_consume_token (parser);
3090 else
3092 if (des_seen == 1)
3094 if (pedantic)
3095 pedwarn ("obsolete use of designated initializer "
3096 "without %<=%>");
3098 else
3100 struct c_expr init;
3101 init.value = error_mark_node;
3102 init.original_code = ERROR_MARK;
3103 c_parser_error (parser, "expected %<=%>");
3104 c_parser_skip_until_found (parser, CPP_COMMA, NULL);
3105 process_init_element (init);
3106 return;
3111 c_parser_initval (parser, NULL);
3114 /* Parse a nested initializer; as c_parser_initializer but parses
3115 initializers within braced lists, after any designators have been
3116 applied. If AFTER is not NULL then it is an Objective-C message
3117 expression which is the primary-expression starting the
3118 initializer. */
3120 static void
3121 c_parser_initval (c_parser *parser, struct c_expr *after)
3123 struct c_expr init;
3124 gcc_assert (!after || c_dialect_objc ());
3125 if (c_parser_next_token_is (parser, CPP_OPEN_BRACE) && !after)
3126 init = c_parser_braced_init (parser, NULL_TREE, true);
3127 else
3129 init = c_parser_expr_no_commas (parser, after);
3130 if (init.value != NULL_TREE
3131 && TREE_CODE (init.value) != STRING_CST
3132 && TREE_CODE (init.value) != COMPOUND_LITERAL_EXPR)
3133 init = default_function_array_conversion (init);
3135 process_init_element (init);
3138 /* Parse a compound statement (possibly a function body) (C90 6.6.2,
3139 C99 6.8.2).
3141 compound-statement:
3142 { block-item-list[opt] }
3143 { label-declarations block-item-list }
3145 block-item-list:
3146 block-item
3147 block-item-list block-item
3149 block-item:
3150 nested-declaration
3151 statement
3153 nested-declaration:
3154 declaration
3156 GNU extensions:
3158 compound-statement:
3159 { label-declarations block-item-list }
3161 nested-declaration:
3162 __extension__ nested-declaration
3163 nested-function-definition
3165 label-declarations:
3166 label-declaration
3167 label-declarations label-declaration
3169 label-declaration:
3170 __label__ identifier-list ;
3172 Allowing the mixing of declarations and code is new in C99. The
3173 GNU syntax also permits (not shown above) labels at the end of
3174 compound statements, which yield an error. We don't allow labels
3175 on declarations; this might seem like a natural extension, but
3176 there would be a conflict between attributes on the label and
3177 prefix attributes on the declaration. ??? The syntax follows the
3178 old parser in requiring something after label declarations.
3179 Although they are erroneous if the labels declared aren't defined,
3180 is it useful for the syntax to be this way? */
3182 static tree
3183 c_parser_compound_statement (c_parser *parser)
3185 tree stmt;
3186 if (!c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>"))
3187 return error_mark_node;
3188 stmt = c_begin_compound_stmt (true);
3189 c_parser_compound_statement_nostart (parser);
3190 return c_end_compound_stmt (stmt, true);
3193 /* Parse a compound statement except for the opening brace. This is
3194 used for parsing both compound statements and statement expressions
3195 (which follow different paths to handling the opening). */
3197 static void
3198 c_parser_compound_statement_nostart (c_parser *parser)
3200 bool last_stmt = false;
3201 bool last_label = false;
3202 if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
3204 c_parser_consume_token (parser);
3205 return;
3207 if (c_parser_next_token_is_keyword (parser, RID_LABEL))
3209 /* Read zero or more forward-declarations for labels that nested
3210 functions can jump to. */
3211 while (c_parser_next_token_is_keyword (parser, RID_LABEL))
3213 c_parser_consume_token (parser);
3214 /* Any identifiers, including those declared as type names,
3215 are OK here. */
3216 while (true)
3218 tree label;
3219 if (c_parser_next_token_is_not (parser, CPP_NAME))
3221 c_parser_error (parser, "expected identifier");
3222 break;
3224 label
3225 = declare_label (c_parser_peek_token (parser)->value);
3226 C_DECLARED_LABEL_FLAG (label) = 1;
3227 add_stmt (build_stmt (DECL_EXPR, label));
3228 c_parser_consume_token (parser);
3229 if (c_parser_next_token_is (parser, CPP_COMMA))
3230 c_parser_consume_token (parser);
3231 else
3232 break;
3234 c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
3236 /* ??? Locating this diagnostic on the token after the
3237 declarations end follows the old parser, but it might be
3238 better to locate it where the declarations start instead. */
3239 if (pedantic)
3240 pedwarn ("ISO C forbids label declarations");
3242 /* We must now have at least one statement, label or declaration. */
3243 if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
3245 c_parser_error (parser, "expected declaration or statement");
3246 c_parser_consume_token (parser);
3247 return;
3249 while (c_parser_next_token_is_not (parser, CPP_CLOSE_BRACE))
3251 location_t loc = c_parser_peek_token (parser)->location;
3252 if (c_parser_next_token_is (parser, CPP_EOF))
3254 c_parser_error (parser, "expected declaration or statement");
3255 return;
3257 if (c_parser_next_token_is_keyword (parser, RID_CASE)
3258 || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
3259 || (c_parser_next_token_is (parser, CPP_NAME)
3260 && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
3262 last_label = true;
3263 last_stmt = false;
3264 c_parser_label (parser);
3266 else if (!last_label
3267 && c_parser_next_token_starts_declspecs (parser))
3269 last_label = false;
3270 c_parser_declaration_or_fndef (parser, true, true, true, true);
3271 if (last_stmt
3272 && ((pedantic && !flag_isoc99)
3273 || warn_declaration_after_statement))
3274 pedwarn_c90 ("%HISO C90 forbids mixed declarations and code",
3275 &loc);
3276 last_stmt = false;
3278 else if (!last_label
3279 && c_parser_next_token_is_keyword (parser, RID_EXTENSION))
3281 /* __extension__ can start a declaration, but is also an
3282 unary operator that can start an expression. Consume all
3283 but the last of a possible series of __extension__ to
3284 determine which. */
3285 while (c_parser_peek_2nd_token (parser)->type == CPP_KEYWORD
3286 && (c_parser_peek_2nd_token (parser)->keyword
3287 == RID_EXTENSION))
3288 c_parser_consume_token (parser);
3289 if (c_token_starts_declspecs (c_parser_peek_2nd_token (parser)))
3291 int ext;
3292 ext = disable_extension_diagnostics ();
3293 c_parser_consume_token (parser);
3294 last_label = false;
3295 c_parser_declaration_or_fndef (parser, true, true, true, true);
3296 /* Following the old parser, __extension__ does not
3297 disable this diagnostic. */
3298 restore_extension_diagnostics (ext);
3299 if (last_stmt
3300 && ((pedantic && !flag_isoc99)
3301 || warn_declaration_after_statement))
3302 pedwarn_c90 ("%HISO C90 forbids mixed declarations and code",
3303 &loc);
3304 last_stmt = false;
3306 else
3307 goto statement;
3309 else
3311 statement:
3312 last_label = false;
3313 last_stmt = true;
3314 c_parser_statement_after_labels (parser);
3317 if (last_label)
3318 error ("label at end of compound statement");
3319 c_parser_consume_token (parser);
3322 /* Parse a label (C90 6.6.1, C99 6.8.1).
3324 label:
3325 identifier : attributes[opt]
3326 case constant-expression :
3327 default :
3329 GNU extensions:
3331 label:
3332 case constant-expression ... constant-expression :
3334 The use of attributes on labels is a GNU extension. The syntax in
3335 GNU C accepts any expressions without commas, non-constant
3336 expressions being rejected later. */
3338 static void
3339 c_parser_label (c_parser *parser)
3341 location_t loc1 = c_parser_peek_token (parser)->location;
3342 tree label = NULL_TREE;
3343 if (c_parser_next_token_is_keyword (parser, RID_CASE))
3345 tree exp1, exp2;
3346 c_parser_consume_token (parser);
3347 exp1 = c_parser_expr_no_commas (parser, NULL).value;
3348 if (c_parser_next_token_is (parser, CPP_COLON))
3350 c_parser_consume_token (parser);
3351 label = do_case (exp1, NULL_TREE);
3353 else if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
3355 c_parser_consume_token (parser);
3356 exp2 = c_parser_expr_no_commas (parser, NULL).value;
3357 if (c_parser_require (parser, CPP_COLON, "expected %<:%>"))
3358 label = do_case (exp1, exp2);
3360 else
3361 c_parser_error (parser, "expected %<:%> or %<...%>");
3363 else if (c_parser_next_token_is_keyword (parser, RID_DEFAULT))
3365 c_parser_consume_token (parser);
3366 if (c_parser_require (parser, CPP_COLON, "expected %<:%>"))
3367 label = do_case (NULL_TREE, NULL_TREE);
3369 else
3371 tree name = c_parser_peek_token (parser)->value;
3372 tree tlab;
3373 location_t loc2;
3374 tree attrs;
3375 gcc_assert (c_parser_next_token_is (parser, CPP_NAME));
3376 c_parser_consume_token (parser);
3377 gcc_assert (c_parser_next_token_is (parser, CPP_COLON));
3378 loc2 = c_parser_peek_token (parser)->location;
3379 c_parser_consume_token (parser);
3380 attrs = c_parser_attributes (parser);
3381 tlab = define_label (loc2, name);
3382 if (tlab)
3384 decl_attributes (&tlab, attrs, 0);
3385 label = add_stmt (build_stmt (LABEL_EXPR, tlab));
3388 if (label)
3389 SET_EXPR_LOCATION (label, loc1);
3392 /* Parse a statement (C90 6.6, C99 6.8).
3394 statement:
3395 labeled-statement
3396 compound-statement
3397 expression-statement
3398 selection-statement
3399 iteration-statement
3400 jump-statement
3402 labeled-statement:
3403 label statement
3405 expression-statement:
3406 expression[opt] ;
3408 selection-statement:
3409 if-statement
3410 switch-statement
3412 iteration-statement:
3413 while-statement
3414 do-statement
3415 for-statement
3417 jump-statement:
3418 goto identifier ;
3419 continue ;
3420 break ;
3421 return expression[opt] ;
3423 GNU extensions:
3425 statement:
3426 asm-statement
3428 jump-statement:
3429 goto * expression ;
3431 Objective-C:
3433 statement:
3434 objc-throw-statement
3435 objc-try-catch-statement
3436 objc-synchronized-statement
3438 objc-throw-statement:
3439 @throw expression ;
3440 @throw ;
3443 static void
3444 c_parser_statement (c_parser *parser)
3446 while (c_parser_next_token_is_keyword (parser, RID_CASE)
3447 || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
3448 || (c_parser_next_token_is (parser, CPP_NAME)
3449 && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
3450 c_parser_label (parser);
3451 c_parser_statement_after_labels (parser);
3454 /* Parse a statement, other than a labeled statement. */
3456 static void
3457 c_parser_statement_after_labels (c_parser *parser)
3459 location_t loc = c_parser_peek_token (parser)->location;
3460 tree stmt = NULL_TREE;
3461 switch (c_parser_peek_token (parser)->type)
3463 case CPP_OPEN_BRACE:
3464 add_stmt (c_parser_compound_statement (parser));
3465 break;
3466 case CPP_KEYWORD:
3467 switch (c_parser_peek_token (parser)->keyword)
3469 case RID_IF:
3470 c_parser_if_statement (parser);
3471 break;
3472 case RID_SWITCH:
3473 c_parser_switch_statement (parser);
3474 break;
3475 case RID_WHILE:
3476 c_parser_while_statement (parser);
3477 break;
3478 case RID_DO:
3479 c_parser_do_statement (parser);
3480 break;
3481 case RID_FOR:
3482 c_parser_for_statement (parser);
3483 break;
3484 case RID_GOTO:
3485 c_parser_consume_token (parser);
3486 if (c_parser_next_token_is (parser, CPP_NAME))
3488 stmt = c_finish_goto_label (c_parser_peek_token (parser)->value);
3489 c_parser_consume_token (parser);
3491 else if (c_parser_next_token_is (parser, CPP_MULT))
3493 c_parser_consume_token (parser);
3494 stmt = c_finish_goto_ptr (c_parser_expression (parser).value);
3496 else
3497 c_parser_error (parser, "expected identifier or %<*%>");
3498 goto expect_semicolon;
3499 case RID_CONTINUE:
3500 c_parser_consume_token (parser);
3501 stmt = c_finish_bc_stmt (&c_cont_label, false);
3502 goto expect_semicolon;
3503 case RID_BREAK:
3504 c_parser_consume_token (parser);
3505 stmt = c_finish_bc_stmt (&c_break_label, true);
3506 goto expect_semicolon;
3507 case RID_RETURN:
3508 c_parser_consume_token (parser);
3509 if (c_parser_next_token_is (parser, CPP_SEMICOLON))
3511 stmt = c_finish_return (NULL_TREE);
3512 c_parser_consume_token (parser);
3514 else
3516 stmt = c_finish_return (c_parser_expression_conv (parser).value);
3517 goto expect_semicolon;
3519 break;
3520 case RID_ASM:
3521 stmt = c_parser_asm_statement (parser);
3522 break;
3523 case RID_AT_THROW:
3524 gcc_assert (c_dialect_objc ());
3525 c_parser_consume_token (parser);
3526 if (c_parser_next_token_is (parser, CPP_SEMICOLON))
3528 stmt = objc_build_throw_stmt (NULL_TREE);
3529 c_parser_consume_token (parser);
3531 else
3533 stmt
3534 = objc_build_throw_stmt (c_parser_expression (parser).value);
3535 goto expect_semicolon;
3537 break;
3538 case RID_AT_TRY:
3539 gcc_assert (c_dialect_objc ());
3540 c_parser_objc_try_catch_statement (parser);
3541 break;
3542 case RID_AT_SYNCHRONIZED:
3543 gcc_assert (c_dialect_objc ());
3544 c_parser_objc_synchronized_statement (parser);
3545 break;
3546 default:
3547 goto expr_stmt;
3549 break;
3550 case CPP_SEMICOLON:
3551 c_parser_consume_token (parser);
3552 break;
3553 case CPP_CLOSE_PAREN:
3554 case CPP_CLOSE_SQUARE:
3555 /* Avoid infinite loop in error recovery:
3556 c_parser_skip_until_found stops at a closing nesting
3557 delimiter without consuming it, but here we need to consume
3558 it to proceed further. */
3559 c_parser_error (parser, "expected statement");
3560 c_parser_consume_token (parser);
3561 break;
3562 default:
3563 expr_stmt:
3564 stmt = c_finish_expr_stmt (c_parser_expression_conv (parser).value);
3565 expect_semicolon:
3566 c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
3567 break;
3569 /* Two cases cannot and do not have line numbers associated: If stmt
3570 is degenerate, such as "2;", then stmt is an INTEGER_CST, which
3571 cannot hold line numbers. But that's OK because the statement
3572 will either be changed to a MODIFY_EXPR during gimplification of
3573 the statement expr, or discarded. If stmt was compound, but
3574 without new variables, we will have skipped the creation of a
3575 BIND and will have a bare STATEMENT_LIST. But that's OK because
3576 (recursively) all of the component statements should already have
3577 line numbers assigned. ??? Can we discard no-op statements
3578 earlier? */
3579 if (stmt && EXPR_P (stmt))
3580 SET_EXPR_LOCATION (stmt, loc);
3583 /* Parse a parenthesized condition from an if, do or while statement.
3585 condition:
3586 ( expression )
3588 static tree
3589 c_parser_paren_condition (c_parser *parser)
3591 location_t loc;
3592 tree cond;
3593 if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
3594 return error_mark_node;
3595 loc = c_parser_peek_token (parser)->location;
3596 cond = c_objc_common_truthvalue_conversion
3597 (c_parser_expression_conv (parser).value);
3598 if (EXPR_P (cond))
3599 SET_EXPR_LOCATION (cond, loc);
3600 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
3601 return cond;
3604 /* Parse a statement which is a block in C99. */
3606 static tree
3607 c_parser_c99_block_statement (c_parser *parser)
3609 tree block = c_begin_compound_stmt (flag_isoc99);
3610 c_parser_statement (parser);
3611 return c_end_compound_stmt (block, flag_isoc99);
3614 /* Parse the body of an if statement or the else half thereof. This
3615 is just parsing a statement but (a) it is a block in C99, (b) we
3616 track whether the body is an if statement for the sake of
3617 -Wparentheses warnings, (c) we handle an empty body specially for
3618 the sake of -Wextra warnings. */
3620 static tree
3621 c_parser_if_body (c_parser *parser, bool *if_p)
3623 tree block = c_begin_compound_stmt (flag_isoc99);
3624 while (c_parser_next_token_is_keyword (parser, RID_CASE)
3625 || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
3626 || (c_parser_next_token_is (parser, CPP_NAME)
3627 && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
3628 c_parser_label (parser);
3629 *if_p = c_parser_next_token_is_keyword (parser, RID_IF);
3630 if (extra_warnings && c_parser_next_token_is (parser, CPP_SEMICOLON))
3631 add_stmt (build (NOP_EXPR, NULL_TREE, NULL_TREE));
3632 c_parser_statement_after_labels (parser);
3633 return c_end_compound_stmt (block, flag_isoc99);
3636 /* Parse an if statement (C90 6.6.4, C99 6.8.4).
3638 if-statement:
3639 if ( expression ) statement
3640 if ( expression ) statement else statement
3643 static void
3644 c_parser_if_statement (c_parser *parser)
3646 tree block;
3647 location_t loc;
3648 tree cond;
3649 bool first_if = false, second_if = false;
3650 tree first_body, second_body;
3651 gcc_assert (c_parser_next_token_is_keyword (parser, RID_IF));
3652 c_parser_consume_token (parser);
3653 block = c_begin_compound_stmt (flag_isoc99);
3654 loc = c_parser_peek_token (parser)->location;
3655 cond = c_parser_paren_condition (parser);
3656 first_body = c_parser_if_body (parser, &first_if);
3657 if (c_parser_next_token_is_keyword (parser, RID_ELSE))
3659 c_parser_consume_token (parser);
3660 second_body = c_parser_if_body (parser, &second_if);
3662 else
3663 second_body = NULL_TREE;
3664 c_finish_if_stmt (loc, cond, first_body, second_body, first_if);
3665 add_stmt (c_end_compound_stmt (block, flag_isoc99));
3668 /* Parse a switch statement (C90 6.6.4, C99 6.8.4).
3670 switch-statement:
3671 switch (expression) statement
3674 static void
3675 c_parser_switch_statement (c_parser *parser)
3677 tree block, expr, body, save_break;
3678 gcc_assert (c_parser_next_token_is_keyword (parser, RID_SWITCH));
3679 c_parser_consume_token (parser);
3680 block = c_begin_compound_stmt (flag_isoc99);
3681 if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
3683 expr = c_parser_expression (parser).value;
3684 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
3686 else
3687 expr = error_mark_node;
3688 c_start_case (expr);
3689 save_break = c_break_label;
3690 c_break_label = NULL_TREE;
3691 body = c_parser_c99_block_statement (parser);
3692 c_finish_case (body);
3693 if (c_break_label)
3694 add_stmt (build (LABEL_EXPR, void_type_node, c_break_label));
3695 c_break_label = save_break;
3696 add_stmt (c_end_compound_stmt (block, flag_isoc99));
3699 /* Parse a while statement (C90 6.6.5, C99 6.8.5).
3701 while-statement:
3702 while (expression) statement
3705 static void
3706 c_parser_while_statement (c_parser *parser)
3708 tree block, cond, body, save_break, save_cont;
3709 location_t loc;
3710 gcc_assert (c_parser_next_token_is_keyword (parser, RID_WHILE));
3711 c_parser_consume_token (parser);
3712 block = c_begin_compound_stmt (flag_isoc99);
3713 loc = c_parser_peek_token (parser)->location;
3714 cond = c_parser_paren_condition (parser);
3715 save_break = c_break_label;
3716 c_break_label = NULL_TREE;
3717 save_cont = c_cont_label;
3718 c_cont_label = NULL_TREE;
3719 body = c_parser_c99_block_statement (parser);
3720 c_finish_loop (loc, cond, NULL, body, c_break_label, c_cont_label, true);
3721 add_stmt (c_end_compound_stmt (block, flag_isoc99));
3722 c_break_label = save_break;
3723 c_cont_label = save_cont;
3726 /* Parse a do statement (C90 6.6.5, C99 6.8.5).
3728 do-statement:
3729 do statement while ( expression ) ;
3732 static void
3733 c_parser_do_statement (c_parser *parser)
3735 tree block, cond, body, save_break, save_cont, new_break, new_cont;
3736 location_t loc;
3737 gcc_assert (c_parser_next_token_is_keyword (parser, RID_DO));
3738 c_parser_consume_token (parser);
3739 block = c_begin_compound_stmt (flag_isoc99);
3740 loc = c_parser_peek_token (parser)->location;
3741 save_break = c_break_label;
3742 c_break_label = NULL_TREE;
3743 save_cont = c_cont_label;
3744 c_cont_label = NULL_TREE;
3745 body = c_parser_c99_block_statement (parser);
3746 c_parser_require_keyword (parser, RID_WHILE, "expected %<while%>");
3747 new_break = c_break_label;
3748 c_break_label = save_break;
3749 new_cont = c_cont_label;
3750 c_cont_label = save_cont;
3751 cond = c_parser_paren_condition (parser);
3752 if (!c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>"))
3753 c_parser_skip_to_end_of_block_or_statement (parser);
3754 c_finish_loop (loc, cond, NULL, body, new_break, new_cont, false);
3755 add_stmt (c_end_compound_stmt (block, flag_isoc99));
3758 /* Parse a for statement (C90 6.6.5, C99 6.8.5).
3760 for-statement:
3761 for ( expression[opt] ; expression[opt] ; expression[opt] ) statement
3762 for ( nested-declaration expression[opt] ; expression[opt] ) statement
3764 The form with a declaration is new in C99.
3766 ??? In accordance with the old parser, the declaration may be a
3767 nested function, which is then rejected in check_for_loop_decls,
3768 but does it make any sense for this to be included in the grammar?
3769 Note in particular that the nested function does not include a
3770 trailing ';', whereas the "declaration" production includes one.
3771 Also, can we reject bad declarations earlier and cheaper than
3772 check_for_loop_decls? */
3774 static void
3775 c_parser_for_statement (c_parser *parser)
3777 tree block, cond, incr, save_break, save_cont, body;
3778 location_t loc = UNKNOWN_LOCATION;
3779 gcc_assert (c_parser_next_token_is_keyword (parser, RID_FOR));
3780 c_parser_consume_token (parser);
3781 block = c_begin_compound_stmt (flag_isoc99);
3782 if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
3784 /* Parse the initialization declaration or expression. */
3785 if (c_parser_next_token_is (parser, CPP_SEMICOLON))
3787 c_parser_consume_token (parser);
3788 c_finish_expr_stmt (NULL_TREE);
3790 else if (c_parser_next_token_starts_declspecs (parser))
3792 c_parser_declaration_or_fndef (parser, true, true, true, true);
3793 check_for_loop_decls ();
3795 else if (c_parser_next_token_is_keyword (parser, RID_EXTENSION))
3797 /* __extension__ can start a declaration, but is also an
3798 unary operator that can start an expression. Consume all
3799 but the last of a possible series of __extension__ to
3800 determine which. */
3801 while (c_parser_peek_2nd_token (parser)->type == CPP_KEYWORD
3802 && (c_parser_peek_2nd_token (parser)->keyword
3803 == RID_EXTENSION))
3804 c_parser_consume_token (parser);
3805 if (c_token_starts_declspecs (c_parser_peek_2nd_token (parser)))
3807 int ext;
3808 ext = disable_extension_diagnostics ();
3809 c_parser_consume_token (parser);
3810 c_parser_declaration_or_fndef (parser, true, true, true, true);
3811 restore_extension_diagnostics (ext);
3812 check_for_loop_decls ();
3814 else
3815 goto init_expr;
3817 else
3819 init_expr:
3820 c_finish_expr_stmt (c_parser_expression (parser).value);
3821 c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
3823 /* Parse the loop condition. */
3824 loc = c_parser_peek_token (parser)->location;
3825 if (c_parser_next_token_is (parser, CPP_SEMICOLON))
3827 c_parser_consume_token (parser);
3828 cond = NULL_TREE;
3830 else
3832 tree ocond = c_parser_expression_conv (parser).value;
3833 cond = c_objc_common_truthvalue_conversion (ocond);
3834 if (EXPR_P (cond))
3835 SET_EXPR_LOCATION (cond, loc);
3836 c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
3838 /* Parse the increment expression. */
3839 if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
3840 incr = c_process_expr_stmt (NULL_TREE);
3841 else
3842 incr = c_process_expr_stmt (c_parser_expression (parser).value);
3843 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
3845 else
3847 cond = error_mark_node;
3848 incr = error_mark_node;
3850 save_break = c_break_label;
3851 c_break_label = NULL_TREE;
3852 save_cont = c_cont_label;
3853 c_cont_label = NULL_TREE;
3854 body = c_parser_c99_block_statement (parser);
3855 c_finish_loop (loc, cond, incr, body, c_break_label, c_cont_label, true);
3856 add_stmt (c_end_compound_stmt (block, flag_isoc99));
3857 c_break_label = save_break;
3858 c_cont_label = save_cont;
3861 /* Parse an asm statement, a GNU extension. This is a full-blown asm
3862 statement with inputs, outputs, clobbers, and volatile tag
3863 allowed.
3865 asm-statement:
3866 asm type-qualifier[opt] ( asm-argument ) ;
3868 asm-argument:
3869 asm-string-literal
3870 asm-string-literal : asm-operands[opt]
3871 asm-string-literal : asm-operands[opt] : asm-operands[opt]
3872 asm-string-literal : asm-operands[opt] : asm-operands[opt] : asm-clobbers
3874 Qualifiers other than volatile are accepted in the syntax but
3875 warned for. */
3877 static tree
3878 c_parser_asm_statement (c_parser *parser)
3880 tree quals, str, outputs, inputs, clobbers, ret;
3881 bool simple;
3882 gcc_assert (c_parser_next_token_is_keyword (parser, RID_ASM));
3883 c_parser_consume_token (parser);
3884 if (c_parser_next_token_is_keyword (parser, RID_VOLATILE))
3886 quals = c_parser_peek_token (parser)->value;
3887 c_parser_consume_token (parser);
3889 else if (c_parser_next_token_is_keyword (parser, RID_CONST)
3890 || c_parser_next_token_is_keyword (parser, RID_RESTRICT))
3892 warning (0, "%E qualifier ignored on asm",
3893 c_parser_peek_token (parser)->value);
3894 quals = NULL_TREE;
3895 c_parser_consume_token (parser);
3897 else
3898 quals = NULL_TREE;
3899 /* ??? Follow the C++ parser rather than using the
3900 c_lex_string_translate kludge. */
3901 c_lex_string_translate = 0;
3902 if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
3904 c_lex_string_translate = 1;
3905 return NULL_TREE;
3907 str = c_parser_asm_string_literal (parser);
3908 if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
3910 simple = true;
3911 outputs = NULL_TREE;
3912 inputs = NULL_TREE;
3913 clobbers = NULL_TREE;
3914 goto done_asm;
3916 if (!c_parser_require (parser, CPP_COLON, "expected %<:%> or %<)%>"))
3918 c_lex_string_translate = 1;
3919 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
3920 return NULL_TREE;
3922 simple = false;
3923 /* Parse outputs. */
3924 if (c_parser_next_token_is (parser, CPP_COLON)
3925 || c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
3926 outputs = NULL_TREE;
3927 else
3928 outputs = c_parser_asm_operands (parser, false);
3929 if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
3931 inputs = NULL_TREE;
3932 clobbers = NULL_TREE;
3933 goto done_asm;
3935 if (!c_parser_require (parser, CPP_COLON, "expected %<:%> or %<)%>"))
3937 c_lex_string_translate = 1;
3938 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
3939 return NULL_TREE;
3941 /* Parse inputs. */
3942 if (c_parser_next_token_is (parser, CPP_COLON)
3943 || c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
3944 inputs = NULL_TREE;
3945 else
3946 inputs = c_parser_asm_operands (parser, true);
3947 if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
3949 clobbers = NULL_TREE;
3950 goto done_asm;
3952 if (!c_parser_require (parser, CPP_COLON, "expected %<:%> or %<)%>"))
3954 c_lex_string_translate = 1;
3955 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
3956 return NULL_TREE;
3958 /* Parse clobbers. */
3959 clobbers = c_parser_asm_clobbers (parser);
3960 done_asm:
3961 c_lex_string_translate = 1;
3962 if (!c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
3964 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
3965 return NULL_TREE;
3967 if (!c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>"))
3968 c_parser_skip_to_end_of_block_or_statement (parser);
3969 ret = build_asm_stmt (quals, build_asm_expr (str, outputs, inputs,
3970 clobbers, simple));
3971 return ret;
3974 /* Parse asm operands, a GNU extension. If CONVERT_P (for inputs but
3975 not outputs), apply the default conversion of functions and arrays
3976 to pointers.
3978 asm-operands:
3979 asm-operand
3980 asm-operands , asm-operand
3982 asm-operand:
3983 asm-string-literal ( expression )
3984 [ identifier ] asm-string-literal ( expression )
3987 static tree
3988 c_parser_asm_operands (c_parser *parser, bool convert_p)
3990 tree list = NULL_TREE;
3991 while (true)
3993 tree name, str;
3994 struct c_expr expr;
3995 if (c_parser_next_token_is (parser, CPP_OPEN_SQUARE))
3997 c_parser_consume_token (parser);
3998 if (c_parser_next_token_is (parser, CPP_NAME))
4000 tree id = c_parser_peek_token (parser)->value;
4001 c_parser_consume_token (parser);
4002 name = build_string (IDENTIFIER_LENGTH (id),
4003 IDENTIFIER_POINTER (id));
4005 else
4007 c_parser_error (parser, "expected identifier");
4008 c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, NULL);
4009 return NULL_TREE;
4011 c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
4012 "expected %<]%>");
4014 else
4015 name = NULL_TREE;
4016 str = c_parser_asm_string_literal (parser);
4017 if (str == NULL_TREE)
4018 return NULL_TREE;
4019 c_lex_string_translate = 1;
4020 if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
4022 c_lex_string_translate = 0;
4023 return NULL_TREE;
4025 expr = c_parser_expression (parser);
4026 if (convert_p)
4027 expr = default_function_array_conversion (expr);
4028 c_lex_string_translate = 0;
4029 if (!c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
4031 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
4032 return NULL_TREE;
4034 list = chainon (list, build_tree_list (build_tree_list (name, str),
4035 expr.value));
4036 if (c_parser_next_token_is (parser, CPP_COMMA))
4037 c_parser_consume_token (parser);
4038 else
4039 break;
4041 return list;
4044 /* Parse asm clobbers, a GNU extension.
4046 asm-clobbers:
4047 asm-string-literal
4048 asm-clobbers , asm-string-literal
4051 static tree
4052 c_parser_asm_clobbers (c_parser *parser)
4054 tree list = NULL_TREE;
4055 while (true)
4057 tree str = c_parser_asm_string_literal (parser);
4058 if (str)
4059 list = tree_cons (NULL_TREE, str, list);
4060 else
4061 return NULL_TREE;
4062 if (c_parser_next_token_is (parser, CPP_COMMA))
4063 c_parser_consume_token (parser);
4064 else
4065 break;
4067 return list;
4070 /* Parse an expression other than a compound expression; that is, an
4071 assignment expression (C90 6.3.16, C99 6.5.16). If AFTER is not
4072 NULL then it is an Objective-C message expression which is the
4073 primary-expression starting the expression as an initializer.
4075 assignment-expression:
4076 conditional-expression
4077 unary-expression assignment-operator assignment-expression
4079 assignment-operator: one of
4080 = *= /= %= += -= <<= >>= &= ^= |=
4082 In GNU C we accept any conditional expression on the LHS and
4083 diagnose the invalid lvalue rather than producing a syntax
4084 error. */
4086 static struct c_expr
4087 c_parser_expr_no_commas (c_parser *parser, struct c_expr *after)
4089 struct c_expr lhs, rhs, ret;
4090 enum tree_code code;
4091 gcc_assert (!after || c_dialect_objc ());
4092 lhs = c_parser_conditional_expression (parser, after);
4093 switch (c_parser_peek_token (parser)->type)
4095 case CPP_EQ:
4096 code = NOP_EXPR;
4097 break;
4098 case CPP_MULT_EQ:
4099 code = MULT_EXPR;
4100 break;
4101 case CPP_DIV_EQ:
4102 code = TRUNC_DIV_EXPR;
4103 break;
4104 case CPP_MOD_EQ:
4105 code = TRUNC_MOD_EXPR;
4106 break;
4107 case CPP_PLUS_EQ:
4108 code = PLUS_EXPR;
4109 break;
4110 case CPP_MINUS_EQ:
4111 code = MINUS_EXPR;
4112 break;
4113 case CPP_LSHIFT_EQ:
4114 code = LSHIFT_EXPR;
4115 break;
4116 case CPP_RSHIFT_EQ:
4117 code = RSHIFT_EXPR;
4118 break;
4119 case CPP_AND_EQ:
4120 code = BIT_AND_EXPR;
4121 break;
4122 case CPP_XOR_EQ:
4123 code = BIT_XOR_EXPR;
4124 break;
4125 case CPP_OR_EQ:
4126 code = BIT_IOR_EXPR;
4127 break;
4128 default:
4129 return lhs;
4131 c_parser_consume_token (parser);
4132 rhs = c_parser_expr_no_commas (parser, NULL);
4133 rhs = default_function_array_conversion (rhs);
4134 ret.value = build_modify_expr (lhs.value, code, rhs.value);
4135 if (code == NOP_EXPR)
4136 ret.original_code = MODIFY_EXPR;
4137 else
4139 TREE_NO_WARNING (ret.value) = 1;
4140 ret.original_code = ERROR_MARK;
4142 return ret;
4145 /* Parse a conditional expression (C90 6.3.15, C99 6.5.15). If AFTER
4146 is not NULL then it is an Objective-C message expression which is
4147 the primary-expression starting the expression as an initializer.
4149 conditional-expression:
4150 logical-OR-expression
4151 logical-OR-expression ? expression : conditional-expression
4153 GNU extensions:
4155 conditional-expression:
4156 logical-OR-expression ? : conditional-expression
4159 static struct c_expr
4160 c_parser_conditional_expression (c_parser *parser, struct c_expr *after)
4162 struct c_expr cond, exp1, exp2, ret;
4163 gcc_assert (!after || c_dialect_objc ());
4164 cond = c_parser_binary_expression (parser, after);
4165 if (c_parser_next_token_is_not (parser, CPP_QUERY))
4166 return cond;
4167 cond = default_function_array_conversion (cond);
4168 c_parser_consume_token (parser);
4169 if (c_parser_next_token_is (parser, CPP_COLON))
4171 if (pedantic)
4172 pedwarn ("ISO C forbids omitting the middle term of a ?: expression");
4173 /* Make sure first operand is calculated only once. */
4174 exp1.value = save_expr (default_conversion (cond.value));
4175 cond.value = c_objc_common_truthvalue_conversion (exp1.value);
4176 skip_evaluation += cond.value == truthvalue_true_node;
4178 else
4180 cond.value
4181 = c_objc_common_truthvalue_conversion
4182 (default_conversion (cond.value));
4183 skip_evaluation += cond.value == truthvalue_false_node;
4184 exp1 = c_parser_expression_conv (parser);
4185 skip_evaluation += ((cond.value == truthvalue_true_node)
4186 - (cond.value == truthvalue_false_node));
4188 if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
4190 skip_evaluation -= cond.value == truthvalue_true_node;
4191 ret.value = error_mark_node;
4192 ret.original_code = ERROR_MARK;
4193 return ret;
4195 exp2 = c_parser_conditional_expression (parser, NULL);
4196 exp2 = default_function_array_conversion (exp2);
4197 skip_evaluation -= cond.value == truthvalue_true_node;
4198 ret.value = build_conditional_expr (cond.value, exp1.value, exp2.value);
4199 ret.original_code = ERROR_MARK;
4200 return ret;
4203 /* Parse a binary expression; that is, a logical-OR-expression (C90
4204 6.3.5-6.3.14, C99 6.5.5-6.5.14). If AFTER is not NULL then it is
4205 an Objective-C message expression which is the primary-expression
4206 starting the expression as an initializer.
4208 multiplicative-expression:
4209 cast-expression
4210 multiplicative-expression * cast-expression
4211 multiplicative-expression / cast-expression
4212 multiplicative-expression % cast-expression
4214 additive-expression:
4215 multiplicative-expression
4216 additive-expression + multiplicative-expression
4217 additive-expression - multiplicative-expression
4219 shift-expression:
4220 additive-expression
4221 shift-expression << additive-expression
4222 shift-expression >> additive-expression
4224 relational-expression:
4225 shift-expression
4226 relational-expression < shift-expression
4227 relational-expression > shift-expression
4228 relational-expression <= shift-expression
4229 relational-expression >= shift-expression
4231 equality-expression:
4232 relational-expression
4233 equality-expression == relational-expression
4234 equality-expression != relational-expression
4236 AND-expression:
4237 equality-expression
4238 AND-expression & equality-expression
4240 exclusive-OR-expression:
4241 AND-expression
4242 exclusive-OR-expression ^ AND-expression
4244 inclusive-OR-expression:
4245 exclusive-OR-expression
4246 inclusive-OR-expression | exclusive-OR-expression
4248 logical-AND-expression:
4249 inclusive-OR-expression
4250 logical-AND-expression && inclusive-OR-expression
4252 logical-OR-expression:
4253 logical-AND-expression
4254 logical-OR-expression || logical-AND-expression
4257 static struct c_expr
4258 c_parser_binary_expression (c_parser *parser, struct c_expr *after)
4260 /* A binary expression is parsed using operator-precedence parsing,
4261 with the operands being cast expressions. All the binary
4262 operators are left-associative. Thus a binary expression is of
4263 form:
4265 E0 op1 E1 op2 E2 ...
4267 which we represent on a stack. On the stack, the precedence
4268 levels are strictly increasing. When a new operator is
4269 encountered of higher precedence than that at the top of the
4270 stack, it is pushed; its LHS is the top expression, and its RHS
4271 is everything parsed until it is popped. When a new operator is
4272 encountered with precedence less than or equal to that at the top
4273 of the stack, triples E[i-1] op[i] E[i] are popped and replaced
4274 by the result of the operation until the operator at the top of
4275 the stack has lower precedence than the new operator or there is
4276 only one element on the stack; then the top expression is the LHS
4277 of the new operator. In the case of logical AND and OR
4278 expressions, we also need to adjust skip_evaluation as
4279 appropriate when the operators are pushed and popped. */
4281 /* The precedence levels, where 0 is a dummy lowest level used for
4282 the bottom of the stack. */
4283 enum prec {
4284 PREC_NONE,
4285 PREC_LOGOR,
4286 PREC_LOGAND,
4287 PREC_BITOR,
4288 PREC_BITXOR,
4289 PREC_BITAND,
4290 PREC_EQ,
4291 PREC_REL,
4292 PREC_SHIFT,
4293 PREC_ADD,
4294 PREC_MULT,
4295 NUM_PRECS
4297 struct {
4298 /* The expression at this stack level. */
4299 struct c_expr expr;
4300 /* The precedence of the operator on its left, PREC_NONE at the
4301 bottom of the stack. */
4302 enum prec prec;
4303 /* The operation on its left. */
4304 enum tree_code op;
4305 } stack[NUM_PRECS];
4306 int sp;
4307 #define POP \
4308 do { \
4309 switch (stack[sp].op) \
4311 case TRUTH_ANDIF_EXPR: \
4312 skip_evaluation -= stack[sp - 1].expr.value == truthvalue_false_node; \
4313 break; \
4314 case TRUTH_ORIF_EXPR: \
4315 skip_evaluation -= stack[sp - 1].expr.value == truthvalue_true_node; \
4316 break; \
4317 default: \
4318 break; \
4320 stack[sp - 1].expr \
4321 = default_function_array_conversion (stack[sp - 1].expr); \
4322 stack[sp].expr \
4323 = default_function_array_conversion (stack[sp].expr); \
4324 stack[sp - 1].expr = parser_build_binary_op (stack[sp].op, \
4325 stack[sp - 1].expr, \
4326 stack[sp].expr); \
4327 sp--; \
4328 } while (0)
4329 gcc_assert (!after || c_dialect_objc ());
4330 stack[0].expr = c_parser_cast_expression (parser, after);
4331 stack[0].prec = PREC_NONE;
4332 sp = 0;
4333 while (true)
4335 enum prec oprec;
4336 enum tree_code ocode;
4337 if (parser->error)
4338 goto out;
4339 switch (c_parser_peek_token (parser)->type)
4341 case CPP_MULT:
4342 oprec = PREC_MULT;
4343 ocode = MULT_EXPR;
4344 break;
4345 case CPP_DIV:
4346 oprec = PREC_MULT;
4347 ocode = TRUNC_DIV_EXPR;
4348 break;
4349 case CPP_MOD:
4350 oprec = PREC_MULT;
4351 ocode = TRUNC_MOD_EXPR;
4352 break;
4353 case CPP_PLUS:
4354 oprec = PREC_ADD;
4355 ocode = PLUS_EXPR;
4356 break;
4357 case CPP_MINUS:
4358 oprec = PREC_ADD;
4359 ocode = MINUS_EXPR;
4360 break;
4361 case CPP_LSHIFT:
4362 oprec = PREC_SHIFT;
4363 ocode = LSHIFT_EXPR;
4364 break;
4365 case CPP_RSHIFT:
4366 oprec = PREC_SHIFT;
4367 ocode = RSHIFT_EXPR;
4368 break;
4369 case CPP_LESS:
4370 oprec = PREC_REL;
4371 ocode = LT_EXPR;
4372 break;
4373 case CPP_GREATER:
4374 oprec = PREC_REL;
4375 ocode = GT_EXPR;
4376 break;
4377 case CPP_LESS_EQ:
4378 oprec = PREC_REL;
4379 ocode = LE_EXPR;
4380 break;
4381 case CPP_GREATER_EQ:
4382 oprec = PREC_REL;
4383 ocode = GE_EXPR;
4384 break;
4385 case CPP_EQ_EQ:
4386 oprec = PREC_EQ;
4387 ocode = EQ_EXPR;
4388 break;
4389 case CPP_NOT_EQ:
4390 oprec = PREC_EQ;
4391 ocode = NE_EXPR;
4392 break;
4393 case CPP_AND:
4394 oprec = PREC_BITAND;
4395 ocode = BIT_AND_EXPR;
4396 break;
4397 case CPP_XOR:
4398 oprec = PREC_BITXOR;
4399 ocode = BIT_XOR_EXPR;
4400 break;
4401 case CPP_OR:
4402 oprec = PREC_BITOR;
4403 ocode = BIT_IOR_EXPR;
4404 break;
4405 case CPP_AND_AND:
4406 oprec = PREC_LOGAND;
4407 ocode = TRUTH_ANDIF_EXPR;
4408 break;
4409 case CPP_OR_OR:
4410 oprec = PREC_LOGOR;
4411 ocode = TRUTH_ORIF_EXPR;
4412 break;
4413 default:
4414 /* Not a binary operator, so end of the binary
4415 expression. */
4416 goto out;
4418 c_parser_consume_token (parser);
4419 while (oprec <= stack[sp].prec)
4420 POP;
4421 switch (ocode)
4423 case TRUTH_ANDIF_EXPR:
4424 stack[sp].expr
4425 = default_function_array_conversion (stack[sp].expr);
4426 stack[sp].expr.value = c_objc_common_truthvalue_conversion
4427 (default_conversion (stack[sp].expr.value));
4428 skip_evaluation += stack[sp].expr.value == truthvalue_false_node;
4429 break;
4430 case TRUTH_ORIF_EXPR:
4431 stack[sp].expr
4432 = default_function_array_conversion (stack[sp].expr);
4433 stack[sp].expr.value = c_objc_common_truthvalue_conversion
4434 (default_conversion (stack[sp].expr.value));
4435 skip_evaluation += stack[sp].expr.value == truthvalue_true_node;
4436 break;
4437 default:
4438 break;
4440 sp++;
4441 stack[sp].expr = c_parser_cast_expression (parser, NULL);
4442 stack[sp].prec = oprec;
4443 stack[sp].op = ocode;
4445 out:
4446 while (sp > 0)
4447 POP;
4448 return stack[0].expr;
4449 #undef POP
4452 /* Parse a cast expression (C90 6.3.4, C99 6.5.4). If AFTER is not
4453 NULL then it is an Objective-C message expression which is the
4454 primary-expression starting the expression as an initializer.
4456 cast-expression:
4457 unary-expression
4458 ( type-name ) unary-expression
4461 static struct c_expr
4462 c_parser_cast_expression (c_parser *parser, struct c_expr *after)
4464 gcc_assert (!after || c_dialect_objc ());
4465 if (after)
4466 return c_parser_postfix_expression_after_primary (parser, *after);
4467 /* If the expression begins with a parenthesized type name, it may
4468 be either a cast or a compound literal; we need to see whether
4469 the next character is '{' to tell the difference. If not, it is
4470 an unary expression. */
4471 if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)
4472 && c_token_starts_typename (c_parser_peek_2nd_token (parser)))
4474 struct c_type_name *type_name;
4475 struct c_expr ret;
4476 struct c_expr expr;
4477 c_parser_consume_token (parser);
4478 type_name = c_parser_type_name (parser);
4479 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
4480 if (type_name == NULL)
4482 ret.value = error_mark_node;
4483 ret.original_code = ERROR_MARK;
4484 return ret;
4486 if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
4487 return c_parser_postfix_expression_after_paren_type (parser,
4488 type_name);
4489 expr = c_parser_cast_expression (parser, NULL);
4490 expr = default_function_array_conversion (expr);
4491 ret.value = c_cast_expr (type_name, expr.value);
4492 ret.original_code = ERROR_MARK;
4493 return ret;
4495 else
4496 return c_parser_unary_expression (parser);
4499 /* Parse an unary expression (C90 6.3.3, C99 6.5.3).
4501 unary-expression:
4502 postfix-expression
4503 ++ unary-expression
4504 -- unary-expression
4505 unary-operator cast-expression
4506 sizeof unary-expression
4507 sizeof ( type-name )
4509 unary-operator: one of
4510 & * + - ~ !
4512 GNU extensions:
4514 unary-expression:
4515 __alignof__ unary-expression
4516 __alignof__ ( type-name )
4517 && identifier
4519 unary-operator: one of
4520 __extension__ __real__ __imag__
4522 In addition, the GNU syntax treats ++ and -- as unary operators, so
4523 they may be applied to cast expressions with errors for non-lvalues
4524 given later. */
4526 static struct c_expr
4527 c_parser_unary_expression (c_parser *parser)
4529 int ext;
4530 struct c_expr ret, op;
4531 switch (c_parser_peek_token (parser)->type)
4533 case CPP_PLUS_PLUS:
4534 c_parser_consume_token (parser);
4535 op = c_parser_cast_expression (parser, NULL);
4536 op = default_function_array_conversion (op);
4537 return parser_build_unary_op (PREINCREMENT_EXPR, op);
4538 case CPP_MINUS_MINUS:
4539 c_parser_consume_token (parser);
4540 op = c_parser_cast_expression (parser, NULL);
4541 op = default_function_array_conversion (op);
4542 return parser_build_unary_op (PREDECREMENT_EXPR, op);
4543 case CPP_AND:
4544 c_parser_consume_token (parser);
4545 return parser_build_unary_op (ADDR_EXPR,
4546 c_parser_cast_expression (parser, NULL));
4547 case CPP_MULT:
4548 c_parser_consume_token (parser);
4549 op = c_parser_cast_expression (parser, NULL);
4550 op = default_function_array_conversion (op);
4551 ret.value = build_indirect_ref (op.value, "unary *");
4552 ret.original_code = ERROR_MARK;
4553 return ret;
4554 case CPP_PLUS:
4555 c_parser_consume_token (parser);
4556 if (!c_dialect_objc () && !in_system_header)
4557 warning (OPT_Wtraditional,
4558 "traditional C rejects the unary plus operator");
4559 op = c_parser_cast_expression (parser, NULL);
4560 op = default_function_array_conversion (op);
4561 return parser_build_unary_op (CONVERT_EXPR, op);
4562 case CPP_MINUS:
4563 c_parser_consume_token (parser);
4564 op = c_parser_cast_expression (parser, NULL);
4565 op = default_function_array_conversion (op);
4566 return parser_build_unary_op (NEGATE_EXPR, op);
4567 case CPP_COMPL:
4568 c_parser_consume_token (parser);
4569 op = c_parser_cast_expression (parser, NULL);
4570 op = default_function_array_conversion (op);
4571 return parser_build_unary_op (BIT_NOT_EXPR, op);
4572 case CPP_NOT:
4573 c_parser_consume_token (parser);
4574 op = c_parser_cast_expression (parser, NULL);
4575 op = default_function_array_conversion (op);
4576 return parser_build_unary_op (TRUTH_NOT_EXPR, op);
4577 case CPP_AND_AND:
4578 /* Refer to the address of a label as a pointer. */
4579 c_parser_consume_token (parser);
4580 if (c_parser_next_token_is (parser, CPP_NAME))
4582 ret.value = finish_label_address_expr
4583 (c_parser_peek_token (parser)->value);
4584 c_parser_consume_token (parser);
4586 else
4588 c_parser_error (parser, "expected identifier");
4589 ret.value = error_mark_node;
4591 ret.original_code = ERROR_MARK;
4592 return ret;
4593 case CPP_KEYWORD:
4594 switch (c_parser_peek_token (parser)->keyword)
4596 case RID_SIZEOF:
4597 return c_parser_sizeof_expression (parser);
4598 case RID_ALIGNOF:
4599 return c_parser_alignof_expression (parser);
4600 case RID_EXTENSION:
4601 c_parser_consume_token (parser);
4602 ext = disable_extension_diagnostics ();
4603 ret = c_parser_cast_expression (parser, NULL);
4604 restore_extension_diagnostics (ext);
4605 return ret;
4606 case RID_REALPART:
4607 c_parser_consume_token (parser);
4608 op = c_parser_cast_expression (parser, NULL);
4609 op = default_function_array_conversion (op);
4610 return parser_build_unary_op (REALPART_EXPR, op);
4611 case RID_IMAGPART:
4612 c_parser_consume_token (parser);
4613 op = c_parser_cast_expression (parser, NULL);
4614 op = default_function_array_conversion (op);
4615 return parser_build_unary_op (IMAGPART_EXPR, op);
4616 default:
4617 return c_parser_postfix_expression (parser);
4619 default:
4620 return c_parser_postfix_expression (parser);
4624 /* Parse a sizeof expression. */
4626 static struct c_expr
4627 c_parser_sizeof_expression (c_parser *parser)
4629 struct c_expr expr;
4630 gcc_assert (c_parser_next_token_is_keyword (parser, RID_SIZEOF));
4631 c_parser_consume_token (parser);
4632 skip_evaluation++;
4633 in_sizeof++;
4634 if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)
4635 && c_token_starts_typename (c_parser_peek_2nd_token (parser)))
4637 /* Either sizeof ( type-name ) or sizeof unary-expression
4638 starting with a compound literal. */
4639 struct c_type_name *type_name;
4640 c_parser_consume_token (parser);
4641 type_name = c_parser_type_name (parser);
4642 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
4643 if (type_name == NULL)
4645 struct c_expr ret;
4646 skip_evaluation--;
4647 in_sizeof--;
4648 ret.value = error_mark_node;
4649 ret.original_code = ERROR_MARK;
4650 return ret;
4652 if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
4654 expr = c_parser_postfix_expression_after_paren_type (parser,
4655 type_name);
4656 goto sizeof_expr;
4658 /* sizeof ( type-name ). */
4659 skip_evaluation--;
4660 in_sizeof--;
4661 return c_expr_sizeof_type (type_name);
4663 else
4665 expr = c_parser_unary_expression (parser);
4666 sizeof_expr:
4667 skip_evaluation--;
4668 in_sizeof--;
4669 if (TREE_CODE (expr.value) == COMPONENT_REF
4670 && DECL_C_BIT_FIELD (TREE_OPERAND (expr.value, 1)))
4671 error ("%<sizeof%> applied to a bit-field");
4672 return c_expr_sizeof_expr (expr);
4676 /* Parse an alignof expression. */
4678 static struct c_expr
4679 c_parser_alignof_expression (c_parser *parser)
4681 struct c_expr expr;
4682 gcc_assert (c_parser_next_token_is_keyword (parser, RID_ALIGNOF));
4683 c_parser_consume_token (parser);
4684 skip_evaluation++;
4685 in_alignof++;
4686 if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)
4687 && c_token_starts_typename (c_parser_peek_2nd_token (parser)))
4689 /* Either __alignof__ ( type-name ) or __alignof__
4690 unary-expression starting with a compound literal. */
4691 struct c_type_name *type_name;
4692 struct c_expr ret;
4693 c_parser_consume_token (parser);
4694 type_name = c_parser_type_name (parser);
4695 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
4696 if (type_name == NULL)
4698 struct c_expr ret;
4699 skip_evaluation--;
4700 in_alignof--;
4701 ret.value = error_mark_node;
4702 ret.original_code = ERROR_MARK;
4703 return ret;
4705 if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
4707 expr = c_parser_postfix_expression_after_paren_type (parser,
4708 type_name);
4709 goto alignof_expr;
4711 /* alignof ( type-name ). */
4712 skip_evaluation--;
4713 in_alignof--;
4714 ret.value = c_alignof (groktypename (type_name));
4715 ret.original_code = ERROR_MARK;
4716 return ret;
4718 else
4720 struct c_expr ret;
4721 expr = c_parser_unary_expression (parser);
4722 alignof_expr:
4723 skip_evaluation--;
4724 in_alignof--;
4725 ret.value = c_alignof_expr (expr.value);
4726 ret.original_code = ERROR_MARK;
4727 return ret;
4731 /* Parse a postfix expression (C90 6.3.1-6.3.2, C99 6.5.1-6.5.2).
4733 postfix-expression:
4734 primary-expression
4735 postfix-expression [ expression ]
4736 postfix-expression ( argument-expression-list[opt] )
4737 postfix-expression . identifier
4738 postfix-expression -> identifier
4739 postfix-expression ++
4740 postfix-expression --
4741 ( type-name ) { initializer-list }
4742 ( type-name ) { initializer-list , }
4744 argument-expression-list:
4745 argument-expression
4746 argument-expression-list , argument-expression
4748 primary-expression:
4749 identifier
4750 constant
4751 string-literal
4752 ( expression )
4754 GNU extensions:
4756 primary-expression:
4757 __func__
4758 (treated as a keyword in GNU C)
4759 __FUNCTION__
4760 __PRETTY_FUNCTION__
4761 ( compound-statement )
4762 __builtin_va_arg ( assignment-expression , type-name )
4763 __builtin_offsetof ( type-name , offsetof-member-designator )
4764 __builtin_choose_expr ( assignment-expression ,
4765 assignment-expression ,
4766 assignment-expression )
4767 __builtin_types_compatible_p ( type-name , type-name )
4769 offsetof-member-designator:
4770 identifier
4771 offsetof-member-designator . identifier
4772 offsetof-member-designator [ expression ]
4774 Objective-C:
4776 primary-expression:
4777 [ objc-receiver objc-message-args ]
4778 @selector ( objc-selector-arg )
4779 @protocol ( identifier )
4780 @encode ( type-name )
4781 objc-string-literal
4784 static struct c_expr
4785 c_parser_postfix_expression (c_parser *parser)
4787 struct c_expr expr, e1, e2, e3;
4788 struct c_type_name *t1, *t2;
4789 switch (c_parser_peek_token (parser)->type)
4791 case CPP_NUMBER:
4792 case CPP_CHAR:
4793 case CPP_WCHAR:
4794 expr.value = c_parser_peek_token (parser)->value;
4795 expr.original_code = ERROR_MARK;
4796 c_parser_consume_token (parser);
4797 break;
4798 case CPP_STRING:
4799 case CPP_WSTRING:
4800 expr.value = c_parser_peek_token (parser)->value;
4801 expr.original_code = STRING_CST;
4802 c_parser_consume_token (parser);
4803 break;
4804 case CPP_OBJC_STRING:
4805 gcc_assert (c_dialect_objc ());
4806 expr.value
4807 = objc_build_string_object (c_parser_peek_token (parser)->value);
4808 expr.original_code = ERROR_MARK;
4809 c_parser_consume_token (parser);
4810 break;
4811 case CPP_NAME:
4812 if (c_parser_peek_token (parser)->id_kind != C_ID_ID)
4814 c_parser_error (parser, "expected expression");
4815 expr.value = error_mark_node;
4816 expr.original_code = ERROR_MARK;
4817 break;
4820 tree id = c_parser_peek_token (parser)->value;
4821 location_t loc = c_parser_peek_token (parser)->location;
4822 c_parser_consume_token (parser);
4823 expr.value = build_external_ref (id,
4824 (c_parser_peek_token (parser)->type
4825 == CPP_OPEN_PAREN), loc);
4826 expr.original_code = ERROR_MARK;
4828 break;
4829 case CPP_OPEN_PAREN:
4830 /* A parenthesized expression, statement expression or compound
4831 literal. */
4832 if (c_parser_peek_2nd_token (parser)->type == CPP_OPEN_BRACE)
4834 /* A statement expression. */
4835 tree stmt;
4836 c_parser_consume_token (parser);
4837 c_parser_consume_token (parser);
4838 if (cur_stmt_list == NULL)
4840 error ("braced-group within expression allowed "
4841 "only inside a function");
4842 parser->error = true;
4843 c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL);
4844 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
4845 expr.value = error_mark_node;
4846 expr.original_code = ERROR_MARK;
4847 break;
4849 stmt = c_begin_stmt_expr ();
4850 c_parser_compound_statement_nostart (parser);
4851 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
4852 "expected %<)%>");
4853 if (pedantic)
4854 pedwarn ("ISO C forbids braced-groups within expressions");
4855 expr.value = c_finish_stmt_expr (stmt);
4856 expr.original_code = ERROR_MARK;
4858 else if (c_token_starts_typename (c_parser_peek_2nd_token (parser)))
4860 /* A compound literal. ??? Can we actually get here rather
4861 than going directly to
4862 c_parser_postfix_expression_after_paren_type from
4863 elsewhere? */
4864 struct c_type_name *type_name;
4865 c_parser_consume_token (parser);
4866 type_name = c_parser_type_name (parser);
4867 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
4868 "expected %<)%>");
4869 if (type_name == NULL)
4871 expr.value = error_mark_node;
4872 expr.original_code = ERROR_MARK;
4874 else
4875 expr = c_parser_postfix_expression_after_paren_type (parser,
4876 type_name);
4878 else
4880 /* A parenthesized expression. */
4881 c_parser_consume_token (parser);
4882 expr = c_parser_expression (parser);
4883 if (TREE_CODE (expr.value) == MODIFY_EXPR)
4884 TREE_NO_WARNING (expr.value) = 1;
4885 expr.original_code = ERROR_MARK;
4886 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
4887 "expected %<)%>");
4889 break;
4890 case CPP_KEYWORD:
4891 switch (c_parser_peek_token (parser)->keyword)
4893 case RID_FUNCTION_NAME:
4894 case RID_PRETTY_FUNCTION_NAME:
4895 case RID_C99_FUNCTION_NAME:
4896 expr.value = fname_decl (c_parser_peek_token (parser)->keyword,
4897 c_parser_peek_token (parser)->value);
4898 expr.original_code = ERROR_MARK;
4899 c_parser_consume_token (parser);
4900 break;
4901 case RID_VA_ARG:
4902 c_parser_consume_token (parser);
4903 if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
4905 expr.value = error_mark_node;
4906 expr.original_code = ERROR_MARK;
4907 break;
4909 e1 = c_parser_expr_no_commas (parser, NULL);
4910 if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>"))
4912 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
4913 expr.value = error_mark_node;
4914 expr.original_code = ERROR_MARK;
4915 break;
4917 t1 = c_parser_type_name (parser);
4918 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
4919 "expected %<)%>");
4920 if (t1 == NULL)
4922 expr.value = error_mark_node;
4923 expr.original_code = ERROR_MARK;
4925 else
4927 expr.value = build_va_arg (e1.value, groktypename (t1));
4928 expr.original_code = ERROR_MARK;
4930 break;
4931 case RID_OFFSETOF:
4932 c_parser_consume_token (parser);
4933 if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
4935 expr.value = error_mark_node;
4936 expr.original_code = ERROR_MARK;
4937 break;
4939 t1 = c_parser_type_name (parser);
4940 if (t1 == NULL)
4942 expr.value = error_mark_node;
4943 expr.original_code = ERROR_MARK;
4944 break;
4946 if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>"))
4948 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
4949 expr.value = error_mark_node;
4950 expr.original_code = ERROR_MARK;
4951 break;
4954 tree type = groktypename (t1);
4955 tree offsetof_ref;
4956 if (type == error_mark_node)
4957 offsetof_ref = error_mark_node;
4958 else
4959 offsetof_ref = build1 (INDIRECT_REF, type, NULL);
4960 /* Parse the second argument to __builtin_offsetof. We
4961 must have one identifier, and beyond that we want to
4962 accept sub structure and sub array references. */
4963 if (c_parser_next_token_is (parser, CPP_NAME))
4965 offsetof_ref = build_component_ref
4966 (offsetof_ref, c_parser_peek_token (parser)->value);
4967 c_parser_consume_token (parser);
4968 while (c_parser_next_token_is (parser, CPP_DOT)
4969 || c_parser_next_token_is (parser,
4970 CPP_OPEN_SQUARE))
4972 if (c_parser_next_token_is (parser, CPP_DOT))
4974 c_parser_consume_token (parser);
4975 if (c_parser_next_token_is_not (parser,
4976 CPP_NAME))
4978 c_parser_error (parser, "expected identifier");
4979 break;
4981 offsetof_ref = build_component_ref
4982 (offsetof_ref,
4983 c_parser_peek_token (parser)->value);
4984 c_parser_consume_token (parser);
4986 else
4988 tree idx;
4989 c_parser_consume_token (parser);
4990 idx = c_parser_expression (parser).value;
4991 c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
4992 "expected %<]%>");
4993 offsetof_ref = build_array_ref (offsetof_ref, idx);
4997 else
4998 c_parser_error (parser, "expected identifier");
4999 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
5000 "expected %<)%>");
5001 expr.value = fold_offsetof (offsetof_ref);
5002 expr.original_code = ERROR_MARK;
5004 break;
5005 case RID_CHOOSE_EXPR:
5006 c_parser_consume_token (parser);
5007 if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
5009 expr.value = error_mark_node;
5010 expr.original_code = ERROR_MARK;
5011 break;
5013 e1 = c_parser_expr_no_commas (parser, NULL);
5014 if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>"))
5016 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
5017 expr.value = error_mark_node;
5018 expr.original_code = ERROR_MARK;
5019 break;
5021 e2 = c_parser_expr_no_commas (parser, NULL);
5022 if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>"))
5024 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
5025 expr.value = error_mark_node;
5026 expr.original_code = ERROR_MARK;
5027 break;
5029 e3 = c_parser_expr_no_commas (parser, NULL);
5030 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
5031 "expected %<)%>");
5033 tree c;
5035 c = fold (e1.value);
5036 if (TREE_CODE (c) != INTEGER_CST)
5037 error ("first argument to %<__builtin_choose_expr%> not"
5038 " a constant");
5039 expr = integer_zerop (c) ? e3 : e2;
5041 break;
5042 case RID_TYPES_COMPATIBLE_P:
5043 c_parser_consume_token (parser);
5044 if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
5046 expr.value = error_mark_node;
5047 expr.original_code = ERROR_MARK;
5048 break;
5050 t1 = c_parser_type_name (parser);
5051 if (t1 == NULL)
5053 expr.value = error_mark_node;
5054 expr.original_code = ERROR_MARK;
5055 break;
5057 if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>"))
5059 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
5060 expr.value = error_mark_node;
5061 expr.original_code = ERROR_MARK;
5062 break;
5064 t2 = c_parser_type_name (parser);
5065 if (t2 == NULL)
5067 expr.value = error_mark_node;
5068 expr.original_code = ERROR_MARK;
5069 break;
5071 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
5072 "expected %<)%>");
5074 tree e1, e2;
5076 e1 = TYPE_MAIN_VARIANT (groktypename (t1));
5077 e2 = TYPE_MAIN_VARIANT (groktypename (t2));
5079 expr.value = comptypes (e1, e2)
5080 ? build_int_cst (NULL_TREE, 1)
5081 : build_int_cst (NULL_TREE, 0);
5082 expr.original_code = ERROR_MARK;
5084 break;
5085 case RID_AT_SELECTOR:
5086 gcc_assert (c_dialect_objc ());
5087 c_parser_consume_token (parser);
5088 if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
5090 expr.value = error_mark_node;
5091 expr.original_code = ERROR_MARK;
5092 break;
5095 tree sel = c_parser_objc_selector_arg (parser);
5096 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
5097 "expected %<)%>");
5098 expr.value = objc_build_selector_expr (sel);
5099 expr.original_code = ERROR_MARK;
5101 break;
5102 case RID_AT_PROTOCOL:
5103 gcc_assert (c_dialect_objc ());
5104 c_parser_consume_token (parser);
5105 if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
5107 expr.value = error_mark_node;
5108 expr.original_code = ERROR_MARK;
5109 break;
5111 if (c_parser_next_token_is_not (parser, CPP_NAME))
5113 c_parser_error (parser, "expected identifier");
5114 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
5115 expr.value = error_mark_node;
5116 expr.original_code = ERROR_MARK;
5117 break;
5120 tree id = c_parser_peek_token (parser)->value;
5121 c_parser_consume_token (parser);
5122 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
5123 "expected %<)%>");
5124 expr.value = objc_build_protocol_expr (id);
5125 expr.original_code = ERROR_MARK;
5127 break;
5128 case RID_AT_ENCODE:
5129 /* Extension to support C-structures in the archiver. */
5130 gcc_assert (c_dialect_objc ());
5131 c_parser_consume_token (parser);
5132 if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
5134 expr.value = error_mark_node;
5135 expr.original_code = ERROR_MARK;
5136 break;
5138 t1 = c_parser_type_name (parser);
5139 if (t1 == NULL)
5141 expr.value = error_mark_node;
5142 expr.original_code = ERROR_MARK;
5143 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
5144 break;
5146 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
5147 "expected %<)%>");
5149 tree type = groktypename (t1);
5150 expr.value = objc_build_encode_expr (type);
5151 expr.original_code = ERROR_MARK;
5153 break;
5154 default:
5155 c_parser_error (parser, "expected expression");
5156 expr.value = error_mark_node;
5157 expr.original_code = ERROR_MARK;
5158 break;
5160 break;
5161 case CPP_OPEN_SQUARE:
5162 if (c_dialect_objc ())
5164 tree receiver, args;
5165 c_parser_consume_token (parser);
5166 receiver = c_parser_objc_receiver (parser);
5167 args = c_parser_objc_message_args (parser);
5168 c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
5169 "expected %<]%>");
5170 expr.value = objc_build_message_expr (build_tree_list (receiver,
5171 args));
5172 expr.original_code = ERROR_MARK;
5173 break;
5175 /* Else fall through to report error. */
5176 default:
5177 c_parser_error (parser, "expected expression");
5178 expr.value = error_mark_node;
5179 expr.original_code = ERROR_MARK;
5180 break;
5182 return c_parser_postfix_expression_after_primary (parser, expr);
5185 /* Parse a postfix expression after a parenthesized type name: the
5186 brace-enclosed initializer of a compound literal, possibly followed
5187 by some postfix operators. This is separate because it is not
5188 possible to tell until after the type name whether a cast
5189 expression has a cast or a compound literal, or whether the operand
5190 of sizeof is a parenthesized type name or starts with a compound
5191 literal. */
5193 static struct c_expr
5194 c_parser_postfix_expression_after_paren_type (c_parser *parser,
5195 struct c_type_name *type_name)
5197 tree type;
5198 struct c_expr init;
5199 struct c_expr expr;
5200 start_init (NULL_TREE, NULL, 0);
5201 type = groktypename (type_name);
5202 if (C_TYPE_VARIABLE_SIZE (type))
5204 error ("compound literal has variable size");
5205 type = error_mark_node;
5207 init = c_parser_braced_init (parser, type, false);
5208 finish_init ();
5209 maybe_warn_string_init (type, init);
5211 if (pedantic && !flag_isoc99)
5212 pedwarn ("ISO C90 forbids compound literals");
5213 expr.value = build_compound_literal (type, init.value);
5214 expr.original_code = ERROR_MARK;
5215 return c_parser_postfix_expression_after_primary (parser, expr);
5218 /* Parse a postfix expression after the initial primary or compound
5219 literal; that is, parse a series of postfix operators. */
5221 static struct c_expr
5222 c_parser_postfix_expression_after_primary (c_parser *parser,
5223 struct c_expr expr)
5225 tree ident, idx, exprlist;
5226 while (true)
5228 switch (c_parser_peek_token (parser)->type)
5230 case CPP_OPEN_SQUARE:
5231 /* Array reference. */
5232 c_parser_consume_token (parser);
5233 idx = c_parser_expression (parser).value;
5234 c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
5235 "expected %<]%>");
5236 expr.value = build_array_ref (expr.value, idx);
5237 expr.original_code = ERROR_MARK;
5238 break;
5239 case CPP_OPEN_PAREN:
5240 /* Function call. */
5241 c_parser_consume_token (parser);
5242 if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
5243 exprlist = NULL_TREE;
5244 else
5245 exprlist = c_parser_expr_list (parser, true);
5246 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
5247 "expected %<)%>");
5248 expr.value = build_function_call (expr.value, exprlist);
5249 expr.original_code = ERROR_MARK;
5250 break;
5251 case CPP_DOT:
5252 /* Structure element reference. */
5253 c_parser_consume_token (parser);
5254 expr = default_function_array_conversion (expr);
5255 if (c_parser_next_token_is (parser, CPP_NAME))
5256 ident = c_parser_peek_token (parser)->value;
5257 else
5259 c_parser_error (parser, "expected identifier");
5260 expr.value = error_mark_node;
5261 expr.original_code = ERROR_MARK;
5262 return expr;
5264 c_parser_consume_token (parser);
5265 expr.value = build_component_ref (expr.value, ident);
5266 expr.original_code = ERROR_MARK;
5267 break;
5268 case CPP_DEREF:
5269 /* Structure element reference. */
5270 c_parser_consume_token (parser);
5271 expr = default_function_array_conversion (expr);
5272 if (c_parser_next_token_is (parser, CPP_NAME))
5273 ident = c_parser_peek_token (parser)->value;
5274 else
5276 c_parser_error (parser, "expected identifier");
5277 expr.value = error_mark_node;
5278 expr.original_code = ERROR_MARK;
5279 return expr;
5281 c_parser_consume_token (parser);
5282 expr.value = build_component_ref (build_indirect_ref (expr.value,
5283 "->"), ident);
5284 expr.original_code = ERROR_MARK;
5285 break;
5286 case CPP_PLUS_PLUS:
5287 /* Postincrement. */
5288 c_parser_consume_token (parser);
5289 expr = default_function_array_conversion (expr);
5290 expr.value = build_unary_op (POSTINCREMENT_EXPR, expr.value, 0);
5291 expr.original_code = ERROR_MARK;
5292 break;
5293 case CPP_MINUS_MINUS:
5294 /* Postdecrement. */
5295 c_parser_consume_token (parser);
5296 expr = default_function_array_conversion (expr);
5297 expr.value = build_unary_op (POSTDECREMENT_EXPR, expr.value, 0);
5298 expr.original_code = ERROR_MARK;
5299 break;
5300 default:
5301 return expr;
5306 /* Parse an expression (C90 6.3.17, C99 6.5.17).
5308 expression:
5309 assignment-expression
5310 expression , assignment-expression
5313 static struct c_expr
5314 c_parser_expression (c_parser *parser)
5316 struct c_expr expr;
5317 expr = c_parser_expr_no_commas (parser, NULL);
5318 while (c_parser_next_token_is (parser, CPP_COMMA))
5320 struct c_expr next;
5321 c_parser_consume_token (parser);
5322 next = c_parser_expr_no_commas (parser, NULL);
5323 next = default_function_array_conversion (next);
5324 expr.value = build_compound_expr (expr.value, next.value);
5325 expr.original_code = COMPOUND_EXPR;
5327 return expr;
5330 /* Parse an expression and convert functions or arrays to
5331 pointers. */
5333 static struct c_expr
5334 c_parser_expression_conv (c_parser *parser)
5336 struct c_expr expr;
5337 expr = c_parser_expression (parser);
5338 expr = default_function_array_conversion (expr);
5339 return expr;
5342 /* Parse a non-empty list of expressions. If CONVERT_P, convert
5343 functions and arrays to pointers.
5345 nonempty-expr-list:
5346 assignment-expression
5347 nonempty-expr-list , assignment-expression
5350 static tree
5351 c_parser_expr_list (c_parser *parser, bool convert_p)
5353 struct c_expr expr;
5354 tree ret, cur;
5355 expr = c_parser_expr_no_commas (parser, NULL);
5356 if (convert_p)
5357 expr = default_function_array_conversion (expr);
5358 ret = cur = build_tree_list (NULL_TREE, expr.value);
5359 while (c_parser_next_token_is (parser, CPP_COMMA))
5361 c_parser_consume_token (parser);
5362 expr = c_parser_expr_no_commas (parser, NULL);
5363 if (convert_p)
5364 expr = default_function_array_conversion (expr);
5365 cur = TREE_CHAIN (cur) = build_tree_list (NULL_TREE, expr.value);
5367 return ret;
5371 /* Parse Objective-C-specific constructs. */
5373 /* Parse an objc-class-definition.
5375 objc-class-definition:
5376 @interface identifier objc-superclass[opt] objc-protocol-refs[opt]
5377 objc-class-instance-variables[opt] objc-methodprotolist @end
5378 @implementation identifier objc-superclass[opt]
5379 objc-class-instance-variables[opt]
5380 @interface identifier ( identifier ) objc-protocol-refs[opt]
5381 objc-methodprotolist @end
5382 @implementation identifier ( identifier )
5384 objc-superclass:
5385 : identifier
5387 "@interface identifier (" must start "@interface identifier (
5388 identifier ) ...": objc-methodprotolist in the first production may
5389 not start with a parenthesized identifier as a declarator of a data
5390 definition with no declaration specifiers if the objc-superclass,
5391 objc-protocol-refs and objc-class-instance-variables are omitted. */
5393 static void
5394 c_parser_objc_class_definition (c_parser *parser)
5396 bool iface_p;
5397 tree id1;
5398 tree superclass;
5399 if (c_parser_next_token_is_keyword (parser, RID_AT_INTERFACE))
5400 iface_p = true;
5401 else if (c_parser_next_token_is_keyword (parser, RID_AT_IMPLEMENTATION))
5402 iface_p = false;
5403 else
5404 gcc_unreachable ();
5405 c_parser_consume_token (parser);
5406 if (c_parser_next_token_is_not (parser, CPP_NAME))
5408 c_parser_error (parser, "expected identifier");
5409 return;
5411 id1 = c_parser_peek_token (parser)->value;
5412 c_parser_consume_token (parser);
5413 if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
5415 tree id2;
5416 tree proto = NULL_TREE;
5417 c_parser_consume_token (parser);
5418 if (c_parser_next_token_is_not (parser, CPP_NAME))
5420 c_parser_error (parser, "expected identifier");
5421 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
5422 return;
5424 id2 = c_parser_peek_token (parser)->value;
5425 c_parser_consume_token (parser);
5426 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
5427 if (!iface_p)
5429 objc_start_category_implementation (id1, id2);
5430 return;
5432 if (c_parser_next_token_is (parser, CPP_LESS))
5433 proto = c_parser_objc_protocol_refs (parser);
5434 objc_start_category_interface (id1, id2, proto);
5435 c_parser_objc_methodprotolist (parser);
5436 c_parser_require_keyword (parser, RID_AT_END, "expected %<@end%>");
5437 objc_finish_interface ();
5438 return;
5440 if (c_parser_next_token_is (parser, CPP_COLON))
5442 c_parser_consume_token (parser);
5443 if (c_parser_next_token_is_not (parser, CPP_NAME))
5445 c_parser_error (parser, "expected identifier");
5446 return;
5448 superclass = c_parser_peek_token (parser)->value;
5449 c_parser_consume_token (parser);
5451 else
5452 superclass = NULL_TREE;
5453 if (iface_p)
5455 tree proto = NULL_TREE;
5456 if (c_parser_next_token_is (parser, CPP_LESS))
5457 proto = c_parser_objc_protocol_refs (parser);
5458 objc_start_class_interface (id1, superclass, proto);
5460 else
5461 objc_start_class_implementation (id1, superclass);
5462 if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
5463 c_parser_objc_class_instance_variables (parser);
5464 if (iface_p)
5466 objc_continue_interface ();
5467 c_parser_objc_methodprotolist (parser);
5468 c_parser_require_keyword (parser, RID_AT_END, "expected %<@end%>");
5469 objc_finish_interface ();
5471 else
5473 objc_continue_implementation ();
5474 return;
5478 /* Parse objc-class-instance-variables.
5480 objc-class-instance-variables:
5481 { objc-instance-variable-decl-list[opt] }
5483 objc-instance-variable-decl-list:
5484 objc-visibility-spec
5485 objc-instance-variable-decl ;
5487 objc-instance-variable-decl-list objc-visibility-spec
5488 objc-instance-variable-decl-list objc-instance-variable-decl ;
5489 objc-instance-variable-decl-list ;
5491 objc-visibility-spec:
5492 @private
5493 @protected
5494 @public
5496 objc-instance-variable-decl:
5497 struct-declaration
5500 static void
5501 c_parser_objc_class_instance_variables (c_parser *parser)
5503 gcc_assert (c_parser_next_token_is (parser, CPP_OPEN_BRACE));
5504 c_parser_consume_token (parser);
5505 while (c_parser_next_token_is_not (parser, CPP_EOF))
5507 tree decls;
5508 /* Parse any stray semicolon. */
5509 if (c_parser_next_token_is (parser, CPP_SEMICOLON))
5511 if (pedantic)
5512 pedwarn ("extra semicolon in struct or union specified");
5513 c_parser_consume_token (parser);
5514 continue;
5516 /* Stop if at the end of the instance variables. */
5517 if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
5519 c_parser_consume_token (parser);
5520 break;
5522 /* Parse any objc-visibility-spec. */
5523 if (c_parser_next_token_is_keyword (parser, RID_AT_PRIVATE))
5525 c_parser_consume_token (parser);
5526 objc_set_visibility (2);
5527 continue;
5529 else if (c_parser_next_token_is_keyword (parser, RID_AT_PROTECTED))
5531 c_parser_consume_token (parser);
5532 objc_set_visibility (0);
5533 continue;
5535 else if (c_parser_next_token_is_keyword (parser, RID_AT_PUBLIC))
5537 c_parser_consume_token (parser);
5538 objc_set_visibility (1);
5539 continue;
5541 /* Parse some comma-separated declarations. */
5542 decls = c_parser_struct_declaration (parser);
5544 /* Comma-separated instance variables are chained together in
5545 reverse order; add them one by one. */
5546 tree ivar = nreverse (decls);
5547 for (; ivar; ivar = TREE_CHAIN (ivar))
5548 objc_add_instance_variable (copy_node (ivar));
5550 c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
5554 /* Parse an objc-class-declaration.
5556 objc-class-declaration:
5557 @class identifier-list ;
5560 static void
5561 c_parser_objc_class_declaration (c_parser *parser)
5563 tree list = NULL_TREE;
5564 gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_CLASS));
5565 c_parser_consume_token (parser);
5566 /* Any identifiers, including those declared as type names, are OK
5567 here. */
5568 while (true)
5570 tree id;
5571 if (c_parser_next_token_is_not (parser, CPP_NAME))
5573 c_parser_error (parser, "expected identifier");
5574 break;
5576 id = c_parser_peek_token (parser)->value;
5577 list = chainon (list, build_tree_list (NULL_TREE, id));
5578 c_parser_consume_token (parser);
5579 if (c_parser_next_token_is (parser, CPP_COMMA))
5580 c_parser_consume_token (parser);
5581 else
5582 break;
5584 c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
5585 objc_declare_class (list);
5588 /* Parse an objc-alias-declaration.
5590 objc-alias-declaration:
5591 @compatibility_alias identifier identifier ;
5594 static void
5595 c_parser_objc_alias_declaration (c_parser *parser)
5597 tree id1, id2;
5598 gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_ALIAS));
5599 c_parser_consume_token (parser);
5600 if (c_parser_next_token_is_not (parser, CPP_NAME))
5602 c_parser_error (parser, "expected identifier");
5603 c_parser_skip_until_found (parser, CPP_SEMICOLON, NULL);
5604 return;
5606 id1 = c_parser_peek_token (parser)->value;
5607 c_parser_consume_token (parser);
5608 if (c_parser_next_token_is_not (parser, CPP_NAME))
5610 c_parser_error (parser, "expected identifier");
5611 c_parser_skip_until_found (parser, CPP_SEMICOLON, NULL);
5612 return;
5614 id2 = c_parser_peek_token (parser)->value;
5615 c_parser_consume_token (parser);
5616 c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
5617 objc_declare_alias (id1, id2);
5620 /* Parse an objc-protocol-definition.
5622 objc-protocol-definition:
5623 @protocol identifier objc-protocol-refs[opt] objc-methodprotolist @end
5624 @protocol identifier-list ;
5626 "@protocol identifier ;" should be resolved as "@protocol
5627 identifier-list ;": objc-methodprotolist may not start with a
5628 semicolon in the first alternative if objc-protocol-refs are
5629 omitted. */
5631 static void
5632 c_parser_objc_protocol_definition (c_parser *parser)
5634 gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_PROTOCOL));
5635 c_parser_consume_token (parser);
5636 if (c_parser_next_token_is_not (parser, CPP_NAME))
5638 c_parser_error (parser, "expected identifier");
5639 return;
5641 if (c_parser_peek_2nd_token (parser)->type == CPP_COMMA
5642 || c_parser_peek_2nd_token (parser)->type == CPP_SEMICOLON)
5644 tree list = NULL_TREE;
5645 /* Any identifiers, including those declared as type names, are
5646 OK here. */
5647 while (true)
5649 tree id;
5650 if (c_parser_next_token_is_not (parser, CPP_NAME))
5652 c_parser_error (parser, "expected identifier");
5653 break;
5655 id = c_parser_peek_token (parser)->value;
5656 list = chainon (list, build_tree_list (NULL_TREE, id));
5657 c_parser_consume_token (parser);
5658 if (c_parser_next_token_is (parser, CPP_COMMA))
5659 c_parser_consume_token (parser);
5660 else
5661 break;
5663 c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
5664 objc_declare_protocols (list);
5666 else
5668 tree id = c_parser_peek_token (parser)->value;
5669 tree proto = NULL_TREE;
5670 c_parser_consume_token (parser);
5671 if (c_parser_next_token_is (parser, CPP_LESS))
5672 proto = c_parser_objc_protocol_refs (parser);
5673 objc_pq_context = 1;
5674 objc_start_protocol (id, proto);
5675 c_parser_objc_methodprotolist (parser);
5676 c_parser_require_keyword (parser, RID_AT_END, "expected %<@end%>");
5677 objc_pq_context = 0;
5678 objc_finish_interface ();
5682 /* Parse an objc-method-type.
5684 objc-method-type:
5689 static enum tree_code
5690 c_parser_objc_method_type (c_parser *parser)
5692 switch (c_parser_peek_token (parser)->type)
5694 case CPP_PLUS:
5695 c_parser_consume_token (parser);
5696 return PLUS_EXPR;
5697 case CPP_MINUS:
5698 c_parser_consume_token (parser);
5699 return MINUS_EXPR;
5700 default:
5701 gcc_unreachable ();
5705 /* Parse an objc-method-definition.
5707 objc-method-definition:
5708 objc-method-type objc-method-decl ;[opt] compound-statement
5711 static void
5712 c_parser_objc_method_definition (c_parser *parser)
5714 enum tree_code type = c_parser_objc_method_type (parser);
5715 tree decl;
5716 objc_set_method_type (type);
5717 objc_pq_context = 1;
5718 decl = c_parser_objc_method_decl (parser);
5719 if (c_parser_next_token_is (parser, CPP_SEMICOLON))
5721 c_parser_consume_token (parser);
5722 if (pedantic)
5723 pedwarn ("extra semicolon in method definition specified");
5725 objc_pq_context = 0;
5726 objc_start_method_definition (decl);
5727 add_stmt (c_parser_compound_statement (parser));
5728 objc_finish_method_definition (current_function_decl);
5731 /* Parse an objc-methodprotolist.
5733 objc-methodprotolist:
5734 empty
5735 objc-methodprotolist objc-methodproto
5736 objc-methodprotolist declaration
5737 objc-methodprotolist ;
5739 The declaration is a data definition, which may be missing
5740 declaration specifiers under the same rules and diagnostics as
5741 other data definitions outside functions, and the stray semicolon
5742 is diagnosed the same way as a stray semicolon outside a
5743 function. */
5745 static void
5746 c_parser_objc_methodprotolist (c_parser *parser)
5748 while (true)
5750 /* The list is terminated by @end. */
5751 switch (c_parser_peek_token (parser)->type)
5753 case CPP_SEMICOLON:
5754 if (pedantic)
5755 pedwarn ("ISO C does not allow extra %<;%> outside of a function");
5756 c_parser_consume_token (parser);
5757 break;
5758 case CPP_PLUS:
5759 case CPP_MINUS:
5760 c_parser_objc_methodproto (parser);
5761 break;
5762 case CPP_EOF:
5763 return;
5764 default:
5765 if (c_parser_next_token_is_keyword (parser, RID_AT_END))
5766 return;
5767 c_parser_declaration_or_fndef (parser, false, true, false, true);
5768 break;
5773 /* Parse an objc-methodproto.
5775 objc-methodproto:
5776 objc-method-type objc-method-decl ;
5779 static void
5780 c_parser_objc_methodproto (c_parser *parser)
5782 enum tree_code type = c_parser_objc_method_type (parser);
5783 tree decl;
5784 objc_set_method_type (type);
5785 /* Remember protocol qualifiers in prototypes. */
5786 objc_pq_context = 1;
5787 decl = c_parser_objc_method_decl (parser);
5788 /* Forget protocol qualifiers here. */
5789 objc_pq_context = 0;
5790 objc_add_method_declaration (decl);
5791 c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
5794 /* Parse an objc-method-decl.
5796 objc-method-decl:
5797 ( objc-type-name ) objc-selector
5798 objc-selector
5799 ( objc-type-name ) objc-keyword-selector objc-optparmlist
5800 objc-keyword-selector objc-optparmlist
5802 objc-keyword-selector:
5803 objc-keyword-decl
5804 objc-keyword-selector objc-keyword-decl
5806 objc-keyword-decl:
5807 objc-selector : ( objc-type-name ) identifier
5808 objc-selector : identifier
5809 : ( objc-type-name ) identifier
5810 : identifier
5812 objc-optparmlist:
5813 objc-optparms objc-optellipsis
5815 objc-optparms:
5816 empty
5817 objc-opt-parms , parameter-declaration
5819 objc-optellipsis:
5820 empty
5821 , ...
5824 static tree
5825 c_parser_objc_method_decl (c_parser *parser)
5827 tree type = NULL_TREE;
5828 tree sel;
5829 tree parms = NULL_TREE;
5830 bool ellipsis = false;
5832 if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
5834 c_parser_consume_token (parser);
5835 type = c_parser_objc_type_name (parser);
5836 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
5838 sel = c_parser_objc_selector (parser);
5839 /* If there is no selector, or a colon follows, we have an
5840 objc-keyword-selector. If there is a selector, and a colon does
5841 not follow, that selector ends the objc-method-decl. */
5842 if (!sel || c_parser_next_token_is (parser, CPP_COLON))
5844 tree tsel = sel;
5845 tree list = NULL_TREE;
5846 while (true)
5848 tree atype = NULL_TREE, id, keyworddecl;
5849 if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
5850 break;
5851 if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
5853 c_parser_consume_token (parser);
5854 atype = c_parser_objc_type_name (parser);
5855 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
5856 "expected %<)%>");
5858 if (c_parser_next_token_is_not (parser, CPP_NAME))
5860 c_parser_error (parser, "expected identifier");
5861 return error_mark_node;
5863 id = c_parser_peek_token (parser)->value;
5864 c_parser_consume_token (parser);
5865 keyworddecl = objc_build_keyword_decl (tsel, atype, id);
5866 list = chainon (list, keyworddecl);
5867 tsel = c_parser_objc_selector (parser);
5868 if (!tsel && c_parser_next_token_is_not (parser, CPP_COLON))
5869 break;
5871 /* Parse the optional parameter list. Optional Objective-C
5872 method parameters follow the C syntax, and may include '...'
5873 to denote a variable number of arguments. */
5874 parms = make_node (TREE_LIST);
5875 while (c_parser_next_token_is (parser, CPP_COMMA))
5877 struct c_parm *parm;
5878 c_parser_consume_token (parser);
5879 if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
5881 ellipsis = true;
5882 c_parser_consume_token (parser);
5883 break;
5885 parm = c_parser_parameter_declaration (parser, NULL_TREE);
5886 if (parm == NULL)
5887 break;
5888 parms = chainon (parms,
5889 build_tree_list (NULL_TREE, grokparm (parm)));
5891 sel = list;
5893 return objc_build_method_signature (type, sel, parms, ellipsis);
5896 /* Parse an objc-type-name.
5898 objc-type-name:
5899 objc-type-qualifiers[opt] type-name
5900 objc-type-qualifiers[opt]
5902 objc-type-qualifiers:
5903 objc-type-qualifier
5904 objc-type-qualifiers objc-type-qualifier
5906 objc-type-qualifier: one of
5907 in out inout bycopy byref oneway
5910 static tree
5911 c_parser_objc_type_name (c_parser *parser)
5913 tree quals = NULL_TREE;
5914 struct c_type_name *typename = NULL;
5915 tree type = NULL_TREE;
5916 while (true)
5918 c_token *token = c_parser_peek_token (parser);
5919 if (token->type == CPP_KEYWORD
5920 && (token->keyword == RID_IN
5921 || token->keyword == RID_OUT
5922 || token->keyword == RID_INOUT
5923 || token->keyword == RID_BYCOPY
5924 || token->keyword == RID_BYREF
5925 || token->keyword == RID_ONEWAY))
5927 quals = chainon (quals, build_tree_list (NULL_TREE, token->value));
5928 c_parser_consume_token (parser);
5930 else
5931 break;
5933 if (c_parser_next_token_starts_typename (parser))
5934 typename = c_parser_type_name (parser);
5935 if (typename)
5936 type = groktypename (typename);
5937 return build_tree_list (quals, type);
5940 /* Parse objc-protocol-refs.
5942 objc-protocol-refs:
5943 < identifier-list >
5946 static tree
5947 c_parser_objc_protocol_refs (c_parser *parser)
5949 tree list = NULL_TREE;
5950 gcc_assert (c_parser_next_token_is (parser, CPP_LESS));
5951 c_parser_consume_token (parser);
5952 /* Any identifiers, including those declared as type names, are OK
5953 here. */
5954 while (true)
5956 tree id;
5957 if (c_parser_next_token_is_not (parser, CPP_NAME))
5959 c_parser_error (parser, "expected identifier");
5960 break;
5962 id = c_parser_peek_token (parser)->value;
5963 list = chainon (list, build_tree_list (NULL_TREE, id));
5964 c_parser_consume_token (parser);
5965 if (c_parser_next_token_is (parser, CPP_COMMA))
5966 c_parser_consume_token (parser);
5967 else
5968 break;
5970 c_parser_require (parser, CPP_GREATER, "expected %<>%>");
5971 return list;
5974 /* Parse an objc-try-catch-statement.
5976 objc-try-catch-statement:
5977 @try compound-statement objc-catch-list[opt]
5978 @try compound-statement objc-catch-list[opt] @finally compound-statement
5980 objc-catch-list:
5981 @catch ( parameter-declaration ) compound-statement
5982 objc-catch-list @catch ( parameter-declaration ) compound-statement
5985 static void
5986 c_parser_objc_try_catch_statement (c_parser *parser)
5988 location_t loc;
5989 tree stmt;
5990 gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_TRY));
5991 c_parser_consume_token (parser);
5992 loc = c_parser_peek_token (parser)->location;
5993 stmt = c_parser_compound_statement (parser);
5994 objc_begin_try_stmt (loc, stmt);
5995 while (c_parser_next_token_is_keyword (parser, RID_AT_CATCH))
5997 struct c_parm *parm;
5998 c_parser_consume_token (parser);
5999 if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
6000 break;
6001 parm = c_parser_parameter_declaration (parser, NULL_TREE);
6002 if (parm == NULL)
6004 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
6005 break;
6007 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
6008 objc_begin_catch_clause (grokparm (parm));
6009 if (c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>"))
6010 c_parser_compound_statement_nostart (parser);
6011 objc_finish_catch_clause ();
6013 if (c_parser_next_token_is_keyword (parser, RID_AT_FINALLY))
6015 location_t finloc;
6016 tree finstmt;
6017 c_parser_consume_token (parser);
6018 finloc = c_parser_peek_token (parser)->location;
6019 finstmt = c_parser_compound_statement (parser);
6020 objc_build_finally_clause (finloc, finstmt);
6022 objc_finish_try_stmt ();
6025 /* Parse an objc-synchronized-statement.
6027 objc-synchronized-statement:
6028 @synchronized ( expression ) compound-statement
6031 static void
6032 c_parser_objc_synchronized_statement (c_parser *parser)
6034 location_t loc;
6035 tree expr, stmt;
6036 gcc_assert (c_parser_next_token_is_keyword (parser, RID_AT_SYNCHRONIZED));
6037 c_parser_consume_token (parser);
6038 loc = c_parser_peek_token (parser)->location;
6039 if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
6041 expr = c_parser_expression (parser).value;
6042 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
6044 else
6045 expr = error_mark_node;
6046 stmt = c_parser_compound_statement (parser);
6047 objc_build_synchronized (loc, expr, stmt);
6050 /* Parse an objc-selector; return NULL_TREE without an error if the
6051 next token is not an objc-selector.
6053 objc-selector:
6054 identifier
6055 one of
6056 enum struct union if else while do for switch case default
6057 break continue return goto asm sizeof typeof __alignof
6058 unsigned long const short volatile signed restrict _Complex
6059 in out inout bycopy byref oneway int char float double void _Bool
6061 ??? Why this selection of keywords but not, for example, storage
6062 class specifiers? */
6064 static tree
6065 c_parser_objc_selector (c_parser *parser)
6067 c_token *token = c_parser_peek_token (parser);
6068 tree value = token->value;
6069 if (token->type == CPP_NAME)
6071 c_parser_consume_token (parser);
6072 return value;
6074 if (token->type != CPP_KEYWORD)
6075 return NULL_TREE;
6076 switch (token->keyword)
6078 case RID_ENUM:
6079 case RID_STRUCT:
6080 case RID_UNION:
6081 case RID_IF:
6082 case RID_ELSE:
6083 case RID_WHILE:
6084 case RID_DO:
6085 case RID_FOR:
6086 case RID_SWITCH:
6087 case RID_CASE:
6088 case RID_DEFAULT:
6089 case RID_BREAK:
6090 case RID_CONTINUE:
6091 case RID_RETURN:
6092 case RID_GOTO:
6093 case RID_ASM:
6094 case RID_SIZEOF:
6095 case RID_TYPEOF:
6096 case RID_ALIGNOF:
6097 case RID_UNSIGNED:
6098 case RID_LONG:
6099 case RID_CONST:
6100 case RID_SHORT:
6101 case RID_VOLATILE:
6102 case RID_SIGNED:
6103 case RID_RESTRICT:
6104 case RID_COMPLEX:
6105 case RID_IN:
6106 case RID_OUT:
6107 case RID_INOUT:
6108 case RID_BYCOPY:
6109 case RID_BYREF:
6110 case RID_ONEWAY:
6111 case RID_INT:
6112 case RID_CHAR:
6113 case RID_FLOAT:
6114 case RID_DOUBLE:
6115 case RID_VOID:
6116 case RID_BOOL:
6117 c_parser_consume_token (parser);
6118 return value;
6119 default:
6120 return NULL_TREE;
6124 /* Parse an objc-selector-arg.
6126 objc-selector-arg:
6127 objc-selector
6128 objc-keywordname-list
6130 objc-keywordname-list:
6131 objc-keywordname
6132 objc-keywordname-list objc-keywordname
6134 objc-keywordname:
6135 objc-selector :
6139 static tree
6140 c_parser_objc_selector_arg (c_parser *parser)
6142 tree sel = c_parser_objc_selector (parser);
6143 tree list = NULL_TREE;
6144 if (sel && c_parser_next_token_is_not (parser, CPP_COLON))
6145 return sel;
6146 while (true)
6148 if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
6149 return list;
6150 list = chainon (list, build_tree_list (sel, NULL_TREE));
6151 sel = c_parser_objc_selector (parser);
6152 if (!sel && c_parser_next_token_is_not (parser, CPP_COLON))
6153 break;
6155 return list;
6158 /* Parse an objc-receiver.
6160 objc-receiver:
6161 expression
6162 class-name
6163 type-name
6166 static tree
6167 c_parser_objc_receiver (c_parser *parser)
6169 if (c_parser_peek_token (parser)->type == CPP_NAME
6170 && (c_parser_peek_token (parser)->id_kind == C_ID_TYPENAME
6171 || c_parser_peek_token (parser)->id_kind == C_ID_CLASSNAME))
6173 tree id = c_parser_peek_token (parser)->value;
6174 c_parser_consume_token (parser);
6175 return objc_get_class_reference (id);
6177 return c_parser_expression (parser).value;
6180 /* Parse objc-message-args.
6182 objc-message-args:
6183 objc-selector
6184 objc-keywordarg-list
6186 objc-keywordarg-list:
6187 objc-keywordarg
6188 objc-keywordarg-list objc-keywordarg
6190 objc-keywordarg:
6191 objc-selector : objc-keywordexpr
6192 : objc-keywordexpr
6195 static tree
6196 c_parser_objc_message_args (c_parser *parser)
6198 tree sel = c_parser_objc_selector (parser);
6199 tree list = NULL_TREE;
6200 if (sel && c_parser_next_token_is_not (parser, CPP_COLON))
6201 return sel;
6202 while (true)
6204 tree keywordexpr;
6205 if (!c_parser_require (parser, CPP_COLON, "expected %<:%>"))
6206 return list;
6207 keywordexpr = c_parser_objc_keywordexpr (parser);
6208 list = chainon (list, build_tree_list (sel, keywordexpr));
6209 sel = c_parser_objc_selector (parser);
6210 if (!sel && c_parser_next_token_is_not (parser, CPP_COLON))
6211 break;
6213 return list;
6216 /* Parse an objc-keywordexpr.
6218 objc-keywordexpr:
6219 nonempty-expr-list
6222 static tree
6223 c_parser_objc_keywordexpr (c_parser *parser)
6225 tree list = c_parser_expr_list (parser, true);
6226 if (TREE_CHAIN (list) == NULL_TREE)
6228 /* Just return the expression, remove a level of
6229 indirection. */
6230 return TREE_VALUE (list);
6232 else
6234 /* We have a comma expression, we will collapse later. */
6235 return list;
6240 /* The actual parser and external interface. ??? Does this need to be
6241 garbage-collected? */
6243 static GTY (()) c_parser *the_parser;
6245 /* Parse a single source file. */
6247 void
6248 c_parse_file (void)
6250 the_parser = c_parser_new ();
6251 c_parser_translation_unit (the_parser);
6252 the_parser = NULL;
6255 #include "gt-c-parser.h"