OSDN Git Service

4ca06fec414e22404e9133f05919c44ed66a60ac
[pf3gnuchains/gcc-fork.git] / gcc / c-parser.c
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, 2007, 2008
4    Free Software Foundation, Inc.
5
6    Parser actions based on the old Bison parser; structure somewhat
7    influenced by and fragments based on the C++ parser.
8
9 This file is part of GCC.
10
11 GCC is free software; you can redistribute it and/or modify it under
12 the terms of the GNU General Public License as published by the Free
13 Software Foundation; either version 3, or (at your option) any later
14 version.
15
16 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
17 WARRANTY; without even the implied warranty of MERCHANTABILITY or
18 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
19 for more details.
20
21 You should have received a copy of the GNU General Public License
22 along with GCC; see the file COPYING3.  If not see
23 <http://www.gnu.org/licenses/>.  */
24
25 /* TODO:
26
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.
30
31    Add testcases covering every input symbol in every state in old and
32    new parsers.
33
34    Include full syntax for GNU C, including erroneous cases accepted
35    with error messages, in syntax productions in comments.
36
37    Make more diagnostics in the front end generally take an explicit
38    location rather than implicitly using input_location.  */
39
40 #include "config.h"
41 #include "system.h"
42 #include "coretypes.h"
43 #include "tm.h"
44 #include "tree.h"
45 #include "rtl.h"
46 #include "langhooks.h"
47 #include "input.h"
48 #include "cpplib.h"
49 #include "timevar.h"
50 #include "c-pragma.h"
51 #include "c-tree.h"
52 #include "flags.h"
53 #include "output.h"
54 #include "toplev.h"
55 #include "ggc.h"
56 #include "c-common.h"
57 #include "vec.h"
58 #include "target.h"
59 #include "cgraph.h"
60
61 \f
62 /* The reserved keyword table.  */
63 struct resword
64 {
65   const char *word;
66   ENUM_BITFIELD(rid) rid : 16;
67   unsigned int disable   : 16;
68 };
69
70 /* Disable mask.  Keywords are disabled if (reswords[i].disable &
71    mask) is _true_.  */
72 #define D_C89   0x01    /* not in C89 */
73 #define D_EXT   0x02    /* GCC extension */
74 #define D_EXT89 0x04    /* GCC extension incorporated in C99 */
75 #define D_OBJC  0x08    /* Objective C only */
76
77 static const struct resword reswords[] =
78 {
79   { "_Bool",            RID_BOOL,       0 },
80   { "_Complex",         RID_COMPLEX,    0 },
81   { "_Decimal32",       RID_DFLOAT32,  D_EXT },
82   { "_Decimal64",       RID_DFLOAT64,  D_EXT },
83   { "_Decimal128",      RID_DFLOAT128, D_EXT },
84   { "_Fract",           RID_FRACT,     D_EXT },
85   { "_Accum",           RID_ACCUM,     D_EXT },
86   { "_Sat",             RID_SAT,       D_EXT },
87   { "__FUNCTION__",     RID_FUNCTION_NAME, 0 },
88   { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 },
89   { "__alignof",        RID_ALIGNOF,    0 },
90   { "__alignof__",      RID_ALIGNOF,    0 },
91   { "__asm",            RID_ASM,        0 },
92   { "__asm__",          RID_ASM,        0 },
93   { "__attribute",      RID_ATTRIBUTE,  0 },
94   { "__attribute__",    RID_ATTRIBUTE,  0 },
95   { "__builtin_choose_expr", RID_CHOOSE_EXPR, 0 },
96   { "__builtin_offsetof", RID_OFFSETOF, 0 },
97   { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P, 0 },
98   { "__builtin_va_arg", RID_VA_ARG,     0 },
99   { "__complex",        RID_COMPLEX,    0 },
100   { "__complex__",      RID_COMPLEX,    0 },
101   { "__const",          RID_CONST,      0 },
102   { "__const__",        RID_CONST,      0 },
103   { "__extension__",    RID_EXTENSION,  0 },
104   { "__func__",         RID_C99_FUNCTION_NAME, 0 },
105   { "__imag",           RID_IMAGPART,   0 },
106   { "__imag__",         RID_IMAGPART,   0 },
107   { "__inline",         RID_INLINE,     0 },
108   { "__inline__",       RID_INLINE,     0 },
109   { "__label__",        RID_LABEL,      0 },
110   { "__real",           RID_REALPART,   0 },
111   { "__real__",         RID_REALPART,   0 },
112   { "__restrict",       RID_RESTRICT,   0 },
113   { "__restrict__",     RID_RESTRICT,   0 },
114   { "__signed",         RID_SIGNED,     0 },
115   { "__signed__",       RID_SIGNED,     0 },
116   { "__thread",         RID_THREAD,     0 },
117   { "__typeof",         RID_TYPEOF,     0 },
118   { "__typeof__",       RID_TYPEOF,     0 },
119   { "__volatile",       RID_VOLATILE,   0 },
120   { "__volatile__",     RID_VOLATILE,   0 },
121   { "asm",              RID_ASM,        D_EXT },
122   { "auto",             RID_AUTO,       0 },
123   { "break",            RID_BREAK,      0 },
124   { "case",             RID_CASE,       0 },
125   { "char",             RID_CHAR,       0 },
126   { "const",            RID_CONST,      0 },
127   { "continue",         RID_CONTINUE,   0 },
128   { "default",          RID_DEFAULT,    0 },
129   { "do",               RID_DO,         0 },
130   { "double",           RID_DOUBLE,     0 },
131   { "else",             RID_ELSE,       0 },
132   { "enum",             RID_ENUM,       0 },
133   { "extern",           RID_EXTERN,     0 },
134   { "float",            RID_FLOAT,      0 },
135   { "for",              RID_FOR,        0 },
136   { "goto",             RID_GOTO,       0 },
137   { "if",               RID_IF,         0 },
138   { "inline",           RID_INLINE,     D_EXT89 },
139   { "int",              RID_INT,        0 },
140   { "long",             RID_LONG,       0 },
141   { "register",         RID_REGISTER,   0 },
142   { "restrict",         RID_RESTRICT,   D_C89 },
143   { "return",           RID_RETURN,     0 },
144   { "short",            RID_SHORT,      0 },
145   { "signed",           RID_SIGNED,     0 },
146   { "sizeof",           RID_SIZEOF,     0 },
147   { "static",           RID_STATIC,     0 },
148   { "struct",           RID_STRUCT,     0 },
149   { "switch",           RID_SWITCH,     0 },
150   { "typedef",          RID_TYPEDEF,    0 },
151   { "typeof",           RID_TYPEOF,     D_EXT },
152   { "union",            RID_UNION,      0 },
153   { "unsigned",         RID_UNSIGNED,   0 },
154   { "void",             RID_VOID,       0 },
155   { "volatile",         RID_VOLATILE,   0 },
156   { "while",            RID_WHILE,      0 },
157   /* These Objective-C keywords are recognized only immediately after
158      an '@'.  */
159   { "class",            RID_AT_CLASS,           D_OBJC },
160   { "compatibility_alias", RID_AT_ALIAS,        D_OBJC },
161   { "defs",             RID_AT_DEFS,            D_OBJC },
162   { "encode",           RID_AT_ENCODE,          D_OBJC },
163   { "end",              RID_AT_END,             D_OBJC },
164   { "implementation",   RID_AT_IMPLEMENTATION,  D_OBJC },
165   { "interface",        RID_AT_INTERFACE,       D_OBJC },
166   { "private",          RID_AT_PRIVATE,         D_OBJC },
167   { "protected",        RID_AT_PROTECTED,       D_OBJC },
168   { "protocol",         RID_AT_PROTOCOL,        D_OBJC },
169   { "public",           RID_AT_PUBLIC,          D_OBJC },
170   { "selector",         RID_AT_SELECTOR,        D_OBJC },
171   { "throw",            RID_AT_THROW,           D_OBJC },
172   { "try",              RID_AT_TRY,             D_OBJC },
173   { "catch",            RID_AT_CATCH,           D_OBJC },
174   { "finally",          RID_AT_FINALLY,         D_OBJC },
175   { "synchronized",     RID_AT_SYNCHRONIZED,    D_OBJC },
176   /* These are recognized only in protocol-qualifier context
177      (see above) */
178   { "bycopy",           RID_BYCOPY,             D_OBJC },
179   { "byref",            RID_BYREF,              D_OBJC },
180   { "in",               RID_IN,                 D_OBJC },
181   { "inout",            RID_INOUT,              D_OBJC },
182   { "oneway",           RID_ONEWAY,             D_OBJC },
183   { "out",              RID_OUT,                D_OBJC },
184 };
185 #define N_reswords (sizeof reswords / sizeof (struct resword))
186
187 /* Initialization routine for this file.  */
188
189 void
190 c_parse_init (void)
191 {
192   /* The only initialization required is of the reserved word
193      identifiers.  */
194   unsigned int i;
195   tree id;
196   int mask = (flag_isoc99 ? 0 : D_C89)
197               | (flag_no_asm ? (flag_isoc99 ? D_EXT : D_EXT|D_EXT89) : 0);
198
199   if (!c_dialect_objc ())
200      mask |= D_OBJC;
201
202   ridpointers = GGC_CNEWVEC (tree, (int) RID_MAX);
203   for (i = 0; i < N_reswords; i++)
204     {
205       /* If a keyword is disabled, do not enter it into the table
206          and so create a canonical spelling that isn't a keyword.  */
207       if (reswords[i].disable & mask)
208         continue;
209
210       id = get_identifier (reswords[i].word);
211       C_SET_RID_CODE (id, reswords[i].rid);
212       C_IS_RESERVED_WORD (id) = 1;
213       ridpointers [(int) reswords[i].rid] = id;
214     }
215 }
216 \f
217 /* The C lexer intermediates between the lexer in cpplib and c-lex.c
218    and the C parser.  Unlike the C++ lexer, the parser structure
219    stores the lexer information instead of using a separate structure.
220    Identifiers are separated into ordinary identifiers, type names,
221    keywords and some other Objective-C types of identifiers, and some
222    look-ahead is maintained.
223
224    ??? It might be a good idea to lex the whole file up front (as for
225    C++).  It would then be possible to share more of the C and C++
226    lexer code, if desired.  */
227
228 /* The following local token type is used.  */
229
230 /* A keyword.  */
231 #define CPP_KEYWORD ((enum cpp_ttype) (N_TTYPES + 1))
232
233 /* More information about the type of a CPP_NAME token.  */
234 typedef enum c_id_kind {
235   /* An ordinary identifier.  */
236   C_ID_ID,
237   /* An identifier declared as a typedef name.  */
238   C_ID_TYPENAME,
239   /* An identifier declared as an Objective-C class name.  */
240   C_ID_CLASSNAME,
241   /* Not an identifier.  */
242   C_ID_NONE
243 } c_id_kind;
244
245 /* A single C token after string literal concatenation and conversion
246    of preprocessing tokens to tokens.  */
247 typedef struct c_token GTY (())
248 {
249   /* The kind of token.  */
250   ENUM_BITFIELD (cpp_ttype) type : 8;
251   /* If this token is a CPP_NAME, this value indicates whether also
252      declared as some kind of type.  Otherwise, it is C_ID_NONE.  */
253   ENUM_BITFIELD (c_id_kind) id_kind : 8;
254   /* If this token is a keyword, this value indicates which keyword.
255      Otherwise, this value is RID_MAX.  */
256   ENUM_BITFIELD (rid) keyword : 8;
257   /* If this token is a CPP_PRAGMA, this indicates the pragma that
258      was seen.  Otherwise it is PRAGMA_NONE.  */
259   ENUM_BITFIELD (pragma_kind) pragma_kind : 7;
260   /* True if this token is from a system header.  */
261   BOOL_BITFIELD in_system_header : 1;
262   /* The value associated with this token, if any.  */
263   tree value;
264   /* The location at which this token was found.  */
265   location_t location;
266 } c_token;
267
268 /* A parser structure recording information about the state and
269    context of parsing.  Includes lexer information with up to two
270    tokens of look-ahead; more are not needed for C.  */
271 typedef struct c_parser GTY(())
272 {
273   /* The look-ahead tokens.  */
274   c_token tokens[2];
275   /* How many look-ahead tokens are available (0, 1 or 2).  */
276   short tokens_avail;
277   /* True if a syntax error is being recovered from; false otherwise.
278      c_parser_error sets this flag.  It should clear this flag when
279      enough tokens have been consumed to recover from the error.  */
280   BOOL_BITFIELD error : 1;
281   /* True if we're processing a pragma, and shouldn't automatically
282      consume CPP_PRAGMA_EOL.  */
283   BOOL_BITFIELD in_pragma : 1;
284   /* True if we're parsing the outermost block of an if statement.  */
285   BOOL_BITFIELD in_if_block : 1;
286   /* True if we want to lex an untranslated string.  */
287   BOOL_BITFIELD lex_untranslated_string : 1;
288   /* Objective-C specific parser/lexer information.  */
289   BOOL_BITFIELD objc_pq_context : 1;
290   /* The following flag is needed to contextualize Objective-C lexical
291      analysis.  In some cases (e.g., 'int NSObject;'), it is
292      undesirable to bind an identifier to an Objective-C class, even
293      if a class with that name exists.  */
294   BOOL_BITFIELD objc_need_raw_identifier : 1;
295 } c_parser;
296
297
298 /* The actual parser and external interface.  ??? Does this need to be
299    garbage-collected?  */
300
301 static GTY (()) c_parser *the_parser;
302
303
304 /* Read in and lex a single token, storing it in *TOKEN.  */
305
306 static void
307 c_lex_one_token (c_parser *parser, c_token *token)
308 {
309   timevar_push (TV_LEX);
310
311   token->type = c_lex_with_flags (&token->value, &token->location, NULL,
312                                   (parser->lex_untranslated_string
313                                    ? C_LEX_STRING_NO_TRANSLATE : 0));
314   token->id_kind = C_ID_NONE;
315   token->keyword = RID_MAX;
316   token->pragma_kind = PRAGMA_NONE;
317   token->in_system_header = in_system_header;
318
319   switch (token->type)
320     {
321     case CPP_NAME:
322       {
323         tree decl;
324
325         bool objc_force_identifier = parser->objc_need_raw_identifier;
326         if (c_dialect_objc ())
327           parser->objc_need_raw_identifier = false;
328
329         if (C_IS_RESERVED_WORD (token->value))
330           {
331             enum rid rid_code = C_RID_CODE (token->value);
332
333             if (c_dialect_objc ())
334               {
335                 if (!OBJC_IS_AT_KEYWORD (rid_code)
336                     && (!OBJC_IS_PQ_KEYWORD (rid_code)
337                         || parser->objc_pq_context))
338                   {
339                     /* Return the canonical spelling for this keyword.  */
340                     token->value = ridpointers[(int) rid_code];
341                     token->type = CPP_KEYWORD;
342                     token->keyword = rid_code;
343                     break;
344                   }
345               }
346             else
347               {
348                 /* Return the canonical spelling for this keyword.  */
349                 token->value = ridpointers[(int) rid_code];
350                 token->type = CPP_KEYWORD;
351                 token->keyword = rid_code;
352                 break;
353               }
354           }
355
356         decl = lookup_name (token->value);
357         if (decl)
358           {
359             if (TREE_CODE (decl) == TYPE_DECL)
360               {
361                 token->id_kind = C_ID_TYPENAME;
362                 break;
363               }
364           }
365         else if (c_dialect_objc ())
366           {
367             tree objc_interface_decl = objc_is_class_name (token->value);
368             /* Objective-C class names are in the same namespace as
369                variables and typedefs, and hence are shadowed by local
370                declarations.  */
371             if (objc_interface_decl
372                 && (global_bindings_p ()
373                     || (!objc_force_identifier && !decl)))
374               {
375                 token->value = objc_interface_decl;
376                 token->id_kind = C_ID_CLASSNAME;
377                 break;
378               }
379           }
380         token->id_kind = C_ID_ID;
381       }
382       break;
383     case CPP_AT_NAME:
384       /* This only happens in Objective-C; it must be a keyword.  */
385       token->type = CPP_KEYWORD;
386       token->keyword = C_RID_CODE (token->value);
387       break;
388     case CPP_COLON:
389     case CPP_COMMA:
390     case CPP_CLOSE_PAREN:
391     case CPP_SEMICOLON:
392       /* These tokens may affect the interpretation of any identifiers
393          following, if doing Objective-C.  */
394       if (c_dialect_objc ())
395         parser->objc_need_raw_identifier = false;
396       break;
397     case CPP_PRAGMA:
398       /* We smuggled the cpp_token->u.pragma value in an INTEGER_CST.  */
399       token->pragma_kind = (enum pragma_kind) TREE_INT_CST_LOW (token->value);
400       token->value = NULL;
401       break;
402     default:
403       break;
404     }
405   timevar_pop (TV_LEX);
406 }
407
408 /* Return a pointer to the next token from PARSER, reading it in if
409    necessary.  */
410
411 static inline c_token *
412 c_parser_peek_token (c_parser *parser)
413 {
414   if (parser->tokens_avail == 0)
415     {
416       c_lex_one_token (parser, &parser->tokens[0]);
417       parser->tokens_avail = 1;
418     }
419   return &parser->tokens[0];
420 }
421
422 /* Return true if the next token from PARSER has the indicated
423    TYPE.  */
424
425 static inline bool
426 c_parser_next_token_is (c_parser *parser, enum cpp_ttype type)
427 {
428   return c_parser_peek_token (parser)->type == type;
429 }
430
431 /* Return true if the next token from PARSER does not have the
432    indicated TYPE.  */
433
434 static inline bool
435 c_parser_next_token_is_not (c_parser *parser, enum cpp_ttype type)
436 {
437   return !c_parser_next_token_is (parser, type);
438 }
439
440 /* Return true if the next token from PARSER is the indicated
441    KEYWORD.  */
442
443 static inline bool
444 c_parser_next_token_is_keyword (c_parser *parser, enum rid keyword)
445 {
446   return c_parser_peek_token (parser)->keyword == keyword;
447 }
448
449 /* Return true if TOKEN can start a type name,
450    false otherwise.  */
451 static bool
452 c_token_starts_typename (c_token *token)
453 {
454   switch (token->type)
455     {
456     case CPP_NAME:
457       switch (token->id_kind)
458         {
459         case C_ID_ID:
460           return false;
461         case C_ID_TYPENAME:
462           return true;
463         case C_ID_CLASSNAME:
464           gcc_assert (c_dialect_objc ());
465           return true;
466         default:
467           gcc_unreachable ();
468         }
469     case CPP_KEYWORD:
470       switch (token->keyword)
471         {
472         case RID_UNSIGNED:
473         case RID_LONG:
474         case RID_SHORT:
475         case RID_SIGNED:
476         case RID_COMPLEX:
477         case RID_INT:
478         case RID_CHAR:
479         case RID_FLOAT:
480         case RID_DOUBLE:
481         case RID_VOID:
482         case RID_DFLOAT32:
483         case RID_DFLOAT64:
484         case RID_DFLOAT128:
485         case RID_BOOL:
486         case RID_ENUM:
487         case RID_STRUCT:
488         case RID_UNION:
489         case RID_TYPEOF:
490         case RID_CONST:
491         case RID_VOLATILE:
492         case RID_RESTRICT:
493         case RID_ATTRIBUTE:
494         case RID_FRACT:
495         case RID_ACCUM:
496         case RID_SAT:
497           return true;
498         default:
499           return false;
500         }
501     case CPP_LESS:
502       if (c_dialect_objc ())
503         return true;
504       return false;
505     default:
506       return false;
507     }
508 }
509
510 /* Return true if the next token from PARSER can start a type name,
511    false otherwise.  */
512 static inline bool
513 c_parser_next_token_starts_typename (c_parser *parser)
514 {
515   c_token *token = c_parser_peek_token (parser);
516   return c_token_starts_typename (token);
517 }
518
519 /* Return true if TOKEN can start declaration specifiers, false
520    otherwise.  */
521 static bool
522 c_token_starts_declspecs (c_token *token)
523 {
524   switch (token->type)
525     {
526     case CPP_NAME:
527       switch (token->id_kind)
528         {
529         case C_ID_ID:
530           return false;
531         case C_ID_TYPENAME:
532           return true;
533         case C_ID_CLASSNAME:
534           gcc_assert (c_dialect_objc ());
535           return true;
536         default:
537           gcc_unreachable ();
538         }
539     case CPP_KEYWORD:
540       switch (token->keyword)
541         {
542         case RID_STATIC:
543         case RID_EXTERN:
544         case RID_REGISTER:
545         case RID_TYPEDEF:
546         case RID_INLINE:
547         case RID_AUTO:
548         case RID_THREAD:
549         case RID_UNSIGNED:
550         case RID_LONG:
551         case RID_SHORT:
552         case RID_SIGNED:
553         case RID_COMPLEX:
554         case RID_INT:
555         case RID_CHAR:
556         case RID_FLOAT:
557         case RID_DOUBLE:
558         case RID_VOID:
559         case RID_DFLOAT32:
560         case RID_DFLOAT64:
561         case RID_DFLOAT128:
562         case RID_BOOL:
563         case RID_ENUM:
564         case RID_STRUCT:
565         case RID_UNION:
566         case RID_TYPEOF:
567         case RID_CONST:
568         case RID_VOLATILE:
569         case RID_RESTRICT:
570         case RID_ATTRIBUTE:
571         case RID_FRACT:
572         case RID_ACCUM:
573         case RID_SAT:
574           return true;
575         default:
576           return false;
577         }
578     case CPP_LESS:
579       if (c_dialect_objc ())
580         return true;
581       return false;
582     default:
583       return false;
584     }
585 }
586
587 /* Return true if the next token from PARSER can start declaration
588    specifiers, false otherwise.  */
589 static inline bool
590 c_parser_next_token_starts_declspecs (c_parser *parser)
591 {
592   c_token *token = c_parser_peek_token (parser);
593   return c_token_starts_declspecs (token);
594 }
595
596 /* Return a pointer to the next-but-one token from PARSER, reading it
597    in if necessary.  The next token is already read in.  */
598
599 static c_token *
600 c_parser_peek_2nd_token (c_parser *parser)
601 {
602   if (parser->tokens_avail >= 2)
603     return &parser->tokens[1];
604   gcc_assert (parser->tokens_avail == 1);
605   gcc_assert (parser->tokens[0].type != CPP_EOF);
606   gcc_assert (parser->tokens[0].type != CPP_PRAGMA_EOL);
607   c_lex_one_token (parser, &parser->tokens[1]);
608   parser->tokens_avail = 2;
609   return &parser->tokens[1];
610 }
611
612 /* Consume the next token from PARSER.  */
613
614 static void
615 c_parser_consume_token (c_parser *parser)
616 {
617   gcc_assert (parser->tokens_avail >= 1);
618   gcc_assert (parser->tokens[0].type != CPP_EOF);
619   gcc_assert (!parser->in_pragma || parser->tokens[0].type != CPP_PRAGMA_EOL);
620   gcc_assert (parser->error || parser->tokens[0].type != CPP_PRAGMA);
621   if (parser->tokens_avail == 2)
622     parser->tokens[0] = parser->tokens[1];
623   parser->tokens_avail--;
624 }
625
626 /* Expect the current token to be a #pragma.  Consume it and remember
627    that we've begun parsing a pragma.  */
628
629 static void
630 c_parser_consume_pragma (c_parser *parser)
631 {
632   gcc_assert (!parser->in_pragma);
633   gcc_assert (parser->tokens_avail >= 1);
634   gcc_assert (parser->tokens[0].type == CPP_PRAGMA);
635   if (parser->tokens_avail == 2)
636     parser->tokens[0] = parser->tokens[1];
637   parser->tokens_avail--;
638   parser->in_pragma = true;
639 }
640
641 /* Update the globals input_location and in_system_header from
642    TOKEN.  */
643 static inline void
644 c_parser_set_source_position_from_token (c_token *token)
645 {
646   if (token->type != CPP_EOF)
647     {
648       input_location = token->location;
649       in_system_header = token->in_system_header;
650     }
651 }
652
653 /* Issue a diagnostic of the form
654       FILE:LINE: MESSAGE before TOKEN
655    where TOKEN is the next token in the input stream of PARSER.
656    MESSAGE (specified by the caller) is usually of the form "expected
657    OTHER-TOKEN".
658
659    Do not issue a diagnostic if still recovering from an error.
660
661    ??? This is taken from the C++ parser, but building up messages in
662    this way is not i18n-friendly and some other approach should be
663    used.  */
664
665 static void
666 c_parser_error (c_parser *parser, const char *gmsgid)
667 {
668   c_token *token = c_parser_peek_token (parser);
669   if (parser->error)
670     return;
671   parser->error = true;
672   if (!gmsgid)
673     return;
674   /* This diagnostic makes more sense if it is tagged to the line of
675      the token we just peeked at.  */
676   c_parser_set_source_position_from_token (token);
677   c_parse_error (gmsgid,
678                  /* Because c_parse_error does not understand
679                     CPP_KEYWORD, keywords are treated like
680                     identifiers.  */
681                  (token->type == CPP_KEYWORD ? CPP_NAME : token->type),
682                  token->value);
683 }
684
685 /* If the next token is of the indicated TYPE, consume it.  Otherwise,
686    issue the error MSGID.  If MSGID is NULL then a message has already
687    been produced and no message will be produced this time.  Returns
688    true if found, false otherwise.  */
689
690 static bool
691 c_parser_require (c_parser *parser,
692                   enum cpp_ttype type,
693                   const char *msgid)
694 {
695   if (c_parser_next_token_is (parser, type))
696     {
697       c_parser_consume_token (parser);
698       return true;
699     }
700   else
701     {
702       c_parser_error (parser, msgid);
703       return false;
704     }
705 }
706
707 /* If the next token is the indicated keyword, consume it.  Otherwise,
708    issue the error MSGID.  Returns true if found, false otherwise.  */
709
710 static bool
711 c_parser_require_keyword (c_parser *parser,
712                           enum rid keyword,
713                           const char *msgid)
714 {
715   if (c_parser_next_token_is_keyword (parser, keyword))
716     {
717       c_parser_consume_token (parser);
718       return true;
719     }
720   else
721     {
722       c_parser_error (parser, msgid);
723       return false;
724     }
725 }
726
727 /* Like c_parser_require, except that tokens will be skipped until the
728    desired token is found.  An error message is still produced if the
729    next token is not as expected.  If MSGID is NULL then a message has
730    already been produced and no message will be produced this
731    time.  */
732
733 static void
734 c_parser_skip_until_found (c_parser *parser,
735                            enum cpp_ttype type,
736                            const char *msgid)
737 {
738   unsigned nesting_depth = 0;
739
740   if (c_parser_require (parser, type, msgid))
741     return;
742
743   /* Skip tokens until the desired token is found.  */
744   while (true)
745     {
746       /* Peek at the next token.  */
747       c_token *token = c_parser_peek_token (parser);
748       /* If we've reached the token we want, consume it and stop.  */
749       if (token->type == type && !nesting_depth)
750         {
751           c_parser_consume_token (parser);
752           break;
753         }
754
755       /* If we've run out of tokens, stop.  */
756       if (token->type == CPP_EOF)
757         return;
758       if (token->type == CPP_PRAGMA_EOL && parser->in_pragma)
759         return;
760       if (token->type == CPP_OPEN_BRACE
761           || token->type == CPP_OPEN_PAREN
762           || token->type == CPP_OPEN_SQUARE)
763         ++nesting_depth;
764       else if (token->type == CPP_CLOSE_BRACE
765                || token->type == CPP_CLOSE_PAREN
766                || token->type == CPP_CLOSE_SQUARE)
767         {
768           if (nesting_depth-- == 0)
769             break;
770         }
771       /* Consume this token.  */
772       c_parser_consume_token (parser);
773     }
774   parser->error = false;
775 }
776
777 /* Skip tokens until the end of a parameter is found, but do not
778    consume the comma, semicolon or closing delimiter.  */
779
780 static void
781 c_parser_skip_to_end_of_parameter (c_parser *parser)
782 {
783   unsigned nesting_depth = 0;
784
785   while (true)
786     {
787       c_token *token = c_parser_peek_token (parser);
788       if ((token->type == CPP_COMMA || token->type == CPP_SEMICOLON)
789           && !nesting_depth)
790         break;
791       /* If we've run out of tokens, stop.  */
792       if (token->type == CPP_EOF)
793         return;
794       if (token->type == CPP_PRAGMA_EOL && parser->in_pragma)
795         return;
796       if (token->type == CPP_OPEN_BRACE
797           || token->type == CPP_OPEN_PAREN
798           || token->type == CPP_OPEN_SQUARE)
799         ++nesting_depth;
800       else if (token->type == CPP_CLOSE_BRACE
801                || token->type == CPP_CLOSE_PAREN
802                || token->type == CPP_CLOSE_SQUARE)
803         {
804           if (nesting_depth-- == 0)
805             break;
806         }
807       /* Consume this token.  */
808       c_parser_consume_token (parser);
809     }
810   parser->error = false;
811 }
812
813 /* Expect to be at the end of the pragma directive and consume an
814    end of line marker.  */
815
816 static void
817 c_parser_skip_to_pragma_eol (c_parser *parser)
818 {
819   gcc_assert (parser->in_pragma);
820   parser->in_pragma = false;
821
822   if (!c_parser_require (parser, CPP_PRAGMA_EOL, "expected end of line"))
823     while (true)
824       {
825         c_token *token = c_parser_peek_token (parser);
826         if (token->type == CPP_EOF)
827           break;
828         if (token->type == CPP_PRAGMA_EOL)
829           {
830             c_parser_consume_token (parser);
831             break;
832           }
833         c_parser_consume_token (parser);
834       }
835
836   parser->error = false;
837 }
838
839 /* Skip tokens until we have consumed an entire block, or until we
840    have consumed a non-nested ';'.  */
841
842 static void
843 c_parser_skip_to_end_of_block_or_statement (c_parser *parser)
844 {
845   unsigned nesting_depth = 0;
846   bool save_error = parser->error;
847
848   while (true)
849     {
850       c_token *token;
851
852       /* Peek at the next token.  */
853       token = c_parser_peek_token (parser);
854
855       switch (token->type)
856         {
857         case CPP_EOF:
858           return;
859
860         case CPP_PRAGMA_EOL:
861           if (parser->in_pragma)
862             return;
863           break;
864
865         case CPP_SEMICOLON:
866           /* If the next token is a ';', we have reached the
867              end of the statement.  */
868           if (!nesting_depth)
869             {
870               /* Consume the ';'.  */
871               c_parser_consume_token (parser);
872               goto finished;
873             }
874           break;
875
876         case CPP_CLOSE_BRACE:
877           /* If the next token is a non-nested '}', then we have
878              reached the end of the current block.  */
879           if (nesting_depth == 0 || --nesting_depth == 0)
880             {
881               c_parser_consume_token (parser);
882               goto finished;
883             }
884           break;
885
886         case CPP_OPEN_BRACE:
887           /* If it the next token is a '{', then we are entering a new
888              block.  Consume the entire block.  */
889           ++nesting_depth;
890           break;
891
892         case CPP_PRAGMA:
893           /* If we see a pragma, consume the whole thing at once.  We
894              have some safeguards against consuming pragmas willy-nilly.
895              Normally, we'd expect to be here with parser->error set,
896              which disables these safeguards.  But it's possible to get
897              here for secondary error recovery, after parser->error has
898              been cleared.  */
899           c_parser_consume_pragma (parser);
900           c_parser_skip_to_pragma_eol (parser);
901           parser->error = save_error;
902           continue;
903
904         default:
905           break;
906         }
907
908       c_parser_consume_token (parser);
909     }
910
911  finished:
912   parser->error = false;
913 }
914
915 /* Save the warning flags which are controlled by __extension__.  */
916
917 static inline int
918 disable_extension_diagnostics (void)
919 {
920   int ret = (pedantic
921              | (warn_pointer_arith << 1)
922              | (warn_traditional << 2)
923              | (flag_iso << 3));
924   pedantic = 0;
925   warn_pointer_arith = 0;
926   warn_traditional = 0;
927   flag_iso = 0;
928   return ret;
929 }
930
931 /* Restore the warning flags which are controlled by __extension__.
932    FLAGS is the return value from disable_extension_diagnostics.  */
933
934 static inline void
935 restore_extension_diagnostics (int flags)
936 {
937   pedantic = flags & 1;
938   warn_pointer_arith = (flags >> 1) & 1;
939   warn_traditional = (flags >> 2) & 1;
940   flag_iso = (flags >> 3) & 1;
941 }
942
943 /* Possibly kinds of declarator to parse.  */
944 typedef enum c_dtr_syn {
945   /* A normal declarator with an identifier.  */
946   C_DTR_NORMAL,
947   /* An abstract declarator (maybe empty).  */
948   C_DTR_ABSTRACT,
949   /* A parameter declarator: may be either, but after a type name does
950      not redeclare a typedef name as an identifier if it can
951      alternatively be interpreted as a typedef name; see DR#009,
952      applied in C90 TC1, omitted from C99 and reapplied in C99 TC2
953      following DR#249.  For example, given a typedef T, "int T" and
954      "int *T" are valid parameter declarations redeclaring T, while
955      "int (T)" and "int * (T)" and "int (T[])" and "int (T (int))" are
956      abstract declarators rather than involving redundant parentheses;
957      the same applies with attributes inside the parentheses before
958      "T".  */
959   C_DTR_PARM
960 } c_dtr_syn;
961
962 static void c_parser_external_declaration (c_parser *);
963 static void c_parser_asm_definition (c_parser *);
964 static void c_parser_declaration_or_fndef (c_parser *, bool, bool, bool, bool);
965 static void c_parser_declspecs (c_parser *, struct c_declspecs *, bool, bool,
966                                 bool);
967 static struct c_typespec c_parser_enum_specifier (c_parser *);
968 static struct c_typespec c_parser_struct_or_union_specifier (c_parser *);
969 static tree c_parser_struct_declaration (c_parser *);
970 static struct c_typespec c_parser_typeof_specifier (c_parser *);
971 static struct c_declarator *c_parser_declarator (c_parser *, bool, c_dtr_syn,
972                                                  bool *);
973 static struct c_declarator *c_parser_direct_declarator (c_parser *, bool,
974                                                         c_dtr_syn, bool *);
975 static struct c_declarator *c_parser_direct_declarator_inner (c_parser *,
976                                                               bool,
977                                                               struct c_declarator *);
978 static struct c_arg_info *c_parser_parms_declarator (c_parser *, bool, tree);
979 static struct c_arg_info *c_parser_parms_list_declarator (c_parser *, tree);
980 static struct c_parm *c_parser_parameter_declaration (c_parser *, tree);
981 static tree c_parser_simple_asm_expr (c_parser *);
982 static tree c_parser_attributes (c_parser *);
983 static struct c_type_name *c_parser_type_name (c_parser *);
984 static struct c_expr c_parser_initializer (c_parser *);
985 static struct c_expr c_parser_braced_init (c_parser *, tree, bool);
986 static void c_parser_initelt (c_parser *);
987 static void c_parser_initval (c_parser *, struct c_expr *);
988 static tree c_parser_compound_statement (c_parser *);
989 static void c_parser_compound_statement_nostart (c_parser *);
990 static void c_parser_label (c_parser *);
991 static void c_parser_statement (c_parser *);
992 static void c_parser_statement_after_labels (c_parser *);
993 static void c_parser_if_statement (c_parser *);
994 static void c_parser_switch_statement (c_parser *);
995 static void c_parser_while_statement (c_parser *);
996 static void c_parser_do_statement (c_parser *);
997 static void c_parser_for_statement (c_parser *);
998 static tree c_parser_asm_statement (c_parser *);
999 static tree c_parser_asm_operands (c_parser *, bool);
1000 static tree c_parser_asm_clobbers (c_parser *);
1001 static struct c_expr c_parser_expr_no_commas (c_parser *, struct c_expr *);
1002 static struct c_expr c_parser_conditional_expression (c_parser *,
1003                                                       struct c_expr *);
1004 static struct c_expr c_parser_binary_expression (c_parser *, struct c_expr *);
1005 static struct c_expr c_parser_cast_expression (c_parser *, struct c_expr *);
1006 static struct c_expr c_parser_unary_expression (c_parser *);
1007 static struct c_expr c_parser_sizeof_expression (c_parser *);
1008 static struct c_expr c_parser_alignof_expression (c_parser *);
1009 static struct c_expr c_parser_postfix_expression (c_parser *);
1010 static struct c_expr c_parser_postfix_expression_after_paren_type (c_parser *,
1011                                                                    struct c_type_name *);
1012 static struct c_expr c_parser_postfix_expression_after_primary (c_parser *,
1013                                                                 struct c_expr);
1014 static struct c_expr c_parser_expression (c_parser *);
1015 static struct c_expr c_parser_expression_conv (c_parser *);
1016 static tree c_parser_expr_list (c_parser *, bool);
1017 static void c_parser_omp_construct (c_parser *);
1018 static void c_parser_omp_threadprivate (c_parser *);
1019 static void c_parser_omp_barrier (c_parser *);
1020 static void c_parser_omp_flush (c_parser *);
1021 static void c_parser_omp_taskwait (c_parser *);
1022
1023 enum pragma_context { pragma_external, pragma_stmt, pragma_compound };
1024 static bool c_parser_pragma (c_parser *, enum pragma_context);
1025
1026 /* These Objective-C parser functions are only ever called when
1027    compiling Objective-C.  */
1028 static void c_parser_objc_class_definition (c_parser *);
1029 static void c_parser_objc_class_instance_variables (c_parser *);
1030 static void c_parser_objc_class_declaration (c_parser *);
1031 static void c_parser_objc_alias_declaration (c_parser *);
1032 static void c_parser_objc_protocol_definition (c_parser *);
1033 static enum tree_code c_parser_objc_method_type (c_parser *);
1034 static void c_parser_objc_method_definition (c_parser *);
1035 static void c_parser_objc_methodprotolist (c_parser *);
1036 static void c_parser_objc_methodproto (c_parser *);
1037 static tree c_parser_objc_method_decl (c_parser *);
1038 static tree c_parser_objc_type_name (c_parser *);
1039 static tree c_parser_objc_protocol_refs (c_parser *);
1040 static void c_parser_objc_try_catch_statement (c_parser *);
1041 static void c_parser_objc_synchronized_statement (c_parser *);
1042 static tree c_parser_objc_selector (c_parser *);
1043 static tree c_parser_objc_selector_arg (c_parser *);
1044 static tree c_parser_objc_receiver (c_parser *);
1045 static tree c_parser_objc_message_args (c_parser *);
1046 static tree c_parser_objc_keywordexpr (c_parser *);
1047
1048 /* Parse a translation unit (C90 6.7, C99 6.9).
1049
1050    translation-unit:
1051      external-declarations
1052
1053    external-declarations:
1054      external-declaration
1055      external-declarations external-declaration
1056
1057    GNU extensions:
1058
1059    translation-unit:
1060      empty
1061 */
1062
1063 static void
1064 c_parser_translation_unit (c_parser *parser)
1065 {
1066   if (c_parser_next_token_is (parser, CPP_EOF))
1067     {
1068       if (pedantic)
1069         pedwarn ("%HISO C forbids an empty translation unit",
1070                  &c_parser_peek_token (parser)->location);
1071     }
1072   else
1073     {
1074       void *obstack_position = obstack_alloc (&parser_obstack, 0);
1075       do
1076         {
1077           ggc_collect ();
1078           c_parser_external_declaration (parser);
1079           obstack_free (&parser_obstack, obstack_position);
1080         }
1081       while (c_parser_next_token_is_not (parser, CPP_EOF));
1082     }
1083 }
1084
1085 /* Parse an external declaration (C90 6.7, C99 6.9).
1086
1087    external-declaration:
1088      function-definition
1089      declaration
1090
1091    GNU extensions:
1092
1093    external-declaration:
1094      asm-definition
1095      ;
1096      __extension__ external-declaration
1097
1098    Objective-C:
1099
1100    external-declaration:
1101      objc-class-definition
1102      objc-class-declaration
1103      objc-alias-declaration
1104      objc-protocol-definition
1105      objc-method-definition
1106      @end
1107 */
1108
1109 static void
1110 c_parser_external_declaration (c_parser *parser)
1111 {
1112   int ext;
1113   switch (c_parser_peek_token (parser)->type)
1114     {
1115     case CPP_KEYWORD:
1116       switch (c_parser_peek_token (parser)->keyword)
1117         {
1118         case RID_EXTENSION:
1119           ext = disable_extension_diagnostics ();
1120           c_parser_consume_token (parser);
1121           c_parser_external_declaration (parser);
1122           restore_extension_diagnostics (ext);
1123           break;
1124         case RID_ASM:
1125           c_parser_asm_definition (parser);
1126           break;
1127         case RID_AT_INTERFACE:
1128         case RID_AT_IMPLEMENTATION:
1129           gcc_assert (c_dialect_objc ());
1130           c_parser_objc_class_definition (parser);
1131           break;
1132         case RID_AT_CLASS:
1133           gcc_assert (c_dialect_objc ());
1134           c_parser_objc_class_declaration (parser);
1135           break;
1136         case RID_AT_ALIAS:
1137           gcc_assert (c_dialect_objc ());
1138           c_parser_objc_alias_declaration (parser);
1139           break;
1140         case RID_AT_PROTOCOL:
1141           gcc_assert (c_dialect_objc ());
1142           c_parser_objc_protocol_definition (parser);
1143           break;
1144         case RID_AT_END:
1145           gcc_assert (c_dialect_objc ());
1146           c_parser_consume_token (parser);
1147           objc_finish_implementation ();
1148           break;
1149         default:
1150           goto decl_or_fndef;
1151         }
1152       break;
1153     case CPP_SEMICOLON:
1154       if (pedantic)
1155         pedwarn ("%HISO C does not allow extra %<;%> outside of a function",
1156                  &c_parser_peek_token (parser)->location);
1157       c_parser_consume_token (parser);
1158       break;
1159     case CPP_PRAGMA:
1160       c_parser_pragma (parser, pragma_external);
1161       break;
1162     case CPP_PLUS:
1163     case CPP_MINUS:
1164       if (c_dialect_objc ())
1165         {
1166           c_parser_objc_method_definition (parser);
1167           break;
1168         }
1169       /* Else fall through, and yield a syntax error trying to parse
1170          as a declaration or function definition.  */
1171     default:
1172     decl_or_fndef:
1173       /* A declaration or a function definition.  We can only tell
1174          which after parsing the declaration specifiers, if any, and
1175          the first declarator.  */
1176       c_parser_declaration_or_fndef (parser, true, true, false, true);
1177       break;
1178     }
1179 }
1180
1181
1182 /* Parse a declaration or function definition (C90 6.5, 6.7.1, C99
1183    6.7, 6.9.1).  If FNDEF_OK is true, a function definition is
1184    accepted; otherwise (old-style parameter declarations) only other
1185    declarations are accepted.  If NESTED is true, we are inside a
1186    function or parsing old-style parameter declarations; any functions
1187    encountered are nested functions and declaration specifiers are
1188    required; otherwise we are at top level and functions are normal
1189    functions and declaration specifiers may be optional.  If EMPTY_OK
1190    is true, empty declarations are OK (subject to all other
1191    constraints); otherwise (old-style parameter declarations) they are
1192    diagnosed.  If START_ATTR_OK is true, the declaration specifiers
1193    may start with attributes; otherwise they may not.
1194
1195    declaration:
1196      declaration-specifiers init-declarator-list[opt] ;
1197
1198    function-definition:
1199      declaration-specifiers[opt] declarator declaration-list[opt]
1200        compound-statement
1201
1202    declaration-list:
1203      declaration
1204      declaration-list declaration
1205
1206    init-declarator-list:
1207      init-declarator
1208      init-declarator-list , init-declarator
1209
1210    init-declarator:
1211      declarator simple-asm-expr[opt] attributes[opt]
1212      declarator simple-asm-expr[opt] attributes[opt] = initializer
1213
1214    GNU extensions:
1215
1216    nested-function-definition:
1217      declaration-specifiers declarator declaration-list[opt]
1218        compound-statement
1219
1220    The simple-asm-expr and attributes are GNU extensions.
1221
1222    This function does not handle __extension__; that is handled in its
1223    callers.  ??? Following the old parser, __extension__ may start
1224    external declarations, declarations in functions and declarations
1225    at the start of "for" loops, but not old-style parameter
1226    declarations.
1227
1228    C99 requires declaration specifiers in a function definition; the
1229    absence is diagnosed through the diagnosis of implicit int.  In GNU
1230    C we also allow but diagnose declarations without declaration
1231    specifiers, but only at top level (elsewhere they conflict with
1232    other syntax).
1233    
1234    OpenMP:
1235    
1236    declaration:
1237      threadprivate-directive  */
1238
1239 static void
1240 c_parser_declaration_or_fndef (c_parser *parser, bool fndef_ok, bool empty_ok,
1241                                bool nested, bool start_attr_ok)
1242 {
1243   struct c_declspecs *specs;
1244   tree prefix_attrs;
1245   tree all_prefix_attrs;
1246   bool diagnosed_no_specs = false;
1247   location_t here = c_parser_peek_token (parser)->location;
1248
1249   specs = build_null_declspecs ();
1250   c_parser_declspecs (parser, specs, true, true, start_attr_ok);
1251   if (parser->error)
1252     {
1253       c_parser_skip_to_end_of_block_or_statement (parser);
1254       return;
1255     }
1256   if (nested && !specs->declspecs_seen_p)
1257     {
1258       c_parser_error (parser, "expected declaration specifiers");
1259       c_parser_skip_to_end_of_block_or_statement (parser);
1260       return;
1261     }
1262   finish_declspecs (specs);
1263   if (c_parser_next_token_is (parser, CPP_SEMICOLON))
1264     {
1265       if (empty_ok)
1266         shadow_tag (specs);
1267       else
1268         {
1269           shadow_tag_warned (specs, 1);
1270           pedwarn ("%Hempty declaration", &here);
1271         }
1272       c_parser_consume_token (parser);
1273       return;
1274     }
1275   pending_xref_error ();
1276   prefix_attrs = specs->attrs;
1277   all_prefix_attrs = prefix_attrs;
1278   specs->attrs = NULL_TREE;
1279   while (true)
1280     {
1281       struct c_declarator *declarator;
1282       bool dummy = false;
1283       tree fnbody;
1284       /* Declaring either one or more declarators (in which case we
1285          should diagnose if there were no declaration specifiers) or a
1286          function definition (in which case the diagnostic for
1287          implicit int suffices).  */
1288       declarator = c_parser_declarator (parser, specs->type_seen_p,
1289                                         C_DTR_NORMAL, &dummy);
1290       if (declarator == NULL)
1291         {
1292           c_parser_skip_to_end_of_block_or_statement (parser);
1293           return;
1294         }
1295       if (c_parser_next_token_is (parser, CPP_EQ)
1296           || c_parser_next_token_is (parser, CPP_COMMA)
1297           || c_parser_next_token_is (parser, CPP_SEMICOLON)
1298           || c_parser_next_token_is_keyword (parser, RID_ASM)
1299           || c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
1300         {
1301           tree asm_name = NULL_TREE;
1302           tree postfix_attrs = NULL_TREE;
1303           if (!diagnosed_no_specs && !specs->declspecs_seen_p)
1304             {
1305               diagnosed_no_specs = true;
1306               pedwarn ("%Hdata definition has no type or storage class",
1307                        &here);
1308             }
1309           /* Having seen a data definition, there cannot now be a
1310              function definition.  */
1311           fndef_ok = false;
1312           if (c_parser_next_token_is_keyword (parser, RID_ASM))
1313             asm_name = c_parser_simple_asm_expr (parser);
1314           if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
1315             postfix_attrs = c_parser_attributes (parser);
1316           if (c_parser_next_token_is (parser, CPP_EQ))
1317             {
1318               tree d;
1319               struct c_expr init;
1320               c_parser_consume_token (parser);
1321               /* The declaration of the variable is in effect while
1322                  its initializer is parsed.  */
1323               d = start_decl (declarator, specs, true,
1324                               chainon (postfix_attrs, all_prefix_attrs));
1325               if (!d)
1326                 d = error_mark_node;
1327               start_init (d, asm_name, global_bindings_p ());
1328               init = c_parser_initializer (parser);
1329               finish_init ();
1330               if (d != error_mark_node)
1331                 {
1332                   maybe_warn_string_init (TREE_TYPE (d), init);
1333                   finish_decl (d, init.value, asm_name);
1334                 }
1335             }
1336           else
1337             {
1338               tree d = start_decl (declarator, specs, false,
1339                                    chainon (postfix_attrs,
1340                                             all_prefix_attrs));
1341               if (d)
1342                 finish_decl (d, NULL_TREE, asm_name);
1343             }
1344           if (c_parser_next_token_is (parser, CPP_COMMA))
1345             {
1346               c_parser_consume_token (parser);
1347               if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
1348                 all_prefix_attrs = chainon (c_parser_attributes (parser),
1349                                             prefix_attrs);
1350               else
1351                 all_prefix_attrs = prefix_attrs;
1352               continue;
1353             }
1354           else if (c_parser_next_token_is (parser, CPP_SEMICOLON))
1355             {
1356               c_parser_consume_token (parser);
1357               return;
1358             }
1359           else
1360             {
1361               c_parser_error (parser, "expected %<,%> or %<;%>");
1362               c_parser_skip_to_end_of_block_or_statement (parser);
1363               return;
1364             }
1365         }
1366       else if (!fndef_ok)
1367         {
1368           c_parser_error (parser, "expected %<=%>, %<,%>, %<;%>, "
1369                           "%<asm%> or %<__attribute__%>");
1370           c_parser_skip_to_end_of_block_or_statement (parser);
1371           return;
1372         }
1373       /* Function definition (nested or otherwise).  */
1374       if (nested)
1375         {
1376           if (pedantic)
1377             pedwarn ("%HISO C forbids nested functions", &here);
1378           c_push_function_context ();
1379         }
1380       if (!start_function (specs, declarator, all_prefix_attrs))
1381         {
1382           /* This can appear in many cases looking nothing like a
1383              function definition, so we don't give a more specific
1384              error suggesting there was one.  */
1385           c_parser_error (parser, "expected %<=%>, %<,%>, %<;%>, %<asm%> "
1386                           "or %<__attribute__%>");
1387           if (nested)
1388             c_pop_function_context ();
1389           break;
1390         }
1391       /* Parse old-style parameter declarations.  ??? Attributes are
1392          not allowed to start declaration specifiers here because of a
1393          syntax conflict between a function declaration with attribute
1394          suffix and a function definition with an attribute prefix on
1395          first old-style parameter declaration.  Following the old
1396          parser, they are not accepted on subsequent old-style
1397          parameter declarations either.  However, there is no
1398          ambiguity after the first declaration, nor indeed on the
1399          first as long as we don't allow postfix attributes after a
1400          declarator with a nonempty identifier list in a definition;
1401          and postfix attributes have never been accepted here in
1402          function definitions either.  */
1403       while (c_parser_next_token_is_not (parser, CPP_EOF)
1404              && c_parser_next_token_is_not (parser, CPP_OPEN_BRACE))
1405         c_parser_declaration_or_fndef (parser, false, false, true, false);
1406       DECL_SOURCE_LOCATION (current_function_decl)
1407         = c_parser_peek_token (parser)->location;
1408       store_parm_decls ();
1409       fnbody = c_parser_compound_statement (parser);
1410       if (nested)
1411         {
1412           tree decl = current_function_decl;
1413           add_stmt (fnbody);
1414           finish_function ();
1415           c_pop_function_context ();
1416           add_stmt (build_stmt (DECL_EXPR, decl));
1417         }
1418       else
1419         {
1420           add_stmt (fnbody);
1421           finish_function ();
1422         }
1423       break;
1424     }
1425 }
1426
1427 /* Parse an asm-definition (asm() outside a function body).  This is a
1428    GNU extension.
1429
1430    asm-definition:
1431      simple-asm-expr ;
1432 */
1433
1434 static void
1435 c_parser_asm_definition (c_parser *parser)
1436 {
1437   tree asm_str = c_parser_simple_asm_expr (parser);
1438   if (asm_str)
1439     cgraph_add_asm_node (asm_str);
1440   c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
1441 }
1442
1443 /* Parse some declaration specifiers (possibly none) (C90 6.5, C99
1444    6.7), adding them to SPECS (which may already include some).
1445    Storage class specifiers are accepted iff SCSPEC_OK; type
1446    specifiers are accepted iff TYPESPEC_OK; attributes are accepted at
1447    the start iff START_ATTR_OK.
1448
1449    declaration-specifiers:
1450      storage-class-specifier declaration-specifiers[opt]
1451      type-specifier declaration-specifiers[opt]
1452      type-qualifier declaration-specifiers[opt]
1453      function-specifier declaration-specifiers[opt]
1454
1455    Function specifiers (inline) are from C99, and are currently
1456    handled as storage class specifiers, as is __thread.
1457
1458    C90 6.5.1, C99 6.7.1:
1459    storage-class-specifier:
1460      typedef
1461      extern
1462      static
1463      auto
1464      register
1465
1466    C99 6.7.4:
1467    function-specifier:
1468      inline
1469
1470    C90 6.5.2, C99 6.7.2:
1471    type-specifier:
1472      void
1473      char
1474      short
1475      int
1476      long
1477      float
1478      double
1479      signed
1480      unsigned
1481      _Bool
1482      _Complex
1483      [_Imaginary removed in C99 TC2]
1484      struct-or-union-specifier
1485      enum-specifier
1486      typedef-name
1487
1488    (_Bool and _Complex are new in C99.)
1489
1490    C90 6.5.3, C99 6.7.3:
1491
1492    type-qualifier:
1493      const
1494      restrict
1495      volatile
1496
1497    (restrict is new in C99.)
1498
1499    GNU extensions:
1500
1501    declaration-specifiers:
1502      attributes declaration-specifiers[opt]
1503
1504    storage-class-specifier:
1505      __thread
1506
1507    type-specifier:
1508      typeof-specifier
1509      _Decimal32
1510      _Decimal64
1511      _Decimal128
1512      _Fract
1513      _Accum
1514      _Sat
1515
1516   (_Fract, _Accum, and _Sat are new from ISO/IEC DTR 18037:
1517    http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1169.pdf)
1518
1519    Objective-C:
1520
1521    type-specifier:
1522      class-name objc-protocol-refs[opt]
1523      typedef-name objc-protocol-refs
1524      objc-protocol-refs
1525 */
1526
1527 static void
1528 c_parser_declspecs (c_parser *parser, struct c_declspecs *specs,
1529                     bool scspec_ok, bool typespec_ok, bool start_attr_ok)
1530 {
1531   bool attrs_ok = start_attr_ok;
1532   bool seen_type = specs->type_seen_p;
1533   while (c_parser_next_token_is (parser, CPP_NAME)
1534          || c_parser_next_token_is (parser, CPP_KEYWORD)
1535          || (c_dialect_objc () && c_parser_next_token_is (parser, CPP_LESS)))
1536     {
1537       struct c_typespec t;
1538       tree attrs;
1539       if (c_parser_next_token_is (parser, CPP_NAME))
1540         {
1541           tree value = c_parser_peek_token (parser)->value;
1542           c_id_kind kind = c_parser_peek_token (parser)->id_kind;
1543           /* This finishes the specifiers unless a type name is OK, it
1544              is declared as a type name and a type name hasn't yet
1545              been seen.  */
1546           if (!typespec_ok || seen_type
1547               || (kind != C_ID_TYPENAME && kind != C_ID_CLASSNAME))
1548             break;
1549           c_parser_consume_token (parser);
1550           seen_type = true;
1551           attrs_ok = true;
1552           if (kind == C_ID_TYPENAME
1553               && (!c_dialect_objc ()
1554                   || c_parser_next_token_is_not (parser, CPP_LESS)))
1555             {
1556               t.kind = ctsk_typedef;
1557               /* For a typedef name, record the meaning, not the name.
1558                  In case of 'foo foo, bar;'.  */
1559               t.spec = lookup_name (value);
1560             }
1561           else
1562             {
1563               tree proto = NULL_TREE;
1564               gcc_assert (c_dialect_objc ());
1565               t.kind = ctsk_objc;
1566               if (c_parser_next_token_is (parser, CPP_LESS))
1567                 proto = c_parser_objc_protocol_refs (parser);
1568               t.spec = objc_get_protocol_qualified_type (value, proto);
1569             }
1570           declspecs_add_type (specs, t);
1571           continue;
1572         }
1573       if (c_parser_next_token_is (parser, CPP_LESS))
1574         {
1575           /* Make "<SomeProtocol>" equivalent to "id <SomeProtocol>" -
1576              nisse@lysator.liu.se.  */
1577           tree proto;
1578           gcc_assert (c_dialect_objc ());
1579           if (!typespec_ok || seen_type)
1580             break;
1581           proto = c_parser_objc_protocol_refs (parser);
1582           t.kind = ctsk_objc;
1583           t.spec = objc_get_protocol_qualified_type (NULL_TREE, proto);
1584           declspecs_add_type (specs, t);
1585           continue;
1586         }
1587       gcc_assert (c_parser_next_token_is (parser, CPP_KEYWORD));
1588       switch (c_parser_peek_token (parser)->keyword)
1589         {
1590         case RID_STATIC:
1591         case RID_EXTERN:
1592         case RID_REGISTER:
1593         case RID_TYPEDEF:
1594         case RID_INLINE:
1595         case RID_AUTO:
1596         case RID_THREAD:
1597           if (!scspec_ok)
1598             goto out;
1599           attrs_ok = true;
1600           /* TODO: Distinguish between function specifiers (inline)
1601              and storage class specifiers, either here or in
1602              declspecs_add_scspec.  */
1603           declspecs_add_scspec (specs, c_parser_peek_token (parser)->value);
1604           c_parser_consume_token (parser);
1605           break;
1606         case RID_UNSIGNED:
1607         case RID_LONG:
1608         case RID_SHORT:
1609         case RID_SIGNED:
1610         case RID_COMPLEX:
1611         case RID_INT:
1612         case RID_CHAR:
1613         case RID_FLOAT:
1614         case RID_DOUBLE:
1615         case RID_VOID:
1616         case RID_DFLOAT32:
1617         case RID_DFLOAT64:
1618         case RID_DFLOAT128:
1619         case RID_BOOL:
1620         case RID_FRACT:
1621         case RID_ACCUM:
1622         case RID_SAT:
1623           if (!typespec_ok)
1624             goto out;
1625           attrs_ok = true;
1626           seen_type = true;
1627           if (c_dialect_objc ())
1628             parser->objc_need_raw_identifier = true;
1629           t.kind = ctsk_resword;
1630           t.spec = c_parser_peek_token (parser)->value;
1631           declspecs_add_type (specs, t);
1632           c_parser_consume_token (parser);
1633           break;
1634         case RID_ENUM:
1635           if (!typespec_ok)
1636             goto out;
1637           attrs_ok = true;
1638           seen_type = true;
1639           t = c_parser_enum_specifier (parser);
1640           declspecs_add_type (specs, t);
1641           break;
1642         case RID_STRUCT:
1643         case RID_UNION:
1644           if (!typespec_ok)
1645             goto out;
1646           attrs_ok = true;
1647           seen_type = true;
1648           t = c_parser_struct_or_union_specifier (parser);
1649           declspecs_add_type (specs, t);
1650           break;
1651         case RID_TYPEOF:
1652           /* ??? The old parser rejected typeof after other type
1653              specifiers, but is a syntax error the best way of
1654              handling this?  */
1655           if (!typespec_ok || seen_type)
1656             goto out;
1657           attrs_ok = true;
1658           seen_type = true;
1659           t = c_parser_typeof_specifier (parser);
1660           declspecs_add_type (specs, t);
1661           break;
1662         case RID_CONST:
1663         case RID_VOLATILE:
1664         case RID_RESTRICT:
1665           attrs_ok = true;
1666           declspecs_add_qual (specs, c_parser_peek_token (parser)->value);
1667           c_parser_consume_token (parser);
1668           break;
1669         case RID_ATTRIBUTE:
1670           if (!attrs_ok)
1671             goto out;
1672           attrs = c_parser_attributes (parser);
1673           declspecs_add_attrs (specs, attrs);
1674           break;
1675         default:
1676           goto out;
1677         }
1678     }
1679  out: ;
1680 }
1681
1682 /* Parse an enum specifier (C90 6.5.2.2, C99 6.7.2.2).
1683
1684    enum-specifier:
1685      enum attributes[opt] identifier[opt] { enumerator-list } attributes[opt]
1686      enum attributes[opt] identifier[opt] { enumerator-list , } attributes[opt]
1687      enum attributes[opt] identifier
1688
1689    The form with trailing comma is new in C99.  The forms with
1690    attributes are GNU extensions.  In GNU C, we accept any expression
1691    without commas in the syntax (assignment expressions, not just
1692    conditional expressions); assignment expressions will be diagnosed
1693    as non-constant.
1694
1695    enumerator-list:
1696      enumerator
1697      enumerator-list , enumerator
1698
1699    enumerator:
1700      enumeration-constant
1701      enumeration-constant = constant-expression
1702 */
1703
1704 static struct c_typespec
1705 c_parser_enum_specifier (c_parser *parser)
1706 {
1707   struct c_typespec ret;
1708   tree attrs;
1709   tree ident = NULL_TREE;
1710   location_t ident_loc;
1711   gcc_assert (c_parser_next_token_is_keyword (parser, RID_ENUM));
1712   c_parser_consume_token (parser);
1713   attrs = c_parser_attributes (parser);
1714   /* Set the location in case we create a decl now.  */
1715   c_parser_set_source_position_from_token (c_parser_peek_token (parser));
1716   if (c_parser_next_token_is (parser, CPP_NAME))
1717     {
1718       ident = c_parser_peek_token (parser)->value;
1719       ident_loc = c_parser_peek_token (parser)->location;
1720       c_parser_consume_token (parser);
1721     }
1722   if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
1723     {
1724       /* Parse an enum definition.  */
1725       struct c_enum_contents the_enum;
1726       tree type = start_enum (&the_enum, ident);
1727       tree postfix_attrs;
1728       /* We chain the enumerators in reverse order, then put them in
1729          forward order at the end.  */
1730       tree values = NULL_TREE;
1731       c_parser_consume_token (parser);
1732       while (true)
1733         {
1734           tree enum_id;
1735           tree enum_value;
1736           tree enum_decl;
1737           bool seen_comma;
1738           c_token *token;
1739           location_t comma_loc;
1740           if (c_parser_next_token_is_not (parser, CPP_NAME))
1741             {
1742               c_parser_error (parser, "expected identifier");
1743               c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL);
1744               values = error_mark_node;
1745               break;
1746             }
1747           token = c_parser_peek_token (parser);
1748           enum_id = token->value;
1749           /* Set the location in case we create a decl now.  */
1750           c_parser_set_source_position_from_token (token);
1751           c_parser_consume_token (parser);
1752           if (c_parser_next_token_is (parser, CPP_EQ))
1753             {
1754               c_parser_consume_token (parser);
1755               enum_value = c_parser_expr_no_commas (parser, NULL).value;
1756             }
1757           else
1758             enum_value = NULL_TREE;
1759           enum_decl = build_enumerator (&the_enum, enum_id, enum_value);
1760           TREE_CHAIN (enum_decl) = values;
1761           values = enum_decl;
1762           seen_comma = false;
1763           if (c_parser_next_token_is (parser, CPP_COMMA))
1764             {
1765               comma_loc = c_parser_peek_token (parser)->location;
1766               seen_comma = true;
1767               c_parser_consume_token (parser);
1768             }
1769           if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
1770             {
1771               if (seen_comma && pedantic && !flag_isoc99)
1772                 pedwarn ("%Hcomma at end of enumerator list", &comma_loc);
1773               c_parser_consume_token (parser);
1774               break;
1775             }
1776           if (!seen_comma)
1777             {
1778               c_parser_error (parser, "expected %<,%> or %<}%>");
1779               c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL);
1780               values = error_mark_node;
1781               break;
1782             }
1783         }
1784       postfix_attrs = c_parser_attributes (parser);
1785       ret.spec = finish_enum (type, nreverse (values),
1786                               chainon (attrs, postfix_attrs));
1787       ret.kind = ctsk_tagdef;
1788       return ret;
1789     }
1790   else if (!ident)
1791     {
1792       c_parser_error (parser, "expected %<{%>");
1793       ret.spec = error_mark_node;
1794       ret.kind = ctsk_tagref;
1795       return ret;
1796     }
1797   ret = parser_xref_tag (ENUMERAL_TYPE, ident);
1798   /* In ISO C, enumerated types can be referred to only if already
1799      defined.  */
1800   if (pedantic && !COMPLETE_TYPE_P (ret.spec))
1801     {
1802       gcc_assert (ident);
1803       pedwarn ("%HISO C forbids forward references to %<enum%> types",
1804                &ident_loc);
1805     }
1806   return ret;
1807 }
1808
1809 /* Parse a struct or union specifier (C90 6.5.2.1, C99 6.7.2.1).
1810
1811    struct-or-union-specifier:
1812      struct-or-union attributes[opt] identifier[opt]
1813        { struct-contents } attributes[opt]
1814      struct-or-union attributes[opt] identifier
1815
1816    struct-contents:
1817      struct-declaration-list
1818
1819    struct-declaration-list:
1820      struct-declaration ;
1821      struct-declaration-list struct-declaration ;
1822
1823    GNU extensions:
1824
1825    struct-contents:
1826      empty
1827      struct-declaration
1828      struct-declaration-list struct-declaration
1829
1830    struct-declaration-list:
1831      struct-declaration-list ;
1832      ;
1833
1834    (Note that in the syntax here, unlike that in ISO C, the semicolons
1835    are included here rather than in struct-declaration, in order to
1836    describe the syntax with extra semicolons and missing semicolon at
1837    end.)
1838
1839    Objective-C:
1840
1841    struct-declaration-list:
1842      @defs ( class-name )
1843
1844    (Note this does not include a trailing semicolon, but can be
1845    followed by further declarations, and gets a pedwarn-if-pedantic
1846    when followed by a semicolon.)  */
1847
1848 static struct c_typespec
1849 c_parser_struct_or_union_specifier (c_parser *parser)
1850 {
1851   struct c_typespec ret;
1852   tree attrs;
1853   tree ident = NULL_TREE;
1854   enum tree_code code;
1855   switch (c_parser_peek_token (parser)->keyword)
1856     {
1857     case RID_STRUCT:
1858       code = RECORD_TYPE;
1859       break;
1860     case RID_UNION:
1861       code = UNION_TYPE;
1862       break;
1863     default:
1864       gcc_unreachable ();
1865     }
1866   c_parser_consume_token (parser);
1867   attrs = c_parser_attributes (parser);
1868   /* Set the location in case we create a decl now.  */
1869   c_parser_set_source_position_from_token (c_parser_peek_token (parser));
1870   if (c_parser_next_token_is (parser, CPP_NAME))
1871     {
1872       ident = c_parser_peek_token (parser)->value;
1873       c_parser_consume_token (parser);
1874     }
1875   if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
1876     {
1877       /* Parse a struct or union definition.  Start the scope of the
1878          tag before parsing components.  */
1879       tree type = start_struct (code, ident);
1880       tree postfix_attrs;
1881       /* We chain the components in reverse order, then put them in
1882          forward order at the end.  Each struct-declaration may
1883          declare multiple components (comma-separated), so we must use
1884          chainon to join them, although when parsing each
1885          struct-declaration we can use TREE_CHAIN directly.
1886
1887          The theory behind all this is that there will be more
1888          semicolon separated fields than comma separated fields, and
1889          so we'll be minimizing the number of node traversals required
1890          by chainon.  */
1891       tree contents = NULL_TREE;
1892       c_parser_consume_token (parser);
1893       /* Handle the Objective-C @defs construct,
1894          e.g. foo(sizeof(struct{ @defs(ClassName) }));.  */
1895       if (c_parser_next_token_is_keyword (parser, RID_AT_DEFS))
1896         {
1897           tree name;
1898           gcc_assert (c_dialect_objc ());
1899           c_parser_consume_token (parser);
1900           if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
1901             goto end_at_defs;
1902           if (c_parser_next_token_is (parser, CPP_NAME)
1903               && c_parser_peek_token (parser)->id_kind == C_ID_CLASSNAME)
1904             {
1905               name = c_parser_peek_token (parser)->value;
1906               c_parser_consume_token (parser);
1907             }
1908           else
1909             {
1910               c_parser_error (parser, "expected class name");
1911               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
1912               goto end_at_defs;
1913             }
1914           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
1915                                      "expected %<)%>");
1916           contents = nreverse (objc_get_class_ivars (name));
1917         }
1918     end_at_defs:
1919       /* Parse the struct-declarations and semicolons.  Problems with
1920          semicolons are diagnosed here; empty structures are diagnosed
1921          elsewhere.  */
1922       while (true)
1923         {
1924           tree decls;
1925           /* Parse any stray semicolon.  */
1926           if (c_parser_next_token_is (parser, CPP_SEMICOLON))
1927             {
1928               if (pedantic)
1929                 pedwarn ("%Hextra semicolon in struct or union specified",
1930                          &c_parser_peek_token (parser)->location);
1931               c_parser_consume_token (parser);
1932               continue;
1933             }
1934           /* Stop if at the end of the struct or union contents.  */
1935           if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
1936             {
1937               c_parser_consume_token (parser);
1938               break;
1939             }
1940           /* Accept #pragmas at struct scope.  */
1941           if (c_parser_next_token_is (parser, CPP_PRAGMA))
1942             {
1943               c_parser_pragma (parser, pragma_external);
1944               continue;
1945             }
1946           /* Parse some comma-separated declarations, but not the
1947              trailing semicolon if any.  */
1948           decls = c_parser_struct_declaration (parser);
1949           contents = chainon (decls, contents);
1950           /* If no semicolon follows, either we have a parse error or
1951              are at the end of the struct or union and should
1952              pedwarn.  */
1953           if (c_parser_next_token_is (parser, CPP_SEMICOLON))
1954             c_parser_consume_token (parser);
1955           else
1956             {
1957               if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
1958                 pedwarn ("%Hno semicolon at end of struct or union",
1959                          &c_parser_peek_token (parser)->location);
1960               else
1961                 {
1962                   c_parser_error (parser, "expected %<;%>");
1963                   c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL);
1964                   break;
1965                 }
1966             }
1967         }
1968       postfix_attrs = c_parser_attributes (parser);
1969       ret.spec = finish_struct (type, nreverse (contents),
1970                                 chainon (attrs, postfix_attrs));
1971       ret.kind = ctsk_tagdef;
1972       return ret;
1973     }
1974   else if (!ident)
1975     {
1976       c_parser_error (parser, "expected %<{%>");
1977       ret.spec = error_mark_node;
1978       ret.kind = ctsk_tagref;
1979       return ret;
1980     }
1981   ret = parser_xref_tag (code, ident);
1982   return ret;
1983 }
1984
1985 /* Parse a struct-declaration (C90 6.5.2.1, C99 6.7.2.1), *without*
1986    the trailing semicolon.
1987
1988    struct-declaration:
1989      specifier-qualifier-list struct-declarator-list
1990
1991    specifier-qualifier-list:
1992      type-specifier specifier-qualifier-list[opt]
1993      type-qualifier specifier-qualifier-list[opt]
1994      attributes specifier-qualifier-list[opt]
1995
1996    struct-declarator-list:
1997      struct-declarator
1998      struct-declarator-list , attributes[opt] struct-declarator
1999
2000    struct-declarator:
2001      declarator attributes[opt]
2002      declarator[opt] : constant-expression attributes[opt]
2003
2004    GNU extensions:
2005
2006    struct-declaration:
2007      __extension__ struct-declaration
2008      specifier-qualifier-list
2009
2010    Unlike the ISO C syntax, semicolons are handled elsewhere.  The use
2011    of attributes where shown is a GNU extension.  In GNU C, we accept
2012    any expression without commas in the syntax (assignment
2013    expressions, not just conditional expressions); assignment
2014    expressions will be diagnosed as non-constant.  */
2015
2016 static tree
2017 c_parser_struct_declaration (c_parser *parser)
2018 {
2019   struct c_declspecs *specs;
2020   tree prefix_attrs;
2021   tree all_prefix_attrs;
2022   tree decls;
2023   location_t decl_loc;
2024   if (c_parser_next_token_is_keyword (parser, RID_EXTENSION))
2025     {
2026       int ext;
2027       tree decl;
2028       ext = disable_extension_diagnostics ();
2029       c_parser_consume_token (parser);
2030       decl = c_parser_struct_declaration (parser);
2031       restore_extension_diagnostics (ext);
2032       return decl;
2033     }
2034   specs = build_null_declspecs ();
2035   decl_loc = c_parser_peek_token (parser)->location;
2036   c_parser_declspecs (parser, specs, false, true, true);
2037   if (parser->error)
2038     return NULL_TREE;
2039   if (!specs->declspecs_seen_p)
2040     {
2041       c_parser_error (parser, "expected specifier-qualifier-list");
2042       return NULL_TREE;
2043     }
2044   finish_declspecs (specs);
2045   if (c_parser_next_token_is (parser, CPP_SEMICOLON))
2046     {
2047       tree ret;
2048       if (!specs->type_seen_p)
2049         {
2050           if (pedantic)
2051             pedwarn ("%HISO C forbids member declarations with no members",
2052                      &decl_loc);
2053           shadow_tag_warned (specs, pedantic);
2054           ret = NULL_TREE;
2055         }
2056       else
2057         {
2058           /* Support for unnamed structs or unions as members of
2059              structs or unions (which is [a] useful and [b] supports
2060              MS P-SDK).  */
2061           tree attrs = NULL;
2062           ret = grokfield (build_id_declarator (NULL_TREE), specs,
2063                            NULL_TREE, &attrs);
2064           if (ret)
2065             decl_attributes (&ret, attrs, 0);
2066         }
2067       return ret;
2068     }
2069   pending_xref_error ();
2070   prefix_attrs = specs->attrs;
2071   all_prefix_attrs = prefix_attrs;
2072   specs->attrs = NULL_TREE;
2073   decls = NULL_TREE;
2074   while (true)
2075     {
2076       /* Declaring one or more declarators or un-named bit-fields.  */
2077       struct c_declarator *declarator;
2078       bool dummy = false;
2079       if (c_parser_next_token_is (parser, CPP_COLON))
2080         declarator = build_id_declarator (NULL_TREE);
2081       else
2082         declarator = c_parser_declarator (parser, specs->type_seen_p,
2083                                           C_DTR_NORMAL, &dummy);
2084       if (declarator == NULL)
2085         {
2086           c_parser_skip_to_end_of_block_or_statement (parser);
2087           break;
2088         }
2089       if (c_parser_next_token_is (parser, CPP_COLON)
2090           || c_parser_next_token_is (parser, CPP_COMMA)
2091           || c_parser_next_token_is (parser, CPP_SEMICOLON)
2092           || c_parser_next_token_is (parser, CPP_CLOSE_BRACE)
2093           || c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
2094         {
2095           tree postfix_attrs = NULL_TREE;
2096           tree width = NULL_TREE;
2097           tree d;
2098           if (c_parser_next_token_is (parser, CPP_COLON))
2099             {
2100               c_parser_consume_token (parser);
2101               width = c_parser_expr_no_commas (parser, NULL).value;
2102             }
2103           if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
2104             postfix_attrs = c_parser_attributes (parser);
2105           d = grokfield (declarator, specs, width, &all_prefix_attrs);
2106           decl_attributes (&d, chainon (postfix_attrs,
2107                                         all_prefix_attrs), 0);
2108           TREE_CHAIN (d) = decls;
2109           decls = d;
2110           if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
2111             all_prefix_attrs = chainon (c_parser_attributes (parser),
2112                                         prefix_attrs);
2113           else
2114             all_prefix_attrs = prefix_attrs;
2115           if (c_parser_next_token_is (parser, CPP_COMMA))
2116             c_parser_consume_token (parser);
2117           else if (c_parser_next_token_is (parser, CPP_SEMICOLON)
2118                    || c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
2119             {
2120               /* Semicolon consumed in caller.  */
2121               break;
2122             }
2123           else
2124             {
2125               c_parser_error (parser, "expected %<,%>, %<;%> or %<}%>");
2126               break;
2127             }
2128         }
2129       else
2130         {
2131           c_parser_error (parser,
2132                           "expected %<:%>, %<,%>, %<;%>, %<}%> or "
2133                           "%<__attribute__%>");
2134           break;
2135         }
2136     }
2137   return decls;
2138 }
2139
2140 /* Parse a typeof specifier (a GNU extension).
2141
2142    typeof-specifier:
2143      typeof ( expression )
2144      typeof ( type-name )
2145 */
2146
2147 static struct c_typespec
2148 c_parser_typeof_specifier (c_parser *parser)
2149 {
2150   struct c_typespec ret;
2151   ret.kind = ctsk_typeof;
2152   ret.spec = error_mark_node;
2153   gcc_assert (c_parser_next_token_is_keyword (parser, RID_TYPEOF));
2154   c_parser_consume_token (parser);
2155   skip_evaluation++;
2156   in_typeof++;
2157   if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
2158     {
2159       skip_evaluation--;
2160       in_typeof--;
2161       return ret;
2162     }
2163   if (c_parser_next_token_starts_typename (parser))
2164     {
2165       struct c_type_name *type = c_parser_type_name (parser);
2166       skip_evaluation--;
2167       in_typeof--;
2168       if (type != NULL)
2169         {
2170           ret.spec = groktypename (type);
2171           pop_maybe_used (variably_modified_type_p (ret.spec, NULL_TREE));
2172         }
2173     }
2174   else
2175     {
2176       bool was_vm;
2177       location_t here = c_parser_peek_token (parser)->location;
2178       struct c_expr expr = c_parser_expression (parser);
2179       skip_evaluation--;
2180       in_typeof--;
2181       if (TREE_CODE (expr.value) == COMPONENT_REF
2182           && DECL_C_BIT_FIELD (TREE_OPERAND (expr.value, 1)))
2183         error ("%H%<typeof%> applied to a bit-field", &here);
2184       ret.spec = TREE_TYPE (expr.value);
2185       was_vm = variably_modified_type_p (ret.spec, NULL_TREE);
2186       /* This should be returned with the type so that when the type
2187          is evaluated, this can be evaluated.  For now, we avoid
2188          evaluation when the context might.  */
2189       if (!skip_evaluation && was_vm)
2190         {
2191           tree e = expr.value;
2192
2193           /* If the expression is not of a type to which we cannot assign a line
2194              number, wrap the thing in a no-op NOP_EXPR.  */
2195           if (DECL_P (e) || CONSTANT_CLASS_P (e))
2196             e = build1 (NOP_EXPR, void_type_node, e);
2197
2198           if (CAN_HAVE_LOCATION_P (e))
2199             SET_EXPR_LOCATION (e, input_location);
2200
2201           add_stmt (e);
2202         }
2203       pop_maybe_used (was_vm);
2204     }
2205   c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
2206   return ret;
2207 }
2208
2209 /* Parse a declarator, possibly an abstract declarator (C90 6.5.4,
2210    6.5.5, C99 6.7.5, 6.7.6).  If TYPE_SEEN_P then a typedef name may
2211    be redeclared; otherwise it may not.  KIND indicates which kind of
2212    declarator is wanted.  Returns a valid declarator except in the
2213    case of a syntax error in which case NULL is returned.  *SEEN_ID is
2214    set to true if an identifier being declared is seen; this is used
2215    to diagnose bad forms of abstract array declarators and to
2216    determine whether an identifier list is syntactically permitted.
2217
2218    declarator:
2219      pointer[opt] direct-declarator
2220
2221    direct-declarator:
2222      identifier
2223      ( attributes[opt] declarator )
2224      direct-declarator array-declarator
2225      direct-declarator ( parameter-type-list )
2226      direct-declarator ( identifier-list[opt] )
2227
2228    pointer:
2229      * type-qualifier-list[opt]
2230      * type-qualifier-list[opt] pointer
2231
2232    type-qualifier-list:
2233      type-qualifier
2234      attributes
2235      type-qualifier-list type-qualifier
2236      type-qualifier-list attributes
2237
2238    parameter-type-list:
2239      parameter-list
2240      parameter-list , ...
2241
2242    parameter-list:
2243      parameter-declaration
2244      parameter-list , parameter-declaration
2245
2246    parameter-declaration:
2247      declaration-specifiers declarator attributes[opt]
2248      declaration-specifiers abstract-declarator[opt] attributes[opt]
2249
2250    identifier-list:
2251      identifier
2252      identifier-list , identifier
2253
2254    abstract-declarator:
2255      pointer
2256      pointer[opt] direct-abstract-declarator
2257
2258    direct-abstract-declarator:
2259      ( attributes[opt] abstract-declarator )
2260      direct-abstract-declarator[opt] array-declarator
2261      direct-abstract-declarator[opt] ( parameter-type-list[opt] )
2262
2263    GNU extensions:
2264
2265    direct-declarator:
2266      direct-declarator ( parameter-forward-declarations
2267                          parameter-type-list[opt] )
2268
2269    direct-abstract-declarator:
2270      direct-abstract-declarator[opt] ( parameter-forward-declarations
2271                                        parameter-type-list[opt] )
2272
2273    parameter-forward-declarations:
2274      parameter-list ;
2275      parameter-forward-declarations parameter-list ;
2276
2277    The uses of attributes shown above are GNU extensions.
2278
2279    Some forms of array declarator are not included in C99 in the
2280    syntax for abstract declarators; these are disallowed elsewhere.
2281    This may be a defect (DR#289).
2282
2283    This function also accepts an omitted abstract declarator as being
2284    an abstract declarator, although not part of the formal syntax.  */
2285
2286 static struct c_declarator *
2287 c_parser_declarator (c_parser *parser, bool type_seen_p, c_dtr_syn kind,
2288                      bool *seen_id)
2289 {
2290   /* Parse any initial pointer part.  */
2291   if (c_parser_next_token_is (parser, CPP_MULT))
2292     {
2293       struct c_declspecs *quals_attrs = build_null_declspecs ();
2294       struct c_declarator *inner;
2295       c_parser_consume_token (parser);
2296       c_parser_declspecs (parser, quals_attrs, false, false, true);
2297       inner = c_parser_declarator (parser, type_seen_p, kind, seen_id);
2298       if (inner == NULL)
2299         return NULL;
2300       else
2301         return make_pointer_declarator (quals_attrs, inner);
2302     }
2303   /* Now we have a direct declarator, direct abstract declarator or
2304      nothing (which counts as a direct abstract declarator here).  */
2305   return c_parser_direct_declarator (parser, type_seen_p, kind, seen_id);
2306 }
2307
2308 /* Parse a direct declarator or direct abstract declarator; arguments
2309    as c_parser_declarator.  */
2310
2311 static struct c_declarator *
2312 c_parser_direct_declarator (c_parser *parser, bool type_seen_p, c_dtr_syn kind,
2313                             bool *seen_id)
2314 {
2315   /* The direct declarator must start with an identifier (possibly
2316      omitted) or a parenthesized declarator (possibly abstract).  In
2317      an ordinary declarator, initial parentheses must start a
2318      parenthesized declarator.  In an abstract declarator or parameter
2319      declarator, they could start a parenthesized declarator or a
2320      parameter list.  To tell which, the open parenthesis and any
2321      following attributes must be read.  If a declaration specifier
2322      follows, then it is a parameter list; if the specifier is a
2323      typedef name, there might be an ambiguity about redeclaring it,
2324      which is resolved in the direction of treating it as a typedef
2325      name.  If a close parenthesis follows, it is also an empty
2326      parameter list, as the syntax does not permit empty abstract
2327      declarators.  Otherwise, it is a parenthesized declarator (in
2328      which case the analysis may be repeated inside it, recursively).
2329
2330      ??? There is an ambiguity in a parameter declaration "int
2331      (__attribute__((foo)) x)", where x is not a typedef name: it
2332      could be an abstract declarator for a function, or declare x with
2333      parentheses.  The proper resolution of this ambiguity needs
2334      documenting.  At present we follow an accident of the old
2335      parser's implementation, whereby the first parameter must have
2336      some declaration specifiers other than just attributes.  Thus as
2337      a parameter declaration it is treated as a parenthesized
2338      parameter named x, and as an abstract declarator it is
2339      rejected.
2340
2341      ??? Also following the old parser, attributes inside an empty
2342      parameter list are ignored, making it a list not yielding a
2343      prototype, rather than giving an error or making it have one
2344      parameter with implicit type int.
2345
2346      ??? Also following the old parser, typedef names may be
2347      redeclared in declarators, but not Objective-C class names.  */
2348
2349   if (kind != C_DTR_ABSTRACT
2350       && c_parser_next_token_is (parser, CPP_NAME)
2351       && ((type_seen_p
2352            && c_parser_peek_token (parser)->id_kind == C_ID_TYPENAME)
2353           || c_parser_peek_token (parser)->id_kind == C_ID_ID))
2354     {
2355       struct c_declarator *inner
2356         = build_id_declarator (c_parser_peek_token (parser)->value);
2357       *seen_id = true;
2358       inner->id_loc = c_parser_peek_token (parser)->location;
2359       c_parser_consume_token (parser);
2360       return c_parser_direct_declarator_inner (parser, *seen_id, inner);
2361     }
2362
2363   if (kind != C_DTR_NORMAL
2364       && c_parser_next_token_is (parser, CPP_OPEN_SQUARE))
2365     {
2366       struct c_declarator *inner = build_id_declarator (NULL_TREE);
2367       return c_parser_direct_declarator_inner (parser, *seen_id, inner);
2368     }
2369
2370   /* Either we are at the end of an abstract declarator, or we have
2371      parentheses.  */
2372
2373   if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
2374     {
2375       tree attrs;
2376       struct c_declarator *inner;
2377       c_parser_consume_token (parser);
2378       attrs = c_parser_attributes (parser);
2379       if (kind != C_DTR_NORMAL
2380           && (c_parser_next_token_starts_declspecs (parser)
2381               || c_parser_next_token_is (parser, CPP_CLOSE_PAREN)))
2382         {
2383           struct c_arg_info *args
2384             = c_parser_parms_declarator (parser, kind == C_DTR_NORMAL,
2385                                          attrs);
2386           if (args == NULL)
2387             return NULL;
2388           else
2389             {
2390               inner
2391                 = build_function_declarator (args,
2392                                              build_id_declarator (NULL_TREE));
2393               return c_parser_direct_declarator_inner (parser, *seen_id,
2394                                                        inner);
2395             }
2396         }
2397       /* A parenthesized declarator.  */
2398       inner = c_parser_declarator (parser, type_seen_p, kind, seen_id);
2399       if (inner != NULL && attrs != NULL)
2400         inner = build_attrs_declarator (attrs, inner);
2401       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2402         {
2403           c_parser_consume_token (parser);
2404           if (inner == NULL)
2405             return NULL;
2406           else
2407             return c_parser_direct_declarator_inner (parser, *seen_id, inner);
2408         }
2409       else
2410         {
2411           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2412                                      "expected %<)%>");
2413           return NULL;
2414         }
2415     }
2416   else
2417     {
2418       if (kind == C_DTR_NORMAL)
2419         {
2420           c_parser_error (parser, "expected identifier or %<(%>");
2421           return NULL;
2422         }
2423       else
2424         return build_id_declarator (NULL_TREE);
2425     }
2426 }
2427
2428 /* Parse part of a direct declarator or direct abstract declarator,
2429    given that some (in INNER) has already been parsed; ID_PRESENT is
2430    true if an identifier is present, false for an abstract
2431    declarator.  */
2432
2433 static struct c_declarator *
2434 c_parser_direct_declarator_inner (c_parser *parser, bool id_present,
2435                                   struct c_declarator *inner)
2436 {
2437   /* Parse a sequence of array declarators and parameter lists.  */
2438   if (c_parser_next_token_is (parser, CPP_OPEN_SQUARE))
2439     {
2440       struct c_declarator *declarator;
2441       struct c_declspecs *quals_attrs = build_null_declspecs ();
2442       bool static_seen;
2443       bool star_seen;
2444       tree dimen;
2445       c_parser_consume_token (parser);
2446       c_parser_declspecs (parser, quals_attrs, false, false, true);
2447       static_seen = c_parser_next_token_is_keyword (parser, RID_STATIC);
2448       if (static_seen)
2449         c_parser_consume_token (parser);
2450       if (static_seen && !quals_attrs->declspecs_seen_p)
2451         c_parser_declspecs (parser, quals_attrs, false, false, true);
2452       if (!quals_attrs->declspecs_seen_p)
2453         quals_attrs = NULL;
2454       /* If "static" is present, there must be an array dimension.
2455          Otherwise, there may be a dimension, "*", or no
2456          dimension.  */
2457       if (static_seen)
2458         {
2459           star_seen = false;
2460           dimen = c_parser_expr_no_commas (parser, NULL).value;
2461         }
2462       else
2463         {
2464           if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
2465             {
2466               dimen = NULL_TREE;
2467               star_seen = false;
2468             }
2469           else if (c_parser_next_token_is (parser, CPP_MULT))
2470             {
2471               if (c_parser_peek_2nd_token (parser)->type == CPP_CLOSE_SQUARE)
2472                 {
2473                   dimen = NULL_TREE;
2474                   star_seen = true;
2475                   c_parser_consume_token (parser);
2476                 }
2477               else
2478                 {
2479                   star_seen = false;
2480                   dimen = c_parser_expr_no_commas (parser, NULL).value;
2481                 }
2482             }
2483           else
2484             {
2485               star_seen = false;
2486               dimen = c_parser_expr_no_commas (parser, NULL).value;
2487             }
2488         }
2489       if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
2490         c_parser_consume_token (parser);
2491       else
2492         {
2493           c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
2494                                      "expected %<]%>");
2495           return NULL;
2496         }
2497       declarator = build_array_declarator (dimen, quals_attrs, static_seen,
2498                                            star_seen);
2499       if (declarator == NULL)
2500         return NULL;
2501       inner = set_array_declarator_inner (declarator, inner);
2502       return c_parser_direct_declarator_inner (parser, id_present, inner);
2503     }
2504   else if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
2505     {
2506       tree attrs;
2507       struct c_arg_info *args;
2508       c_parser_consume_token (parser);
2509       attrs = c_parser_attributes (parser);
2510       args = c_parser_parms_declarator (parser, id_present, attrs);
2511       if (args == NULL)
2512         return NULL;
2513       else
2514         {
2515           inner = build_function_declarator (args, inner);
2516           return c_parser_direct_declarator_inner (parser, id_present, inner);
2517         }
2518     }
2519   return inner;
2520 }
2521
2522 /* Parse a parameter list or identifier list, including the closing
2523    parenthesis but not the opening one.  ATTRS are the attributes at
2524    the start of the list.  ID_LIST_OK is true if an identifier list is
2525    acceptable; such a list must not have attributes at the start.  */
2526
2527 static struct c_arg_info *
2528 c_parser_parms_declarator (c_parser *parser, bool id_list_ok, tree attrs)
2529 {
2530   push_scope ();
2531   declare_parm_level ();
2532   /* If the list starts with an identifier, it is an identifier list.
2533      Otherwise, it is either a prototype list or an empty list.  */
2534   if (id_list_ok
2535       && !attrs
2536       && c_parser_next_token_is (parser, CPP_NAME)
2537       && c_parser_peek_token (parser)->id_kind == C_ID_ID)
2538     {
2539       tree list = NULL_TREE, *nextp = &list;
2540       while (c_parser_next_token_is (parser, CPP_NAME)
2541              && c_parser_peek_token (parser)->id_kind == C_ID_ID)
2542         {
2543           *nextp = build_tree_list (NULL_TREE,
2544                                     c_parser_peek_token (parser)->value);
2545           nextp = & TREE_CHAIN (*nextp);
2546           c_parser_consume_token (parser);
2547           if (c_parser_next_token_is_not (parser, CPP_COMMA))
2548             break;
2549           c_parser_consume_token (parser);
2550           if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2551             {
2552               c_parser_error (parser, "expected identifier");
2553               break;
2554             }
2555         }
2556       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2557         {
2558           struct c_arg_info *ret = XOBNEW (&parser_obstack, struct c_arg_info);
2559           ret->parms = 0;
2560           ret->tags = 0;
2561           ret->types = list;
2562           ret->others = 0;
2563           ret->pending_sizes = 0;
2564           ret->had_vla_unspec = 0;
2565           c_parser_consume_token (parser);
2566           pop_scope ();
2567           return ret;
2568         }
2569       else
2570         {
2571           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2572                                      "expected %<)%>");
2573           pop_scope ();
2574           return NULL;
2575         }
2576     }
2577   else
2578     {
2579       struct c_arg_info *ret = c_parser_parms_list_declarator (parser, attrs);
2580       pop_scope ();
2581       return ret;
2582     }
2583 }
2584
2585 /* Parse a parameter list (possibly empty), including the closing
2586    parenthesis but not the opening one.  ATTRS are the attributes at
2587    the start of the list.  */
2588
2589 static struct c_arg_info *
2590 c_parser_parms_list_declarator (c_parser *parser, tree attrs)
2591 {
2592   bool good_parm = false;
2593   /* ??? Following the old parser, forward parameter declarations may
2594      use abstract declarators, and if no real parameter declarations
2595      follow the forward declarations then this is not diagnosed.  Also
2596      note as above that attributes are ignored as the only contents of
2597      the parentheses, or as the only contents after forward
2598      declarations.  */
2599   if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2600     {
2601       struct c_arg_info *ret = XOBNEW (&parser_obstack, struct c_arg_info);
2602       ret->parms = 0;
2603       ret->tags = 0;
2604       ret->types = 0;
2605       ret->others = 0;
2606       ret->pending_sizes = 0;
2607       ret->had_vla_unspec = 0;
2608       c_parser_consume_token (parser);
2609       return ret;
2610     }
2611   if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
2612     {
2613       struct c_arg_info *ret = XOBNEW (&parser_obstack, struct c_arg_info);
2614       ret->parms = 0;
2615       ret->tags = 0;
2616       ret->others = 0;
2617       ret->pending_sizes = 0;
2618       ret->had_vla_unspec = 0;
2619       /* Suppress -Wold-style-definition for this case.  */
2620       ret->types = error_mark_node;
2621       error ("%HISO C requires a named argument before %<...%>",
2622              &c_parser_peek_token (parser)->location);
2623       c_parser_consume_token (parser);
2624       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2625         {
2626           c_parser_consume_token (parser);
2627           return ret;
2628         }
2629       else
2630         {
2631           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2632                                      "expected %<)%>");
2633           return NULL;
2634         }
2635     }
2636   /* Nonempty list of parameters, either terminated with semicolon
2637      (forward declarations; recurse) or with close parenthesis (normal
2638      function) or with ", ... )" (variadic function).  */
2639   while (true)
2640     {
2641       /* Parse a parameter.  */
2642       struct c_parm *parm = c_parser_parameter_declaration (parser, attrs);
2643       attrs = NULL_TREE;
2644       if (parm != NULL)
2645         {
2646           good_parm = true;
2647           push_parm_decl (parm);
2648         }
2649       if (c_parser_next_token_is (parser, CPP_SEMICOLON))
2650         {
2651           tree new_attrs;
2652           c_parser_consume_token (parser);
2653           mark_forward_parm_decls ();
2654           new_attrs = c_parser_attributes (parser);
2655           return c_parser_parms_list_declarator (parser, new_attrs);
2656         }
2657       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2658         {
2659           c_parser_consume_token (parser);
2660           if (good_parm)
2661             return get_parm_info (false);
2662           else
2663             {
2664               struct c_arg_info *ret
2665                 = XOBNEW (&parser_obstack, struct c_arg_info);
2666               ret->parms = 0;
2667               ret->tags = 0;
2668               ret->types = 0;
2669               ret->others = 0;
2670               ret->pending_sizes = 0;
2671               ret->had_vla_unspec = 0;
2672               return ret;
2673             }
2674         }
2675       if (!c_parser_require (parser, CPP_COMMA,
2676                              "expected %<;%>, %<,%> or %<)%>"))
2677         {
2678           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
2679           return NULL;
2680         }
2681       if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
2682         {
2683           c_parser_consume_token (parser);
2684           if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2685             {
2686               c_parser_consume_token (parser);
2687               if (good_parm)
2688                 return get_parm_info (true);
2689               else
2690                 {
2691                   struct c_arg_info *ret
2692                     = XOBNEW (&parser_obstack, struct c_arg_info);
2693                   ret->parms = 0;
2694                   ret->tags = 0;
2695                   ret->types = 0;
2696                   ret->others = 0;
2697                   ret->pending_sizes = 0;
2698                   ret->had_vla_unspec = 0;
2699                   return ret;
2700                 }
2701             }
2702           else
2703             {
2704               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2705                                          "expected %<)%>");
2706               return NULL;
2707             }
2708         }
2709     }
2710 }
2711
2712 /* Parse a parameter declaration.  ATTRS are the attributes at the
2713    start of the declaration if it is the first parameter.  */
2714
2715 static struct c_parm *
2716 c_parser_parameter_declaration (c_parser *parser, tree attrs)
2717 {
2718   struct c_declspecs *specs;
2719   struct c_declarator *declarator;
2720   tree prefix_attrs;
2721   tree postfix_attrs = NULL_TREE;
2722   bool dummy = false;
2723   if (!c_parser_next_token_starts_declspecs (parser))
2724     {
2725       /* ??? In some Objective-C cases '...' isn't applicable so there
2726          should be a different message.  */
2727       c_parser_error (parser,
2728                       "expected declaration specifiers or %<...%>");
2729       c_parser_skip_to_end_of_parameter (parser);
2730       return NULL;
2731     }
2732   specs = build_null_declspecs ();
2733   if (attrs)
2734     {
2735       declspecs_add_attrs (specs, attrs);
2736       attrs = NULL_TREE;
2737     }
2738   c_parser_declspecs (parser, specs, true, true, true);
2739   finish_declspecs (specs);
2740   pending_xref_error ();
2741   prefix_attrs = specs->attrs;
2742   specs->attrs = NULL_TREE;
2743   declarator = c_parser_declarator (parser, specs->type_seen_p,
2744                                     C_DTR_PARM, &dummy);
2745   if (declarator == NULL)
2746     {
2747       c_parser_skip_until_found (parser, CPP_COMMA, NULL);
2748       return NULL;
2749     }
2750   if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
2751     postfix_attrs = c_parser_attributes (parser);
2752   return build_c_parm (specs, chainon (postfix_attrs, prefix_attrs),
2753                        declarator);
2754 }
2755
2756 /* Parse a string literal in an asm expression.  It should not be
2757    translated, and wide string literals are an error although
2758    permitted by the syntax.  This is a GNU extension.
2759
2760    asm-string-literal:
2761      string-literal
2762
2763    ??? At present, following the old parser, the caller needs to have
2764    set lex_untranslated_string to 1.  It would be better to follow the
2765    C++ parser rather than using this kludge.  */
2766
2767 static tree
2768 c_parser_asm_string_literal (c_parser *parser)
2769 {
2770   tree str;
2771   if (c_parser_next_token_is (parser, CPP_STRING))
2772     {
2773       str = c_parser_peek_token (parser)->value;
2774       c_parser_consume_token (parser);
2775     }
2776   else if (c_parser_next_token_is (parser, CPP_WSTRING))
2777     {
2778       error ("%Hwide string literal in %<asm%>",
2779              &c_parser_peek_token (parser)->location);
2780       str = build_string (1, "");
2781       c_parser_consume_token (parser);
2782     }
2783   else
2784     {
2785       c_parser_error (parser, "expected string literal");
2786       str = NULL_TREE;
2787     }
2788   return str;
2789 }
2790
2791 /* Parse a simple asm expression.  This is used in restricted
2792    contexts, where a full expression with inputs and outputs does not
2793    make sense.  This is a GNU extension.
2794
2795    simple-asm-expr:
2796      asm ( asm-string-literal )
2797 */
2798
2799 static tree
2800 c_parser_simple_asm_expr (c_parser *parser)
2801 {
2802   tree str;
2803   gcc_assert (c_parser_next_token_is_keyword (parser, RID_ASM));
2804   /* ??? Follow the C++ parser rather than using the
2805      lex_untranslated_string kludge.  */
2806   parser->lex_untranslated_string = true;
2807   c_parser_consume_token (parser);
2808   if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
2809     {
2810       parser->lex_untranslated_string = false;
2811       return NULL_TREE;
2812     }
2813   str = c_parser_asm_string_literal (parser);
2814   parser->lex_untranslated_string = false;
2815   if (!c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
2816     {
2817       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
2818       return NULL_TREE;
2819     }
2820   return str;
2821 }
2822
2823 /* Parse (possibly empty) attributes.  This is a GNU extension.
2824
2825    attributes:
2826      empty
2827      attributes attribute
2828
2829    attribute:
2830      __attribute__ ( ( attribute-list ) )
2831
2832    attribute-list:
2833      attrib
2834      attribute_list , attrib
2835
2836    attrib:
2837      empty
2838      any-word
2839      any-word ( identifier )
2840      any-word ( identifier , nonempty-expr-list )
2841      any-word ( expr-list )
2842
2843    where the "identifier" must not be declared as a type, and
2844    "any-word" may be any identifier (including one declared as a
2845    type), a reserved word storage class specifier, type specifier or
2846    type qualifier.  ??? This still leaves out most reserved keywords
2847    (following the old parser), shouldn't we include them, and why not
2848    allow identifiers declared as types to start the arguments?  */
2849
2850 static tree
2851 c_parser_attributes (c_parser *parser)
2852 {
2853   tree attrs = NULL_TREE;
2854   while (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
2855     {
2856       /* ??? Follow the C++ parser rather than using the
2857          lex_untranslated_string kludge.  */
2858       parser->lex_untranslated_string = true;
2859       c_parser_consume_token (parser);
2860       if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
2861         {
2862           parser->lex_untranslated_string = false;
2863           return attrs;
2864         }
2865       if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
2866         {
2867           parser->lex_untranslated_string = false;
2868           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
2869           return attrs;
2870         }
2871       /* Parse the attribute list.  */
2872       while (c_parser_next_token_is (parser, CPP_COMMA)
2873              || c_parser_next_token_is (parser, CPP_NAME)
2874              || c_parser_next_token_is (parser, CPP_KEYWORD))
2875         {
2876           tree attr, attr_name, attr_args;
2877           if (c_parser_next_token_is (parser, CPP_COMMA))
2878             {
2879               c_parser_consume_token (parser);
2880               continue;
2881             }
2882           if (c_parser_next_token_is (parser, CPP_KEYWORD))
2883             {
2884               /* ??? See comment above about what keywords are
2885                  accepted here.  */
2886               bool ok;
2887               switch (c_parser_peek_token (parser)->keyword)
2888                 {
2889                 case RID_STATIC:
2890                 case RID_UNSIGNED:
2891                 case RID_LONG:
2892                 case RID_CONST:
2893                 case RID_EXTERN:
2894                 case RID_REGISTER:
2895                 case RID_TYPEDEF:
2896                 case RID_SHORT:
2897                 case RID_INLINE:
2898                 case RID_VOLATILE:
2899                 case RID_SIGNED:
2900                 case RID_AUTO:
2901                 case RID_RESTRICT:
2902                 case RID_COMPLEX:
2903                 case RID_THREAD:
2904                 case RID_INT:
2905                 case RID_CHAR:
2906                 case RID_FLOAT:
2907                 case RID_DOUBLE:
2908                 case RID_VOID:
2909                 case RID_DFLOAT32:
2910                 case RID_DFLOAT64:
2911                 case RID_DFLOAT128:
2912                 case RID_BOOL:
2913                 case RID_FRACT:
2914                 case RID_ACCUM:
2915                 case RID_SAT:
2916                   ok = true;
2917                   break;
2918                 default:
2919                   ok = false;
2920                   break;
2921                 }
2922               if (!ok)
2923                 break;
2924             }
2925           attr_name = c_parser_peek_token (parser)->value;
2926           c_parser_consume_token (parser);
2927           if (c_parser_next_token_is_not (parser, CPP_OPEN_PAREN))
2928             {
2929               attr = build_tree_list (attr_name, NULL_TREE);
2930               attrs = chainon (attrs, attr);
2931               continue;
2932             }
2933           c_parser_consume_token (parser);
2934           /* Parse the attribute contents.  If they start with an
2935              identifier which is followed by a comma or close
2936              parenthesis, then the arguments start with that
2937              identifier; otherwise they are an expression list.  */
2938           if (c_parser_next_token_is (parser, CPP_NAME)
2939               && c_parser_peek_token (parser)->id_kind == C_ID_ID
2940               && ((c_parser_peek_2nd_token (parser)->type == CPP_COMMA)
2941                   || (c_parser_peek_2nd_token (parser)->type
2942                       == CPP_CLOSE_PAREN)))
2943             {
2944               tree arg1 = c_parser_peek_token (parser)->value;
2945               c_parser_consume_token (parser);
2946               if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2947                 attr_args = build_tree_list (NULL_TREE, arg1);
2948               else
2949                 {
2950                   c_parser_consume_token (parser);
2951                   attr_args = tree_cons (NULL_TREE, arg1,
2952                                          c_parser_expr_list (parser, false));
2953                 }
2954             }
2955           else
2956             {
2957               if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2958                 attr_args = NULL_TREE;
2959               else
2960                 attr_args = c_parser_expr_list (parser, false);
2961             }
2962           attr = build_tree_list (attr_name, attr_args);
2963           if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2964             c_parser_consume_token (parser);
2965           else
2966             {
2967               parser->lex_untranslated_string = false;
2968               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2969                                          "expected %<)%>");
2970               return attrs;
2971             }
2972           attrs = chainon (attrs, attr);
2973         }
2974       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2975         c_parser_consume_token (parser);
2976       else
2977         {
2978           parser->lex_untranslated_string = false;
2979           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2980                                      "expected %<)%>");
2981           return attrs;
2982         }
2983       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2984         c_parser_consume_token (parser);
2985       else
2986         {
2987           parser->lex_untranslated_string = false;
2988           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2989                                      "expected %<)%>");
2990           return attrs;
2991         }
2992       parser->lex_untranslated_string = false;
2993     }
2994   return attrs;
2995 }
2996
2997 /* Parse a type name (C90 6.5.5, C99 6.7.6).
2998
2999    type-name:
3000      specifier-qualifier-list abstract-declarator[opt]
3001 */
3002
3003 static struct c_type_name *
3004 c_parser_type_name (c_parser *parser)
3005 {
3006   struct c_declspecs *specs = build_null_declspecs ();
3007   struct c_declarator *declarator;
3008   struct c_type_name *ret;
3009   bool dummy = false;
3010   c_parser_declspecs (parser, specs, false, true, true);
3011   if (!specs->declspecs_seen_p)
3012     {
3013       c_parser_error (parser, "expected specifier-qualifier-list");
3014       return NULL;
3015     }
3016   pending_xref_error ();
3017   finish_declspecs (specs);
3018   declarator = c_parser_declarator (parser, specs->type_seen_p,
3019                                     C_DTR_ABSTRACT, &dummy);
3020   if (declarator == NULL)
3021     return NULL;
3022   ret = XOBNEW (&parser_obstack, struct c_type_name);
3023   ret->specs = specs;
3024   ret->declarator = declarator;
3025   return ret;
3026 }
3027
3028 /* Parse an initializer (C90 6.5.7, C99 6.7.8).
3029
3030    initializer:
3031      assignment-expression
3032      { initializer-list }
3033      { initializer-list , }
3034
3035    initializer-list:
3036      designation[opt] initializer
3037      initializer-list , designation[opt] initializer
3038
3039    designation:
3040      designator-list =
3041
3042    designator-list:
3043      designator
3044      designator-list designator
3045
3046    designator:
3047      array-designator
3048      . identifier
3049
3050    array-designator:
3051      [ constant-expression ]
3052
3053    GNU extensions:
3054
3055    initializer:
3056      { }
3057
3058    designation:
3059      array-designator
3060      identifier :
3061
3062    array-designator:
3063      [ constant-expression ... constant-expression ]
3064
3065    Any expression without commas is accepted in the syntax for the
3066    constant-expressions, with non-constant expressions rejected later.
3067
3068    This function is only used for top-level initializers; for nested
3069    ones, see c_parser_initval.  */
3070
3071 static struct c_expr
3072 c_parser_initializer (c_parser *parser)
3073 {
3074   if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
3075     return c_parser_braced_init (parser, NULL_TREE, false);
3076   else
3077     {
3078       struct c_expr ret;
3079       ret = c_parser_expr_no_commas (parser, NULL);
3080       if (TREE_CODE (ret.value) != STRING_CST
3081           && TREE_CODE (ret.value) != COMPOUND_LITERAL_EXPR)
3082         ret = default_function_array_conversion (ret);
3083       return ret;
3084     }
3085 }
3086
3087 /* Parse a braced initializer list.  TYPE is the type specified for a
3088    compound literal, and NULL_TREE for other initializers and for
3089    nested braced lists.  NESTED_P is true for nested braced lists,
3090    false for the list of a compound literal or the list that is the
3091    top-level initializer in a declaration.  */
3092
3093 static struct c_expr
3094 c_parser_braced_init (c_parser *parser, tree type, bool nested_p)
3095 {
3096   location_t brace_loc = c_parser_peek_token (parser)->location;
3097   gcc_assert (c_parser_next_token_is (parser, CPP_OPEN_BRACE));
3098   c_parser_consume_token (parser);
3099   if (nested_p)
3100     push_init_level (0);
3101   else
3102     really_start_incremental_init (type);
3103   if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
3104     {
3105       if (pedantic)
3106         pedwarn ("%HISO C forbids empty initializer braces", &brace_loc);
3107     }
3108   else
3109     {
3110       /* Parse a non-empty initializer list, possibly with a trailing
3111          comma.  */
3112       while (true)
3113         {
3114           c_parser_initelt (parser);
3115           if (parser->error)
3116             break;
3117           if (c_parser_next_token_is (parser, CPP_COMMA))
3118             c_parser_consume_token (parser);
3119           else
3120             break;
3121           if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
3122             break;
3123         }
3124     }
3125   if (c_parser_next_token_is_not (parser, CPP_CLOSE_BRACE))
3126     {
3127       struct c_expr ret;
3128       ret.value = error_mark_node;
3129       ret.original_code = ERROR_MARK;
3130       c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, "expected %<}%>");
3131       return ret;
3132     }
3133   c_parser_consume_token (parser);
3134   return pop_init_level (0);
3135 }
3136
3137 /* Parse a nested initializer, including designators.  */
3138
3139 static void
3140 c_parser_initelt (c_parser *parser)
3141 {
3142   /* Parse any designator or designator list.  A single array
3143      designator may have the subsequent "=" omitted in GNU C, but a
3144      longer list or a structure member designator may not.  */
3145   if (c_parser_next_token_is (parser, CPP_NAME)
3146       && c_parser_peek_2nd_token (parser)->type == CPP_COLON)
3147     {
3148       /* Old-style structure member designator.  */
3149       set_init_label (c_parser_peek_token (parser)->value);
3150       if (pedantic)
3151         {
3152           /* Use the colon as the error location.  */
3153           pedwarn ("%Hobsolete use of designated initializer with %<:%>",
3154                    &c_parser_peek_2nd_token (parser)->location);
3155         }
3156       c_parser_consume_token (parser);
3157       c_parser_consume_token (parser);
3158     }
3159   else
3160     {
3161       /* des_seen is 0 if there have been no designators, 1 if there
3162          has been a single array designator and 2 otherwise.  */
3163       int des_seen = 0;
3164       /* Location of a designator.  */
3165       location_t des_loc;
3166       while (c_parser_next_token_is (parser, CPP_OPEN_SQUARE)
3167              || c_parser_next_token_is (parser, CPP_DOT))
3168         {
3169           int des_prev = des_seen;
3170           if (!des_seen)
3171             des_loc = c_parser_peek_token (parser)->location;
3172           if (des_seen < 2)
3173             des_seen++;
3174           if (c_parser_next_token_is (parser, CPP_DOT))
3175             {
3176               des_seen = 2;
3177               c_parser_consume_token (parser);
3178               if (c_parser_next_token_is (parser, CPP_NAME))
3179                 {
3180                   set_init_label (c_parser_peek_token (parser)->value);
3181                   c_parser_consume_token (parser);
3182                 }
3183               else
3184                 {
3185                   struct c_expr init;
3186                   init.value = error_mark_node;
3187                   init.original_code = ERROR_MARK;
3188                   c_parser_error (parser, "expected identifier");
3189                   c_parser_skip_until_found (parser, CPP_COMMA, NULL);
3190                   process_init_element (init);
3191                   return;
3192                 }
3193             }
3194           else
3195             {
3196               tree first, second;
3197               location_t ellipsis_loc;
3198               /* ??? Following the old parser, [ objc-receiver
3199                  objc-message-args ] is accepted as an initializer,
3200                  being distinguished from a designator by what follows
3201                  the first assignment expression inside the square
3202                  brackets, but after a first array designator a
3203                  subsequent square bracket is for Objective-C taken to
3204                  start an expression, using the obsolete form of
3205                  designated initializer without '=', rather than
3206                  possibly being a second level of designation: in LALR
3207                  terms, the '[' is shifted rather than reducing
3208                  designator to designator-list.  */
3209               if (des_prev == 1 && c_dialect_objc ())
3210                 {
3211                   des_seen = des_prev;
3212                   break;
3213                 }
3214               if (des_prev == 0 && c_dialect_objc ())
3215                 {
3216                   /* This might be an array designator or an
3217                      Objective-C message expression.  If the former,
3218                      continue parsing here; if the latter, parse the
3219                      remainder of the initializer given the starting
3220                      primary-expression.  ??? It might make sense to
3221                      distinguish when des_prev == 1 as well; see
3222                      previous comment.  */
3223                   tree rec, args;
3224                   struct c_expr mexpr;
3225                   c_parser_consume_token (parser);
3226                   if (c_parser_peek_token (parser)->type == CPP_NAME
3227                       && ((c_parser_peek_token (parser)->id_kind
3228                            == C_ID_TYPENAME)
3229                           || (c_parser_peek_token (parser)->id_kind
3230                               == C_ID_CLASSNAME)))
3231                     {
3232                       /* Type name receiver.  */
3233                       tree id = c_parser_peek_token (parser)->value;
3234                       c_parser_consume_token (parser);
3235                       rec = objc_get_class_reference (id);
3236                       goto parse_message_args;
3237                     }
3238                   first = c_parser_expr_no_commas (parser, NULL).value;
3239                   if (c_parser_next_token_is (parser, CPP_ELLIPSIS)
3240                       || c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
3241                     goto array_desig_after_first;
3242                   /* Expression receiver.  So far only one part
3243                      without commas has been parsed; there might be
3244                      more of the expression.  */
3245                   rec = first;
3246                   while (c_parser_next_token_is (parser, CPP_COMMA))
3247                     {
3248                       struct c_expr next;
3249                       c_parser_consume_token (parser);
3250                       next = c_parser_expr_no_commas (parser, NULL);
3251                       next = default_function_array_conversion (next);
3252                       rec = build_compound_expr (rec, next.value);
3253                     }
3254                 parse_message_args:
3255                   /* Now parse the objc-message-args.  */
3256                   args = c_parser_objc_message_args (parser);
3257                   c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
3258                                              "expected %<]%>");
3259                   mexpr.value
3260                     = objc_build_message_expr (build_tree_list (rec, args));
3261                   mexpr.original_code = ERROR_MARK;
3262                   /* Now parse and process the remainder of the
3263                      initializer, starting with this message
3264                      expression as a primary-expression.  */
3265                   c_parser_initval (parser, &mexpr);
3266                   return;
3267                 }
3268               c_parser_consume_token (parser);
3269               first = c_parser_expr_no_commas (parser, NULL).value;
3270             array_desig_after_first:
3271               if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
3272                 {
3273                   ellipsis_loc = c_parser_peek_token (parser)->location;
3274                   c_parser_consume_token (parser);
3275                   second = c_parser_expr_no_commas (parser, NULL).value;
3276                 }
3277               else
3278                 second = NULL_TREE;
3279               if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
3280                 {
3281                   c_parser_consume_token (parser);
3282                   set_init_index (first, second);
3283                   if (pedantic && second)
3284                     pedwarn ("%HISO C forbids specifying range of "
3285                              "elements to initialize", &ellipsis_loc);
3286                 }
3287               else
3288                 c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
3289                                            "expected %<]%>");
3290             }
3291         }
3292       if (des_seen >= 1)
3293         {
3294           if (c_parser_next_token_is (parser, CPP_EQ))
3295             {
3296               if (pedantic && !flag_isoc99)
3297                 pedwarn ("%HISO C90 forbids specifying subobject "
3298                          "to initialize", &des_loc);
3299               c_parser_consume_token (parser);
3300             }
3301           else
3302             {
3303               if (des_seen == 1)
3304                 {
3305                   if (pedantic)
3306                     pedwarn ("%Hobsolete use of designated initializer "
3307                              "without %<=%>",
3308                              &c_parser_peek_token (parser)->location);
3309                 }
3310               else
3311                 {
3312                   struct c_expr init;
3313                   init.value = error_mark_node;
3314                   init.original_code = ERROR_MARK;
3315                   c_parser_error (parser, "expected %<=%>");
3316                   c_parser_skip_until_found (parser, CPP_COMMA, NULL);
3317                   process_init_element (init);
3318                   return;
3319                 }
3320             }
3321         }
3322     }
3323   c_parser_initval (parser, NULL);
3324 }
3325
3326 /* Parse a nested initializer; as c_parser_initializer but parses
3327    initializers within braced lists, after any designators have been
3328    applied.  If AFTER is not NULL then it is an Objective-C message
3329    expression which is the primary-expression starting the
3330    initializer.  */
3331
3332 static void
3333 c_parser_initval (c_parser *parser, struct c_expr *after)
3334 {
3335   struct c_expr init;
3336   gcc_assert (!after || c_dialect_objc ());
3337   if (c_parser_next_token_is (parser, CPP_OPEN_BRACE) && !after)
3338     init = c_parser_braced_init (parser, NULL_TREE, true);
3339   else
3340     {
3341       init = c_parser_expr_no_commas (parser, after);
3342       if (init.value != NULL_TREE
3343           && TREE_CODE (init.value) != STRING_CST
3344           && TREE_CODE (init.value) != COMPOUND_LITERAL_EXPR)
3345         init = default_function_array_conversion (init);
3346     }
3347   process_init_element (init);
3348 }
3349
3350 /* Parse a compound statement (possibly a function body) (C90 6.6.2,
3351    C99 6.8.2).
3352
3353    compound-statement:
3354      { block-item-list[opt] }
3355      { label-declarations block-item-list }
3356
3357    block-item-list:
3358      block-item
3359      block-item-list block-item
3360
3361    block-item:
3362      nested-declaration
3363      statement
3364
3365    nested-declaration:
3366      declaration
3367
3368    GNU extensions:
3369
3370    compound-statement:
3371      { label-declarations block-item-list }
3372
3373    nested-declaration:
3374      __extension__ nested-declaration
3375      nested-function-definition
3376
3377    label-declarations:
3378      label-declaration
3379      label-declarations label-declaration
3380
3381    label-declaration:
3382      __label__ identifier-list ;
3383
3384    Allowing the mixing of declarations and code is new in C99.  The
3385    GNU syntax also permits (not shown above) labels at the end of
3386    compound statements, which yield an error.  We don't allow labels
3387    on declarations; this might seem like a natural extension, but
3388    there would be a conflict between attributes on the label and
3389    prefix attributes on the declaration.  ??? The syntax follows the
3390    old parser in requiring something after label declarations.
3391    Although they are erroneous if the labels declared aren't defined,
3392    is it useful for the syntax to be this way?
3393    
3394    OpenMP:
3395    
3396    block-item:
3397      openmp-directive
3398
3399    openmp-directive:
3400      barrier-directive
3401      flush-directive  */
3402
3403 static tree
3404 c_parser_compound_statement (c_parser *parser)
3405 {
3406   tree stmt;
3407   if (!c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>"))
3408     return error_mark_node;
3409   stmt = c_begin_compound_stmt (true);
3410   c_parser_compound_statement_nostart (parser);
3411   return c_end_compound_stmt (stmt, true);
3412 }
3413
3414 /* Parse a compound statement except for the opening brace.  This is
3415    used for parsing both compound statements and statement expressions
3416    (which follow different paths to handling the opening).  */
3417
3418 static void
3419 c_parser_compound_statement_nostart (c_parser *parser)
3420 {
3421   bool last_stmt = false;
3422   bool last_label = false;
3423   location_t label_loc;
3424   if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
3425     {
3426       c_parser_consume_token (parser);
3427       return;
3428     }
3429   if (c_parser_next_token_is_keyword (parser, RID_LABEL))
3430     {
3431       location_t err_loc = c_parser_peek_token (parser)->location;
3432       /* Read zero or more forward-declarations for labels that nested
3433          functions can jump to.  */
3434       while (c_parser_next_token_is_keyword (parser, RID_LABEL))
3435         {
3436           c_parser_consume_token (parser);
3437           /* Any identifiers, including those declared as type names,
3438              are OK here.  */
3439           while (true)
3440             {
3441               tree label;
3442               if (c_parser_next_token_is_not (parser, CPP_NAME))
3443                 {
3444                   c_parser_error (parser, "expected identifier");
3445                   break;
3446                 }
3447               label
3448                 = declare_label (c_parser_peek_token (parser)->value);
3449               C_DECLARED_LABEL_FLAG (label) = 1;
3450               add_stmt (build_stmt (DECL_EXPR, label));
3451               c_parser_consume_token (parser);
3452               if (c_parser_next_token_is (parser, CPP_COMMA))
3453                 c_parser_consume_token (parser);
3454               else
3455                 break;
3456             }
3457           c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
3458         }
3459       if (pedantic)
3460         pedwarn ("%HISO C forbids label declarations", &err_loc);
3461     }
3462   /* We must now have at least one statement, label or declaration.  */
3463   if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
3464     {
3465       c_parser_error (parser, "expected declaration or statement");
3466       c_parser_consume_token (parser);
3467       return;
3468     }
3469   while (c_parser_next_token_is_not (parser, CPP_CLOSE_BRACE))
3470     {
3471       location_t loc = c_parser_peek_token (parser)->location;
3472       if (c_parser_next_token_is_keyword (parser, RID_CASE)
3473           || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
3474           || (c_parser_next_token_is (parser, CPP_NAME)
3475               && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
3476         {
3477           if (c_parser_next_token_is_keyword (parser, RID_CASE))
3478             label_loc = c_parser_peek_2nd_token (parser)->location;
3479           else
3480             label_loc = c_parser_peek_token (parser)->location;
3481           last_label = true;
3482           last_stmt = false;
3483           c_parser_label (parser);
3484         }
3485       else if (!last_label
3486                && c_parser_next_token_starts_declspecs (parser))
3487         {
3488           last_label = false;
3489           c_parser_declaration_or_fndef (parser, true, true, true, true);
3490           if (last_stmt
3491               && ((pedantic && !flag_isoc99)
3492                   || warn_declaration_after_statement))
3493             pedwarn_c90 ("%HISO C90 forbids mixed declarations and code",
3494                          &loc);
3495           last_stmt = false;
3496         }
3497       else if (!last_label
3498                && c_parser_next_token_is_keyword (parser, RID_EXTENSION))
3499         {
3500           /* __extension__ can start a declaration, but is also an
3501              unary operator that can start an expression.  Consume all
3502              but the last of a possible series of __extension__ to
3503              determine which.  */
3504           while (c_parser_peek_2nd_token (parser)->type == CPP_KEYWORD
3505                  && (c_parser_peek_2nd_token (parser)->keyword
3506                      == RID_EXTENSION))
3507             c_parser_consume_token (parser);
3508           if (c_token_starts_declspecs (c_parser_peek_2nd_token (parser)))
3509             {
3510               int ext;
3511               ext = disable_extension_diagnostics ();
3512               c_parser_consume_token (parser);
3513               last_label = false;
3514               c_parser_declaration_or_fndef (parser, true, true, true, true);
3515               /* Following the old parser, __extension__ does not
3516                  disable this diagnostic.  */
3517               restore_extension_diagnostics (ext);
3518               if (last_stmt
3519                   && ((pedantic && !flag_isoc99)
3520                       || warn_declaration_after_statement))
3521                 pedwarn_c90 ("%HISO C90 forbids mixed declarations and code",
3522                              &loc);
3523               last_stmt = false;
3524             }
3525           else
3526             goto statement;
3527         }
3528       else if (c_parser_next_token_is (parser, CPP_PRAGMA))
3529         {
3530           /* External pragmas, and some omp pragmas, are not associated
3531              with regular c code, and so are not to be considered statements
3532              syntactically.  This ensures that the user doesn't put them
3533              places that would turn into syntax errors if the directive
3534              were ignored.  */
3535           if (c_parser_pragma (parser, pragma_compound))
3536             last_label = false, last_stmt = true;
3537         }
3538       else if (c_parser_next_token_is (parser, CPP_EOF))
3539         {
3540           c_parser_error (parser, "expected declaration or statement");
3541           return;
3542         }
3543       else if (c_parser_next_token_is_keyword (parser, RID_ELSE))
3544         {
3545           if (parser->in_if_block) 
3546             {
3547               error ("%H""expected %<}%> before %<else%>", &loc);
3548               return;
3549             }
3550           else 
3551             {
3552               error ("%H%<else%> without a previous %<if%>", &loc);
3553               c_parser_consume_token (parser);
3554               continue;
3555             }
3556         }
3557       else
3558         {
3559         statement:
3560           last_label = false;
3561           last_stmt = true;
3562           c_parser_statement_after_labels (parser);
3563         }
3564
3565       parser->error = false;
3566     }
3567   if (last_label)
3568     error ("%Hlabel at end of compound statement", &label_loc);
3569   c_parser_consume_token (parser);
3570 }
3571
3572 /* Parse a label (C90 6.6.1, C99 6.8.1).
3573
3574    label:
3575      identifier : attributes[opt]
3576      case constant-expression :
3577      default :
3578
3579    GNU extensions:
3580
3581    label:
3582      case constant-expression ... constant-expression :
3583
3584    The use of attributes on labels is a GNU extension.  The syntax in
3585    GNU C accepts any expressions without commas, non-constant
3586    expressions being rejected later.  */
3587
3588 static void
3589 c_parser_label (c_parser *parser)
3590 {
3591   location_t loc1 = c_parser_peek_token (parser)->location;
3592   tree label = NULL_TREE;
3593   if (c_parser_next_token_is_keyword (parser, RID_CASE))
3594     {
3595       tree exp1, exp2;
3596       c_parser_consume_token (parser);
3597       exp1 = c_parser_expr_no_commas (parser, NULL).value;
3598       if (c_parser_next_token_is (parser, CPP_COLON))
3599         {
3600           c_parser_consume_token (parser);
3601           label = do_case (exp1, NULL_TREE);
3602         }
3603       else if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
3604         {
3605           c_parser_consume_token (parser);
3606           exp2 = c_parser_expr_no_commas (parser, NULL).value;
3607           if (c_parser_require (parser, CPP_COLON, "expected %<:%>"))
3608             label = do_case (exp1, exp2);
3609         }
3610       else
3611         c_parser_error (parser, "expected %<:%> or %<...%>");
3612     }
3613   else if (c_parser_next_token_is_keyword (parser, RID_DEFAULT))
3614     {
3615       c_parser_consume_token (parser);
3616       if (c_parser_require (parser, CPP_COLON, "expected %<:%>"))
3617         label = do_case (NULL_TREE, NULL_TREE);
3618     }
3619   else
3620     {
3621       tree name = c_parser_peek_token (parser)->value;
3622       tree tlab;
3623       tree attrs;
3624       location_t loc2 = c_parser_peek_token (parser)->location;
3625       gcc_assert (c_parser_next_token_is (parser, CPP_NAME));
3626       c_parser_consume_token (parser);
3627       gcc_assert (c_parser_next_token_is (parser, CPP_COLON));
3628       c_parser_consume_token (parser);
3629       attrs = c_parser_attributes (parser);
3630       tlab = define_label (loc2, name);
3631       if (tlab)
3632         {
3633           decl_attributes (&tlab, attrs, 0);
3634           label = add_stmt (build_stmt (LABEL_EXPR, tlab));
3635         }
3636     }
3637   if (label)
3638     {
3639       SET_EXPR_LOCATION (label, loc1);
3640       if (c_parser_next_token_starts_declspecs (parser)
3641           && !(c_parser_next_token_is (parser, CPP_NAME)
3642                && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
3643         {
3644           error ("%Ha label can only be part of a statement and "
3645                  "a declaration is not a statement",
3646                  &c_parser_peek_token (parser)->location);
3647           c_parser_declaration_or_fndef (parser, /*fndef_ok*/ false, 
3648                                          /*nested*/ true, /*empty_ok*/ false,
3649                                          /*start_attr_ok*/ true);
3650         }
3651     }
3652 }
3653
3654 /* Parse a statement (C90 6.6, C99 6.8).
3655
3656    statement:
3657      labeled-statement
3658      compound-statement
3659      expression-statement
3660      selection-statement
3661      iteration-statement
3662      jump-statement
3663
3664    labeled-statement:
3665      label statement
3666
3667    expression-statement:
3668      expression[opt] ;
3669
3670    selection-statement:
3671      if-statement
3672      switch-statement
3673
3674    iteration-statement:
3675      while-statement
3676      do-statement
3677      for-statement
3678
3679    jump-statement:
3680      goto identifier ;
3681      continue ;
3682      break ;
3683      return expression[opt] ;
3684
3685    GNU extensions:
3686
3687    statement:
3688      asm-statement
3689
3690    jump-statement:
3691      goto * expression ;
3692
3693    Objective-C:
3694
3695    statement:
3696      objc-throw-statement
3697      objc-try-catch-statement
3698      objc-synchronized-statement
3699
3700    objc-throw-statement:
3701      @throw expression ;
3702      @throw ;
3703
3704    OpenMP:
3705
3706    statement:
3707      openmp-construct
3708
3709    openmp-construct:
3710      parallel-construct
3711      for-construct
3712      sections-construct
3713      single-construct
3714      parallel-for-construct
3715      parallel-sections-construct
3716      master-construct
3717      critical-construct
3718      atomic-construct
3719      ordered-construct
3720
3721    parallel-construct:
3722      parallel-directive structured-block
3723
3724    for-construct:
3725      for-directive iteration-statement
3726
3727    sections-construct:
3728      sections-directive section-scope
3729
3730    single-construct:
3731      single-directive structured-block
3732
3733    parallel-for-construct:
3734      parallel-for-directive iteration-statement
3735
3736    parallel-sections-construct:
3737      parallel-sections-directive section-scope
3738
3739    master-construct:
3740      master-directive structured-block
3741
3742    critical-construct:
3743      critical-directive structured-block
3744
3745    atomic-construct:
3746      atomic-directive expression-statement
3747
3748    ordered-construct:
3749      ordered-directive structured-block  */
3750
3751 static void
3752 c_parser_statement (c_parser *parser)
3753 {
3754   while (c_parser_next_token_is_keyword (parser, RID_CASE)
3755          || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
3756          || (c_parser_next_token_is (parser, CPP_NAME)
3757              && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
3758     c_parser_label (parser);
3759   c_parser_statement_after_labels (parser);
3760 }
3761
3762 /* Parse a statement, other than a labeled statement.  */
3763
3764 static void
3765 c_parser_statement_after_labels (c_parser *parser)
3766 {
3767   location_t loc = c_parser_peek_token (parser)->location;
3768   tree stmt = NULL_TREE;
3769   bool in_if_block = parser->in_if_block;
3770   parser->in_if_block = false;
3771   switch (c_parser_peek_token (parser)->type)
3772     {
3773     case CPP_OPEN_BRACE:
3774       add_stmt (c_parser_compound_statement (parser));
3775       break;
3776     case CPP_KEYWORD:
3777       switch (c_parser_peek_token (parser)->keyword)
3778         {
3779         case RID_IF:
3780           c_parser_if_statement (parser);
3781           break;
3782         case RID_SWITCH:
3783           c_parser_switch_statement (parser);
3784           break;
3785         case RID_WHILE:
3786           c_parser_while_statement (parser);
3787           break;
3788         case RID_DO:
3789           c_parser_do_statement (parser);
3790           break;
3791         case RID_FOR:
3792           c_parser_for_statement (parser);
3793           break;
3794         case RID_GOTO:
3795           c_parser_consume_token (parser);
3796           if (c_parser_next_token_is (parser, CPP_NAME))
3797             {
3798               stmt = c_finish_goto_label (c_parser_peek_token (parser)->value);
3799               c_parser_consume_token (parser);
3800             }
3801           else if (c_parser_next_token_is (parser, CPP_MULT))
3802             {
3803               c_parser_consume_token (parser);
3804               stmt = c_finish_goto_ptr (c_parser_expression (parser).value);
3805             }
3806           else
3807             c_parser_error (parser, "expected identifier or %<*%>");
3808           goto expect_semicolon;
3809         case RID_CONTINUE:
3810           c_parser_consume_token (parser);
3811           stmt = c_finish_bc_stmt (&c_cont_label, false);
3812           goto expect_semicolon;
3813         case RID_BREAK:
3814           c_parser_consume_token (parser);
3815           stmt = c_finish_bc_stmt (&c_break_label, true);
3816           goto expect_semicolon;
3817         case RID_RETURN:
3818           c_parser_consume_token (parser);
3819           if (c_parser_next_token_is (parser, CPP_SEMICOLON))
3820             {
3821               stmt = c_finish_return (NULL_TREE);
3822               c_parser_consume_token (parser);
3823             }
3824           else
3825             {
3826               stmt = c_finish_return (c_parser_expression_conv (parser).value);
3827               goto expect_semicolon;
3828             }
3829           break;
3830         case RID_ASM:
3831           stmt = c_parser_asm_statement (parser);
3832           break;
3833         case RID_AT_THROW:
3834           gcc_assert (c_dialect_objc ());
3835           c_parser_consume_token (parser);
3836           if (c_parser_next_token_is (parser, CPP_SEMICOLON))
3837             {
3838               stmt = objc_build_throw_stmt (NULL_TREE);
3839               c_parser_consume_token (parser);
3840             }
3841           else
3842             {
3843               stmt
3844                 = objc_build_throw_stmt (c_parser_expression (parser).value);
3845               goto expect_semicolon;
3846             }
3847           break;
3848         case RID_AT_TRY:
3849           gcc_assert (c_dialect_objc ());
3850           c_parser_objc_try_catch_statement (parser);
3851           break;
3852         case RID_AT_SYNCHRONIZED:
3853           gcc_assert (c_dialect_objc ());
3854           c_parser_objc_synchronized_statement (parser);
3855           break;
3856         default:
3857           goto expr_stmt;
3858         }
3859       break;
3860     case CPP_SEMICOLON:
3861       c_parser_consume_token (parser);
3862       break;
3863     case CPP_CLOSE_PAREN:
3864     case CPP_CLOSE_SQUARE:
3865       /* Avoid infinite loop in error recovery:
3866          c_parser_skip_until_found stops at a closing nesting
3867          delimiter without consuming it, but here we need to consume
3868          it to proceed further.  */
3869       c_parser_error (parser, "expected statement");
3870       c_parser_consume_token (parser);
3871       break;
3872     case CPP_PRAGMA:
3873       c_parser_pragma (parser, pragma_stmt);
3874       break;
3875     default:
3876     expr_stmt:
3877       stmt = c_finish_expr_stmt (c_parser_expression_conv (parser).value);
3878     expect_semicolon:
3879       c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
3880       break;
3881     }
3882   /* Two cases cannot and do not have line numbers associated: If stmt
3883      is degenerate, such as "2;", then stmt is an INTEGER_CST, which
3884      cannot hold line numbers.  But that's OK because the statement
3885      will either be changed to a MODIFY_EXPR during gimplification of
3886      the statement expr, or discarded.  If stmt was compound, but
3887      without new variables, we will have skipped the creation of a
3888      BIND and will have a bare STATEMENT_LIST.  But that's OK because
3889      (recursively) all of the component statements should already have
3890      line numbers assigned.  ??? Can we discard no-op statements
3891      earlier?  */
3892   if (stmt && CAN_HAVE_LOCATION_P (stmt))
3893     SET_EXPR_LOCATION (stmt, loc);
3894
3895   parser->in_if_block = in_if_block;
3896 }
3897
3898 /* Parse a parenthesized condition from an if, do or while statement.
3899
3900    condition:
3901      ( expression )
3902 */
3903 static tree
3904 c_parser_paren_condition (c_parser *parser)
3905 {
3906   location_t loc;
3907   tree cond;
3908   if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
3909     return error_mark_node;
3910   loc = c_parser_peek_token (parser)->location;
3911   cond = c_objc_common_truthvalue_conversion
3912     (c_parser_expression_conv (parser).value);
3913   if (CAN_HAVE_LOCATION_P (cond))
3914     SET_EXPR_LOCATION (cond, loc);
3915   c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
3916   return cond;
3917 }
3918
3919 /* Parse a statement which is a block in C99.  */
3920
3921 static tree
3922 c_parser_c99_block_statement (c_parser *parser)
3923 {
3924   tree block = c_begin_compound_stmt (flag_isoc99);
3925   c_parser_statement (parser);
3926   return c_end_compound_stmt (block, flag_isoc99);
3927 }
3928
3929 /* Parse the body of an if statement.  This is just parsing a
3930    statement but (a) it is a block in C99, (b) we track whether the
3931    body is an if statement for the sake of -Wparentheses warnings, (c)
3932    we handle an empty body specially for the sake of -Wempty-body
3933    warnings, and (d) we call parser_compound_statement directly
3934    because c_parser_statement_after_labels resets
3935    parser->in_if_block.  */
3936
3937 static tree
3938 c_parser_if_body (c_parser *parser, bool *if_p)
3939 {
3940   tree block = c_begin_compound_stmt (flag_isoc99);
3941   while (c_parser_next_token_is_keyword (parser, RID_CASE)
3942          || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
3943          || (c_parser_next_token_is (parser, CPP_NAME)
3944              && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
3945     c_parser_label (parser);
3946   *if_p = c_parser_next_token_is_keyword (parser, RID_IF);
3947   if (c_parser_next_token_is (parser, CPP_SEMICOLON))
3948     {
3949       add_stmt (build_empty_stmt ());
3950       c_parser_consume_token (parser);
3951     }
3952   else if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
3953     add_stmt (c_parser_compound_statement (parser));
3954   else
3955     c_parser_statement_after_labels (parser);
3956   return c_end_compound_stmt (block, flag_isoc99);
3957 }
3958
3959 /* Parse the else body of an if statement.  This is just parsing a
3960    statement but (a) it is a block in C99, (b) we handle an empty body
3961    specially for the sake of -Wempty-body warnings.  */
3962
3963 static tree
3964 c_parser_else_body (c_parser *parser)
3965 {
3966   tree block = c_begin_compound_stmt (flag_isoc99);
3967   while (c_parser_next_token_is_keyword (parser, RID_CASE)
3968          || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
3969          || (c_parser_next_token_is (parser, CPP_NAME)
3970              && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
3971     c_parser_label (parser);
3972   if (c_parser_next_token_is (parser, CPP_SEMICOLON))
3973     {
3974       add_stmt (build_empty_stmt ());
3975       c_parser_consume_token (parser);
3976     }
3977   else 
3978     c_parser_statement_after_labels (parser);
3979   return c_end_compound_stmt (block, flag_isoc99);
3980 }
3981
3982 /* Parse an if statement (C90 6.6.4, C99 6.8.4).
3983
3984    if-statement:
3985      if ( expression ) statement
3986      if ( expression ) statement else statement
3987 */
3988
3989 static void
3990 c_parser_if_statement (c_parser *parser)
3991 {
3992   tree block;
3993   location_t loc;
3994   tree cond;
3995   bool first_if = false;
3996   tree first_body, second_body;
3997   bool in_if_block;
3998
3999   gcc_assert (c_parser_next_token_is_keyword (parser, RID_IF));
4000   c_parser_consume_token (parser);
4001   block = c_begin_compound_stmt (flag_isoc99);
4002   loc = c_parser_peek_token (parser)->location;
4003   cond = c_parser_paren_condition (parser);
4004   in_if_block = parser->in_if_block;
4005   parser->in_if_block = true;
4006   first_body = c_parser_if_body (parser, &first_if);
4007   parser->in_if_block = in_if_block;
4008   if (c_parser_next_token_is_keyword (parser, RID_ELSE))
4009     {
4010       c_parser_consume_token (parser);
4011       second_body = c_parser_else_body (parser);
4012     }
4013   else
4014     second_body = NULL_TREE;
4015   c_finish_if_stmt (loc, cond, first_body, second_body, first_if);
4016   add_stmt (c_end_compound_stmt (block, flag_isoc99));
4017 }
4018
4019 /* Parse a switch statement (C90 6.6.4, C99 6.8.4).
4020
4021    switch-statement:
4022      switch (expression) statement
4023 */
4024
4025 static void
4026 c_parser_switch_statement (c_parser *parser)
4027 {
4028   tree block, expr, body, save_break;
4029   gcc_assert (c_parser_next_token_is_keyword (parser, RID_SWITCH));
4030   c_parser_consume_token (parser);
4031   block = c_begin_compound_stmt (flag_isoc99);
4032   if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
4033     {
4034       expr = c_parser_expression (parser).value;
4035       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
4036     }
4037   else
4038     expr = error_mark_node;
4039   c_start_case (expr);
4040   save_break = c_break_label;
4041   c_break_label = NULL_TREE;
4042   body = c_parser_c99_block_statement (parser);
4043   c_finish_case (body);
4044   if (c_break_label)
4045     add_stmt (build1 (LABEL_EXPR, void_type_node, c_break_label));
4046   c_break_label = save_break;
4047   add_stmt (c_end_compound_stmt (block, flag_isoc99));
4048 }
4049
4050 /* Parse a while statement (C90 6.6.5, C99 6.8.5).
4051
4052    while-statement:
4053       while (expression) statement
4054 */
4055
4056 static void
4057 c_parser_while_statement (c_parser *parser)
4058 {
4059   tree block, cond, body, save_break, save_cont;
4060   location_t loc;
4061   gcc_assert (c_parser_next_token_is_keyword (parser, RID_WHILE));
4062   c_parser_consume_token (parser);
4063   block = c_begin_compound_stmt (flag_isoc99);
4064   loc = c_parser_peek_token (parser)->location;
4065   cond = c_parser_paren_condition (parser);
4066   save_break = c_break_label;
4067   c_break_label = NULL_TREE;
4068   save_cont = c_cont_label;
4069   c_cont_label = NULL_TREE;
4070   body = c_parser_c99_block_statement (parser);
4071   c_finish_loop (loc, cond, NULL, body, c_break_label, c_cont_label, true);
4072   add_stmt (c_end_compound_stmt (block, flag_isoc99));
4073   c_break_label = save_break;
4074   c_cont_label = save_cont;
4075 }
4076
4077 /* Parse a do statement (C90 6.6.5, C99 6.8.5).
4078
4079    do-statement:
4080      do statement while ( expression ) ;
4081 */
4082
4083 static void
4084 c_parser_do_statement (c_parser *parser)
4085 {
4086   tree block, cond, body, save_break, save_cont, new_break, new_cont;
4087   location_t loc;
4088   gcc_assert (c_parser_next_token_is_keyword (parser, RID_DO));
4089   c_parser_consume_token (parser);
4090   if (c_parser_next_token_is (parser, CPP_SEMICOLON))
4091     warning (OPT_Wempty_body,
4092              "%Hsuggest braces around empty body in %<do%> statement",
4093              &c_parser_peek_token (parser)->location);
4094   block = c_begin_compound_stmt (flag_isoc99);
4095   loc = c_parser_peek_token (parser)->location;