OSDN Git Service

d28ec9c91a9fa82bc16626f2ed0bcb9989df853c
[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_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 = 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
1022 enum pragma_context { pragma_external, pragma_stmt, pragma_compound };
1023 static bool c_parser_pragma (c_parser *, enum pragma_context);
1024
1025 /* These Objective-C parser functions are only ever called when
1026    compiling Objective-C.  */
1027 static void c_parser_objc_class_definition (c_parser *);
1028 static void c_parser_objc_class_instance_variables (c_parser *);
1029 static void c_parser_objc_class_declaration (c_parser *);
1030 static void c_parser_objc_alias_declaration (c_parser *);
1031 static void c_parser_objc_protocol_definition (c_parser *);
1032 static enum tree_code c_parser_objc_method_type (c_parser *);
1033 static void c_parser_objc_method_definition (c_parser *);
1034 static void c_parser_objc_methodprotolist (c_parser *);
1035 static void c_parser_objc_methodproto (c_parser *);
1036 static tree c_parser_objc_method_decl (c_parser *);
1037 static tree c_parser_objc_type_name (c_parser *);
1038 static tree c_parser_objc_protocol_refs (c_parser *);
1039 static void c_parser_objc_try_catch_statement (c_parser *);
1040 static void c_parser_objc_synchronized_statement (c_parser *);
1041 static tree c_parser_objc_selector (c_parser *);
1042 static tree c_parser_objc_selector_arg (c_parser *);
1043 static tree c_parser_objc_receiver (c_parser *);
1044 static tree c_parser_objc_message_args (c_parser *);
1045 static tree c_parser_objc_keywordexpr (c_parser *);
1046
1047 /* Parse a translation unit (C90 6.7, C99 6.9).
1048
1049    translation-unit:
1050      external-declarations
1051
1052    external-declarations:
1053      external-declaration
1054      external-declarations external-declaration
1055
1056    GNU extensions:
1057
1058    translation-unit:
1059      empty
1060 */
1061
1062 static void
1063 c_parser_translation_unit (c_parser *parser)
1064 {
1065   if (c_parser_next_token_is (parser, CPP_EOF))
1066     {
1067       if (pedantic)
1068         pedwarn ("%HISO C forbids an empty translation unit",
1069                  &c_parser_peek_token (parser)->location);
1070     }
1071   else
1072     {
1073       void *obstack_position = obstack_alloc (&parser_obstack, 0);
1074       do
1075         {
1076           ggc_collect ();
1077           c_parser_external_declaration (parser);
1078           obstack_free (&parser_obstack, obstack_position);
1079         }
1080       while (c_parser_next_token_is_not (parser, CPP_EOF));
1081     }
1082 }
1083
1084 /* Parse an external declaration (C90 6.7, C99 6.9).
1085
1086    external-declaration:
1087      function-definition
1088      declaration
1089
1090    GNU extensions:
1091
1092    external-declaration:
1093      asm-definition
1094      ;
1095      __extension__ external-declaration
1096
1097    Objective-C:
1098
1099    external-declaration:
1100      objc-class-definition
1101      objc-class-declaration
1102      objc-alias-declaration
1103      objc-protocol-definition
1104      objc-method-definition
1105      @end
1106 */
1107
1108 static void
1109 c_parser_external_declaration (c_parser *parser)
1110 {
1111   int ext;
1112   switch (c_parser_peek_token (parser)->type)
1113     {
1114     case CPP_KEYWORD:
1115       switch (c_parser_peek_token (parser)->keyword)
1116         {
1117         case RID_EXTENSION:
1118           ext = disable_extension_diagnostics ();
1119           c_parser_consume_token (parser);
1120           c_parser_external_declaration (parser);
1121           restore_extension_diagnostics (ext);
1122           break;
1123         case RID_ASM:
1124           c_parser_asm_definition (parser);
1125           break;
1126         case RID_AT_INTERFACE:
1127         case RID_AT_IMPLEMENTATION:
1128           gcc_assert (c_dialect_objc ());
1129           c_parser_objc_class_definition (parser);
1130           break;
1131         case RID_AT_CLASS:
1132           gcc_assert (c_dialect_objc ());
1133           c_parser_objc_class_declaration (parser);
1134           break;
1135         case RID_AT_ALIAS:
1136           gcc_assert (c_dialect_objc ());
1137           c_parser_objc_alias_declaration (parser);
1138           break;
1139         case RID_AT_PROTOCOL:
1140           gcc_assert (c_dialect_objc ());
1141           c_parser_objc_protocol_definition (parser);
1142           break;
1143         case RID_AT_END:
1144           gcc_assert (c_dialect_objc ());
1145           c_parser_consume_token (parser);
1146           objc_finish_implementation ();
1147           break;
1148         default:
1149           goto decl_or_fndef;
1150         }
1151       break;
1152     case CPP_SEMICOLON:
1153       if (pedantic)
1154         pedwarn ("%HISO C does not allow extra %<;%> outside of a function",
1155                  &c_parser_peek_token (parser)->location);
1156       c_parser_consume_token (parser);
1157       break;
1158     case CPP_PRAGMA:
1159       c_parser_pragma (parser, pragma_external);
1160       break;
1161     case CPP_PLUS:
1162     case CPP_MINUS:
1163       if (c_dialect_objc ())
1164         {
1165           c_parser_objc_method_definition (parser);
1166           break;
1167         }
1168       /* Else fall through, and yield a syntax error trying to parse
1169          as a declaration or function definition.  */
1170     default:
1171     decl_or_fndef:
1172       /* A declaration or a function definition.  We can only tell
1173          which after parsing the declaration specifiers, if any, and
1174          the first declarator.  */
1175       c_parser_declaration_or_fndef (parser, true, true, false, true);
1176       break;
1177     }
1178 }
1179
1180
1181 /* Parse a declaration or function definition (C90 6.5, 6.7.1, C99
1182    6.7, 6.9.1).  If FNDEF_OK is true, a function definition is
1183    accepted; otherwise (old-style parameter declarations) only other
1184    declarations are accepted.  If NESTED is true, we are inside a
1185    function or parsing old-style parameter declarations; any functions
1186    encountered are nested functions and declaration specifiers are
1187    required; otherwise we are at top level and functions are normal
1188    functions and declaration specifiers may be optional.  If EMPTY_OK
1189    is true, empty declarations are OK (subject to all other
1190    constraints); otherwise (old-style parameter declarations) they are
1191    diagnosed.  If START_ATTR_OK is true, the declaration specifiers
1192    may start with attributes; otherwise they may not.
1193
1194    declaration:
1195      declaration-specifiers init-declarator-list[opt] ;
1196
1197    function-definition:
1198      declaration-specifiers[opt] declarator declaration-list[opt]
1199        compound-statement
1200
1201    declaration-list:
1202      declaration
1203      declaration-list declaration
1204
1205    init-declarator-list:
1206      init-declarator
1207      init-declarator-list , init-declarator
1208
1209    init-declarator:
1210      declarator simple-asm-expr[opt] attributes[opt]
1211      declarator simple-asm-expr[opt] attributes[opt] = initializer
1212
1213    GNU extensions:
1214
1215    nested-function-definition:
1216      declaration-specifiers declarator declaration-list[opt]
1217        compound-statement
1218
1219    The simple-asm-expr and attributes are GNU extensions.
1220
1221    This function does not handle __extension__; that is handled in its
1222    callers.  ??? Following the old parser, __extension__ may start
1223    external declarations, declarations in functions and declarations
1224    at the start of "for" loops, but not old-style parameter
1225    declarations.
1226
1227    C99 requires declaration specifiers in a function definition; the
1228    absence is diagnosed through the diagnosis of implicit int.  In GNU
1229    C we also allow but diagnose declarations without declaration
1230    specifiers, but only at top level (elsewhere they conflict with
1231    other syntax).
1232    
1233    OpenMP:
1234    
1235    declaration:
1236      threadprivate-directive  */
1237
1238 static void
1239 c_parser_declaration_or_fndef (c_parser *parser, bool fndef_ok, bool empty_ok,
1240                                bool nested, bool start_attr_ok)
1241 {
1242   struct c_declspecs *specs;
1243   tree prefix_attrs;
1244   tree all_prefix_attrs;
1245   bool diagnosed_no_specs = false;
1246   location_t here = c_parser_peek_token (parser)->location;
1247
1248   specs = build_null_declspecs ();
1249   c_parser_declspecs (parser, specs, true, true, start_attr_ok);
1250   if (parser->error)
1251     {
1252       c_parser_skip_to_end_of_block_or_statement (parser);
1253       return;
1254     }
1255   if (nested && !specs->declspecs_seen_p)
1256     {
1257       c_parser_error (parser, "expected declaration specifiers");
1258       c_parser_skip_to_end_of_block_or_statement (parser);
1259       return;
1260     }
1261   finish_declspecs (specs);
1262   if (c_parser_next_token_is (parser, CPP_SEMICOLON))
1263     {
1264       if (empty_ok)
1265         shadow_tag (specs);
1266       else
1267         {
1268           shadow_tag_warned (specs, 1);
1269           pedwarn ("%Hempty declaration", &here);
1270         }
1271       c_parser_consume_token (parser);
1272       return;
1273     }
1274   pending_xref_error ();
1275   prefix_attrs = specs->attrs;
1276   all_prefix_attrs = prefix_attrs;
1277   specs->attrs = NULL_TREE;
1278   while (true)
1279     {
1280       struct c_declarator *declarator;
1281       bool dummy = false;
1282       tree fnbody;
1283       /* Declaring either one or more declarators (in which case we
1284          should diagnose if there were no declaration specifiers) or a
1285          function definition (in which case the diagnostic for
1286          implicit int suffices).  */
1287       declarator = c_parser_declarator (parser, specs->type_seen_p,
1288                                         C_DTR_NORMAL, &dummy);
1289       if (declarator == NULL)
1290         {
1291           c_parser_skip_to_end_of_block_or_statement (parser);
1292           return;
1293         }
1294       if (c_parser_next_token_is (parser, CPP_EQ)
1295           || c_parser_next_token_is (parser, CPP_COMMA)
1296           || c_parser_next_token_is (parser, CPP_SEMICOLON)
1297           || c_parser_next_token_is_keyword (parser, RID_ASM)
1298           || c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
1299         {
1300           tree asm_name = NULL_TREE;
1301           tree postfix_attrs = NULL_TREE;
1302           if (!diagnosed_no_specs && !specs->declspecs_seen_p)
1303             {
1304               diagnosed_no_specs = true;
1305               pedwarn ("%Hdata definition has no type or storage class",
1306                        &here);
1307             }
1308           /* Having seen a data definition, there cannot now be a
1309              function definition.  */
1310           fndef_ok = false;
1311           if (c_parser_next_token_is_keyword (parser, RID_ASM))
1312             asm_name = c_parser_simple_asm_expr (parser);
1313           if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
1314             postfix_attrs = c_parser_attributes (parser);
1315           if (c_parser_next_token_is (parser, CPP_EQ))
1316             {
1317               tree d;
1318               struct c_expr init;
1319               c_parser_consume_token (parser);
1320               /* The declaration of the variable is in effect while
1321                  its initializer is parsed.  */
1322               d = start_decl (declarator, specs, true,
1323                               chainon (postfix_attrs, all_prefix_attrs));
1324               if (!d)
1325                 d = error_mark_node;
1326               start_init (d, asm_name, global_bindings_p ());
1327               init = c_parser_initializer (parser);
1328               finish_init ();
1329               if (d != error_mark_node)
1330                 {
1331                   maybe_warn_string_init (TREE_TYPE (d), init);
1332                   finish_decl (d, init.value, asm_name);
1333                 }
1334             }
1335           else
1336             {
1337               tree d = start_decl (declarator, specs, false,
1338                                    chainon (postfix_attrs,
1339                                             all_prefix_attrs));
1340               if (d)
1341                 finish_decl (d, NULL_TREE, asm_name);
1342             }
1343           if (c_parser_next_token_is (parser, CPP_COMMA))
1344             {
1345               c_parser_consume_token (parser);
1346               if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
1347                 all_prefix_attrs = chainon (c_parser_attributes (parser),
1348                                             prefix_attrs);
1349               else
1350                 all_prefix_attrs = prefix_attrs;
1351               continue;
1352             }
1353           else if (c_parser_next_token_is (parser, CPP_SEMICOLON))
1354             {
1355               c_parser_consume_token (parser);
1356               return;
1357             }
1358           else
1359             {
1360               c_parser_error (parser, "expected %<,%> or %<;%>");
1361               c_parser_skip_to_end_of_block_or_statement (parser);
1362               return;
1363             }
1364         }
1365       else if (!fndef_ok)
1366         {
1367           c_parser_error (parser, "expected %<=%>, %<,%>, %<;%>, "
1368                           "%<asm%> or %<__attribute__%>");
1369           c_parser_skip_to_end_of_block_or_statement (parser);
1370           return;
1371         }
1372       /* Function definition (nested or otherwise).  */
1373       if (nested)
1374         {
1375           if (pedantic)
1376             pedwarn ("%HISO C forbids nested functions", &here);
1377           c_push_function_context ();
1378         }
1379       if (!start_function (specs, declarator, all_prefix_attrs))
1380         {
1381           /* This can appear in many cases looking nothing like a
1382              function definition, so we don't give a more specific
1383              error suggesting there was one.  */
1384           c_parser_error (parser, "expected %<=%>, %<,%>, %<;%>, %<asm%> "
1385                           "or %<__attribute__%>");
1386           if (nested)
1387             c_pop_function_context ();
1388           break;
1389         }
1390       /* Parse old-style parameter declarations.  ??? Attributes are
1391          not allowed to start declaration specifiers here because of a
1392          syntax conflict between a function declaration with attribute
1393          suffix and a function definition with an attribute prefix on
1394          first old-style parameter declaration.  Following the old
1395          parser, they are not accepted on subsequent old-style
1396          parameter declarations either.  However, there is no
1397          ambiguity after the first declaration, nor indeed on the
1398          first as long as we don't allow postfix attributes after a
1399          declarator with a nonempty identifier list in a definition;
1400          and postfix attributes have never been accepted here in
1401          function definitions either.  */
1402       while (c_parser_next_token_is_not (parser, CPP_EOF)
1403              && c_parser_next_token_is_not (parser, CPP_OPEN_BRACE))
1404         c_parser_declaration_or_fndef (parser, false, false, true, false);
1405       DECL_SOURCE_LOCATION (current_function_decl)
1406         = c_parser_peek_token (parser)->location;
1407       store_parm_decls ();
1408       fnbody = c_parser_compound_statement (parser);
1409       if (nested)
1410         {
1411           tree decl = current_function_decl;
1412           add_stmt (fnbody);
1413           finish_function ();
1414           c_pop_function_context ();
1415           add_stmt (build_stmt (DECL_EXPR, decl));
1416         }
1417       else
1418         {
1419           add_stmt (fnbody);
1420           finish_function ();
1421         }
1422       break;
1423     }
1424 }
1425
1426 /* Parse an asm-definition (asm() outside a function body).  This is a
1427    GNU extension.
1428
1429    asm-definition:
1430      simple-asm-expr ;
1431 */
1432
1433 static void
1434 c_parser_asm_definition (c_parser *parser)
1435 {
1436   tree asm_str = c_parser_simple_asm_expr (parser);
1437   if (asm_str)
1438     cgraph_add_asm_node (asm_str);
1439   c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
1440 }
1441
1442 /* Parse some declaration specifiers (possibly none) (C90 6.5, C99
1443    6.7), adding them to SPECS (which may already include some).
1444    Storage class specifiers are accepted iff SCSPEC_OK; type
1445    specifiers are accepted iff TYPESPEC_OK; attributes are accepted at
1446    the start iff START_ATTR_OK.
1447
1448    declaration-specifiers:
1449      storage-class-specifier declaration-specifiers[opt]
1450      type-specifier declaration-specifiers[opt]
1451      type-qualifier declaration-specifiers[opt]
1452      function-specifier declaration-specifiers[opt]
1453
1454    Function specifiers (inline) are from C99, and are currently
1455    handled as storage class specifiers, as is __thread.
1456
1457    C90 6.5.1, C99 6.7.1:
1458    storage-class-specifier:
1459      typedef
1460      extern
1461      static
1462      auto
1463      register
1464
1465    C99 6.7.4:
1466    function-specifier:
1467      inline
1468
1469    C90 6.5.2, C99 6.7.2:
1470    type-specifier:
1471      void
1472      char
1473      short
1474      int
1475      long
1476      float
1477      double
1478      signed
1479      unsigned
1480      _Bool
1481      _Complex
1482      [_Imaginary removed in C99 TC2]
1483      struct-or-union-specifier
1484      enum-specifier
1485      typedef-name
1486
1487    (_Bool and _Complex are new in C99.)
1488
1489    C90 6.5.3, C99 6.7.3:
1490
1491    type-qualifier:
1492      const
1493      restrict
1494      volatile
1495
1496    (restrict is new in C99.)
1497
1498    GNU extensions:
1499
1500    declaration-specifiers:
1501      attributes declaration-specifiers[opt]
1502
1503    storage-class-specifier:
1504      __thread
1505
1506    type-specifier:
1507      typeof-specifier
1508      _Decimal32
1509      _Decimal64
1510      _Decimal128
1511      _Fract
1512      _Accum
1513      _Sat
1514
1515   (_Fract, _Accum, and _Sat are new from ISO/IEC DTR 18037:
1516    http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1169.pdf)
1517
1518    Objective-C:
1519
1520    type-specifier:
1521      class-name objc-protocol-refs[opt]
1522      typedef-name objc-protocol-refs
1523      objc-protocol-refs
1524 */
1525
1526 static void
1527 c_parser_declspecs (c_parser *parser, struct c_declspecs *specs,
1528                     bool scspec_ok, bool typespec_ok, bool start_attr_ok)
1529 {
1530   bool attrs_ok = start_attr_ok;
1531   bool seen_type = specs->type_seen_p;
1532   while (c_parser_next_token_is (parser, CPP_NAME)
1533          || c_parser_next_token_is (parser, CPP_KEYWORD)
1534          || (c_dialect_objc () && c_parser_next_token_is (parser, CPP_LESS)))
1535     {
1536       struct c_typespec t;
1537       tree attrs;
1538       if (c_parser_next_token_is (parser, CPP_NAME))
1539         {
1540           tree value = c_parser_peek_token (parser)->value;
1541           c_id_kind kind = c_parser_peek_token (parser)->id_kind;
1542           /* This finishes the specifiers unless a type name is OK, it
1543              is declared as a type name and a type name hasn't yet
1544              been seen.  */
1545           if (!typespec_ok || seen_type
1546               || (kind != C_ID_TYPENAME && kind != C_ID_CLASSNAME))
1547             break;
1548           c_parser_consume_token (parser);
1549           seen_type = true;
1550           attrs_ok = true;
1551           if (kind == C_ID_TYPENAME
1552               && (!c_dialect_objc ()
1553                   || c_parser_next_token_is_not (parser, CPP_LESS)))
1554             {
1555               t.kind = ctsk_typedef;
1556               /* For a typedef name, record the meaning, not the name.
1557                  In case of 'foo foo, bar;'.  */
1558               t.spec = lookup_name (value);
1559             }
1560           else
1561             {
1562               tree proto = NULL_TREE;
1563               gcc_assert (c_dialect_objc ());
1564               t.kind = ctsk_objc;
1565               if (c_parser_next_token_is (parser, CPP_LESS))
1566                 proto = c_parser_objc_protocol_refs (parser);
1567               t.spec = objc_get_protocol_qualified_type (value, proto);
1568             }
1569           declspecs_add_type (specs, t);
1570           continue;
1571         }
1572       if (c_parser_next_token_is (parser, CPP_LESS))
1573         {
1574           /* Make "<SomeProtocol>" equivalent to "id <SomeProtocol>" -
1575              nisse@lysator.liu.se.  */
1576           tree proto;
1577           gcc_assert (c_dialect_objc ());
1578           if (!typespec_ok || seen_type)
1579             break;
1580           proto = c_parser_objc_protocol_refs (parser);
1581           t.kind = ctsk_objc;
1582           t.spec = objc_get_protocol_qualified_type (NULL_TREE, proto);
1583           declspecs_add_type (specs, t);
1584           continue;
1585         }
1586       gcc_assert (c_parser_next_token_is (parser, CPP_KEYWORD));
1587       switch (c_parser_peek_token (parser)->keyword)
1588         {
1589         case RID_STATIC:
1590         case RID_EXTERN:
1591         case RID_REGISTER:
1592         case RID_TYPEDEF:
1593         case RID_INLINE:
1594         case RID_AUTO:
1595         case RID_THREAD:
1596           if (!scspec_ok)
1597             goto out;
1598           attrs_ok = true;
1599           /* TODO: Distinguish between function specifiers (inline)
1600              and storage class specifiers, either here or in
1601              declspecs_add_scspec.  */
1602           declspecs_add_scspec (specs, c_parser_peek_token (parser)->value);
1603           c_parser_consume_token (parser);
1604           break;
1605         case RID_UNSIGNED:
1606         case RID_LONG:
1607         case RID_SHORT:
1608         case RID_SIGNED:
1609         case RID_COMPLEX:
1610         case RID_INT:
1611         case RID_CHAR:
1612         case RID_FLOAT:
1613         case RID_DOUBLE:
1614         case RID_VOID:
1615         case RID_DFLOAT32:
1616         case RID_DFLOAT64:
1617         case RID_DFLOAT128:
1618         case RID_BOOL:
1619         case RID_FRACT:
1620         case RID_ACCUM:
1621         case RID_SAT:
1622           if (!typespec_ok)
1623             goto out;
1624           attrs_ok = true;
1625           seen_type = true;
1626           if (c_dialect_objc ())
1627             parser->objc_need_raw_identifier = true;
1628           t.kind = ctsk_resword;
1629           t.spec = c_parser_peek_token (parser)->value;
1630           declspecs_add_type (specs, t);
1631           c_parser_consume_token (parser);
1632           break;
1633         case RID_ENUM:
1634           if (!typespec_ok)
1635             goto out;
1636           attrs_ok = true;
1637           seen_type = true;
1638           t = c_parser_enum_specifier (parser);
1639           declspecs_add_type (specs, t);
1640           break;
1641         case RID_STRUCT:
1642         case RID_UNION:
1643           if (!typespec_ok)
1644             goto out;
1645           attrs_ok = true;
1646           seen_type = true;
1647           t = c_parser_struct_or_union_specifier (parser);
1648           declspecs_add_type (specs, t);
1649           break;
1650         case RID_TYPEOF:
1651           /* ??? The old parser rejected typeof after other type
1652              specifiers, but is a syntax error the best way of
1653              handling this?  */
1654           if (!typespec_ok || seen_type)
1655             goto out;
1656           attrs_ok = true;
1657           seen_type = true;
1658           t = c_parser_typeof_specifier (parser);
1659           declspecs_add_type (specs, t);
1660           break;
1661         case RID_CONST:
1662         case RID_VOLATILE:
1663         case RID_RESTRICT:
1664           attrs_ok = true;
1665           declspecs_add_qual (specs, c_parser_peek_token (parser)->value);
1666           c_parser_consume_token (parser);
1667           break;
1668         case RID_ATTRIBUTE:
1669           if (!attrs_ok)
1670             goto out;
1671           attrs = c_parser_attributes (parser);
1672           declspecs_add_attrs (specs, attrs);
1673           break;
1674         default:
1675           goto out;
1676         }
1677     }
1678  out: ;
1679 }
1680
1681 /* Parse an enum specifier (C90 6.5.2.2, C99 6.7.2.2).
1682
1683    enum-specifier:
1684      enum attributes[opt] identifier[opt] { enumerator-list } attributes[opt]
1685      enum attributes[opt] identifier[opt] { enumerator-list , } attributes[opt]
1686      enum attributes[opt] identifier
1687
1688    The form with trailing comma is new in C99.  The forms with
1689    attributes are GNU extensions.  In GNU C, we accept any expression
1690    without commas in the syntax (assignment expressions, not just
1691    conditional expressions); assignment expressions will be diagnosed
1692    as non-constant.
1693
1694    enumerator-list:
1695      enumerator
1696      enumerator-list , enumerator
1697
1698    enumerator:
1699      enumeration-constant
1700      enumeration-constant = constant-expression
1701 */
1702
1703 static struct c_typespec
1704 c_parser_enum_specifier (c_parser *parser)
1705 {
1706   struct c_typespec ret;
1707   tree attrs;
1708   tree ident = NULL_TREE;
1709   location_t ident_loc;
1710   gcc_assert (c_parser_next_token_is_keyword (parser, RID_ENUM));
1711   c_parser_consume_token (parser);
1712   attrs = c_parser_attributes (parser);
1713   /* Set the location in case we create a decl now.  */
1714   c_parser_set_source_position_from_token (c_parser_peek_token (parser));
1715   if (c_parser_next_token_is (parser, CPP_NAME))
1716     {
1717       ident = c_parser_peek_token (parser)->value;
1718       ident_loc = c_parser_peek_token (parser)->location;
1719       c_parser_consume_token (parser);
1720     }
1721   if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
1722     {
1723       /* Parse an enum definition.  */
1724       struct c_enum_contents the_enum;
1725       tree type = start_enum (&the_enum, ident);
1726       tree postfix_attrs;
1727       /* We chain the enumerators in reverse order, then put them in
1728          forward order at the end.  */
1729       tree values = NULL_TREE;
1730       c_parser_consume_token (parser);
1731       while (true)
1732         {
1733           tree enum_id;
1734           tree enum_value;
1735           tree enum_decl;
1736           bool seen_comma;
1737           c_token *token;
1738           location_t comma_loc;
1739           if (c_parser_next_token_is_not (parser, CPP_NAME))
1740             {
1741               c_parser_error (parser, "expected identifier");
1742               c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL);
1743               values = error_mark_node;
1744               break;
1745             }
1746           token = c_parser_peek_token (parser);
1747           enum_id = token->value;
1748           /* Set the location in case we create a decl now.  */
1749           c_parser_set_source_position_from_token (token);
1750           c_parser_consume_token (parser);
1751           if (c_parser_next_token_is (parser, CPP_EQ))
1752             {
1753               c_parser_consume_token (parser);
1754               enum_value = c_parser_expr_no_commas (parser, NULL).value;
1755             }
1756           else
1757             enum_value = NULL_TREE;
1758           enum_decl = build_enumerator (&the_enum, enum_id, enum_value);
1759           TREE_CHAIN (enum_decl) = values;
1760           values = enum_decl;
1761           seen_comma = false;
1762           if (c_parser_next_token_is (parser, CPP_COMMA))
1763             {
1764               comma_loc = c_parser_peek_token (parser)->location;
1765               seen_comma = true;
1766               c_parser_consume_token (parser);
1767             }
1768           if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
1769             {
1770               if (seen_comma && pedantic && !flag_isoc99)
1771                 pedwarn ("%Hcomma at end of enumerator list", &comma_loc);
1772               c_parser_consume_token (parser);
1773               break;
1774             }
1775           if (!seen_comma)
1776             {
1777               c_parser_error (parser, "expected %<,%> or %<}%>");
1778               c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL);
1779               values = error_mark_node;
1780               break;
1781             }
1782         }
1783       postfix_attrs = c_parser_attributes (parser);
1784       ret.spec = finish_enum (type, nreverse (values),
1785                               chainon (attrs, postfix_attrs));
1786       ret.kind = ctsk_tagdef;
1787       return ret;
1788     }
1789   else if (!ident)
1790     {
1791       c_parser_error (parser, "expected %<{%>");
1792       ret.spec = error_mark_node;
1793       ret.kind = ctsk_tagref;
1794       return ret;
1795     }
1796   ret = parser_xref_tag (ENUMERAL_TYPE, ident);
1797   /* In ISO C, enumerated types can be referred to only if already
1798      defined.  */
1799   if (pedantic && !COMPLETE_TYPE_P (ret.spec))
1800     {
1801       gcc_assert (ident);
1802       pedwarn ("%HISO C forbids forward references to %<enum%> types",
1803                &ident_loc);
1804     }
1805   return ret;
1806 }
1807
1808 /* Parse a struct or union specifier (C90 6.5.2.1, C99 6.7.2.1).
1809
1810    struct-or-union-specifier:
1811      struct-or-union attributes[opt] identifier[opt]
1812        { struct-contents } attributes[opt]
1813      struct-or-union attributes[opt] identifier
1814
1815    struct-contents:
1816      struct-declaration-list
1817
1818    struct-declaration-list:
1819      struct-declaration ;
1820      struct-declaration-list struct-declaration ;
1821
1822    GNU extensions:
1823
1824    struct-contents:
1825      empty
1826      struct-declaration
1827      struct-declaration-list struct-declaration
1828
1829    struct-declaration-list:
1830      struct-declaration-list ;
1831      ;
1832
1833    (Note that in the syntax here, unlike that in ISO C, the semicolons
1834    are included here rather than in struct-declaration, in order to
1835    describe the syntax with extra semicolons and missing semicolon at
1836    end.)
1837
1838    Objective-C:
1839
1840    struct-declaration-list:
1841      @defs ( class-name )
1842
1843    (Note this does not include a trailing semicolon, but can be
1844    followed by further declarations, and gets a pedwarn-if-pedantic
1845    when followed by a semicolon.)  */
1846
1847 static struct c_typespec
1848 c_parser_struct_or_union_specifier (c_parser *parser)
1849 {
1850   struct c_typespec ret;
1851   tree attrs;
1852   tree ident = NULL_TREE;
1853   enum tree_code code;
1854   switch (c_parser_peek_token (parser)->keyword)
1855     {
1856     case RID_STRUCT:
1857       code = RECORD_TYPE;
1858       break;
1859     case RID_UNION:
1860       code = UNION_TYPE;
1861       break;
1862     default:
1863       gcc_unreachable ();
1864     }
1865   c_parser_consume_token (parser);
1866   attrs = c_parser_attributes (parser);
1867   /* Set the location in case we create a decl now.  */
1868   c_parser_set_source_position_from_token (c_parser_peek_token (parser));
1869   if (c_parser_next_token_is (parser, CPP_NAME))
1870     {
1871       ident = c_parser_peek_token (parser)->value;
1872       c_parser_consume_token (parser);
1873     }
1874   if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
1875     {
1876       /* Parse a struct or union definition.  Start the scope of the
1877          tag before parsing components.  */
1878       tree type = start_struct (code, ident);
1879       tree postfix_attrs;
1880       /* We chain the components in reverse order, then put them in
1881          forward order at the end.  Each struct-declaration may
1882          declare multiple components (comma-separated), so we must use
1883          chainon to join them, although when parsing each
1884          struct-declaration we can use TREE_CHAIN directly.
1885
1886          The theory behind all this is that there will be more
1887          semicolon separated fields than comma separated fields, and
1888          so we'll be minimizing the number of node traversals required
1889          by chainon.  */
1890       tree contents = NULL_TREE;
1891       c_parser_consume_token (parser);
1892       /* Handle the Objective-C @defs construct,
1893          e.g. foo(sizeof(struct{ @defs(ClassName) }));.  */
1894       if (c_parser_next_token_is_keyword (parser, RID_AT_DEFS))
1895         {
1896           tree name;
1897           gcc_assert (c_dialect_objc ());
1898           c_parser_consume_token (parser);
1899           if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
1900             goto end_at_defs;
1901           if (c_parser_next_token_is (parser, CPP_NAME)
1902               && c_parser_peek_token (parser)->id_kind == C_ID_CLASSNAME)
1903             {
1904               name = c_parser_peek_token (parser)->value;
1905               c_parser_consume_token (parser);
1906             }
1907           else
1908             {
1909               c_parser_error (parser, "expected class name");
1910               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
1911               goto end_at_defs;
1912             }
1913           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
1914                                      "expected %<)%>");
1915           contents = nreverse (objc_get_class_ivars (name));
1916         }
1917     end_at_defs:
1918       /* Parse the struct-declarations and semicolons.  Problems with
1919          semicolons are diagnosed here; empty structures are diagnosed
1920          elsewhere.  */
1921       while (true)
1922         {
1923           tree decls;
1924           /* Parse any stray semicolon.  */
1925           if (c_parser_next_token_is (parser, CPP_SEMICOLON))
1926             {
1927               if (pedantic)
1928                 pedwarn ("%Hextra semicolon in struct or union specified",
1929                          &c_parser_peek_token (parser)->location);
1930               c_parser_consume_token (parser);
1931               continue;
1932             }
1933           /* Stop if at the end of the struct or union contents.  */
1934           if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
1935             {
1936               c_parser_consume_token (parser);
1937               break;
1938             }
1939           /* Accept #pragmas at struct scope.  */
1940           if (c_parser_next_token_is (parser, CPP_PRAGMA))
1941             {
1942               c_parser_pragma (parser, pragma_external);
1943               continue;
1944             }
1945           /* Parse some comma-separated declarations, but not the
1946              trailing semicolon if any.  */
1947           decls = c_parser_struct_declaration (parser);
1948           contents = chainon (decls, contents);
1949           /* If no semicolon follows, either we have a parse error or
1950              are at the end of the struct or union and should
1951              pedwarn.  */
1952           if (c_parser_next_token_is (parser, CPP_SEMICOLON))
1953             c_parser_consume_token (parser);
1954           else
1955             {
1956               if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
1957                 pedwarn ("%Hno semicolon at end of struct or union",
1958                          &c_parser_peek_token (parser)->location);
1959               else
1960                 {
1961                   c_parser_error (parser, "expected %<;%>");
1962                   c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL);
1963                   break;
1964                 }
1965             }
1966         }
1967       postfix_attrs = c_parser_attributes (parser);
1968       ret.spec = finish_struct (type, nreverse (contents),
1969                                 chainon (attrs, postfix_attrs));
1970       ret.kind = ctsk_tagdef;
1971       return ret;
1972     }
1973   else if (!ident)
1974     {
1975       c_parser_error (parser, "expected %<{%>");
1976       ret.spec = error_mark_node;
1977       ret.kind = ctsk_tagref;
1978       return ret;
1979     }
1980   ret = parser_xref_tag (code, ident);
1981   return ret;
1982 }
1983
1984 /* Parse a struct-declaration (C90 6.5.2.1, C99 6.7.2.1), *without*
1985    the trailing semicolon.
1986
1987    struct-declaration:
1988      specifier-qualifier-list struct-declarator-list
1989
1990    specifier-qualifier-list:
1991      type-specifier specifier-qualifier-list[opt]
1992      type-qualifier specifier-qualifier-list[opt]
1993      attributes specifier-qualifier-list[opt]
1994
1995    struct-declarator-list:
1996      struct-declarator
1997      struct-declarator-list , attributes[opt] struct-declarator
1998
1999    struct-declarator:
2000      declarator attributes[opt]
2001      declarator[opt] : constant-expression attributes[opt]
2002
2003    GNU extensions:
2004
2005    struct-declaration:
2006      __extension__ struct-declaration
2007      specifier-qualifier-list
2008
2009    Unlike the ISO C syntax, semicolons are handled elsewhere.  The use
2010    of attributes where shown is a GNU extension.  In GNU C, we accept
2011    any expression without commas in the syntax (assignment
2012    expressions, not just conditional expressions); assignment
2013    expressions will be diagnosed as non-constant.  */
2014
2015 static tree
2016 c_parser_struct_declaration (c_parser *parser)
2017 {
2018   struct c_declspecs *specs;
2019   tree prefix_attrs;
2020   tree all_prefix_attrs;
2021   tree decls;
2022   location_t decl_loc;
2023   if (c_parser_next_token_is_keyword (parser, RID_EXTENSION))
2024     {
2025       int ext;
2026       tree decl;
2027       ext = disable_extension_diagnostics ();
2028       c_parser_consume_token (parser);
2029       decl = c_parser_struct_declaration (parser);
2030       restore_extension_diagnostics (ext);
2031       return decl;
2032     }
2033   specs = build_null_declspecs ();
2034   decl_loc = c_parser_peek_token (parser)->location;
2035   c_parser_declspecs (parser, specs, false, true, true);
2036   if (parser->error)
2037     return NULL_TREE;
2038   if (!specs->declspecs_seen_p)
2039     {
2040       c_parser_error (parser, "expected specifier-qualifier-list");
2041       return NULL_TREE;
2042     }
2043   finish_declspecs (specs);
2044   if (c_parser_next_token_is (parser, CPP_SEMICOLON))
2045     {
2046       tree ret;
2047       if (!specs->type_seen_p)
2048         {
2049           if (pedantic)
2050             pedwarn ("%HISO C forbids member declarations with no members",
2051                      &decl_loc);
2052           shadow_tag_warned (specs, pedantic);
2053           ret = NULL_TREE;
2054         }
2055       else
2056         {
2057           /* Support for unnamed structs or unions as members of
2058              structs or unions (which is [a] useful and [b] supports
2059              MS P-SDK).  */
2060           tree attrs = NULL;
2061           ret = grokfield (build_id_declarator (NULL_TREE), specs,
2062                            NULL_TREE, &attrs);
2063           if (ret)
2064             decl_attributes (&ret, attrs, 0);
2065         }
2066       return ret;
2067     }
2068   pending_xref_error ();
2069   prefix_attrs = specs->attrs;
2070   all_prefix_attrs = prefix_attrs;
2071   specs->attrs = NULL_TREE;
2072   decls = NULL_TREE;
2073   while (true)
2074     {
2075       /* Declaring one or more declarators or un-named bit-fields.  */
2076       struct c_declarator *declarator;
2077       bool dummy = false;
2078       if (c_parser_next_token_is (parser, CPP_COLON))
2079         declarator = build_id_declarator (NULL_TREE);
2080       else
2081         declarator = c_parser_declarator (parser, specs->type_seen_p,
2082                                           C_DTR_NORMAL, &dummy);
2083       if (declarator == NULL)
2084         {
2085           c_parser_skip_to_end_of_block_or_statement (parser);
2086           break;
2087         }
2088       if (c_parser_next_token_is (parser, CPP_COLON)
2089           || c_parser_next_token_is (parser, CPP_COMMA)
2090           || c_parser_next_token_is (parser, CPP_SEMICOLON)
2091           || c_parser_next_token_is (parser, CPP_CLOSE_BRACE)
2092           || c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
2093         {
2094           tree postfix_attrs = NULL_TREE;
2095           tree width = NULL_TREE;
2096           tree d;
2097           if (c_parser_next_token_is (parser, CPP_COLON))
2098             {
2099               c_parser_consume_token (parser);
2100               width = c_parser_expr_no_commas (parser, NULL).value;
2101             }
2102           if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
2103             postfix_attrs = c_parser_attributes (parser);
2104           d = grokfield (declarator, specs, width, &all_prefix_attrs);
2105           decl_attributes (&d, chainon (postfix_attrs,
2106                                         all_prefix_attrs), 0);
2107           TREE_CHAIN (d) = decls;
2108           decls = d;
2109           if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
2110             all_prefix_attrs = chainon (c_parser_attributes (parser),
2111                                         prefix_attrs);
2112           else
2113             all_prefix_attrs = prefix_attrs;
2114           if (c_parser_next_token_is (parser, CPP_COMMA))
2115             c_parser_consume_token (parser);
2116           else if (c_parser_next_token_is (parser, CPP_SEMICOLON)
2117                    || c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
2118             {
2119               /* Semicolon consumed in caller.  */
2120               break;
2121             }
2122           else
2123             {
2124               c_parser_error (parser, "expected %<,%>, %<;%> or %<}%>");
2125               break;
2126             }
2127         }
2128       else
2129         {
2130           c_parser_error (parser,
2131                           "expected %<:%>, %<,%>, %<;%>, %<}%> or "
2132                           "%<__attribute__%>");
2133           break;
2134         }
2135     }
2136   return decls;
2137 }
2138
2139 /* Parse a typeof specifier (a GNU extension).
2140
2141    typeof-specifier:
2142      typeof ( expression )
2143      typeof ( type-name )
2144 */
2145
2146 static struct c_typespec
2147 c_parser_typeof_specifier (c_parser *parser)
2148 {
2149   struct c_typespec ret;
2150   ret.kind = ctsk_typeof;
2151   ret.spec = error_mark_node;
2152   gcc_assert (c_parser_next_token_is_keyword (parser, RID_TYPEOF));
2153   c_parser_consume_token (parser);
2154   skip_evaluation++;
2155   in_typeof++;
2156   if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
2157     {
2158       skip_evaluation--;
2159       in_typeof--;
2160       return ret;
2161     }
2162   if (c_parser_next_token_starts_typename (parser))
2163     {
2164       struct c_type_name *type = c_parser_type_name (parser);
2165       skip_evaluation--;
2166       in_typeof--;
2167       if (type != NULL)
2168         {
2169           ret.spec = groktypename (type);
2170           pop_maybe_used (variably_modified_type_p (ret.spec, NULL_TREE));
2171         }
2172     }
2173   else
2174     {
2175       bool was_vm;
2176       location_t here = c_parser_peek_token (parser)->location;
2177       struct c_expr expr = c_parser_expression (parser);
2178       skip_evaluation--;
2179       in_typeof--;
2180       if (TREE_CODE (expr.value) == COMPONENT_REF
2181           && DECL_C_BIT_FIELD (TREE_OPERAND (expr.value, 1)))
2182         error ("%H%<typeof%> applied to a bit-field", &here);
2183       ret.spec = TREE_TYPE (expr.value);
2184       was_vm = variably_modified_type_p (ret.spec, NULL_TREE);
2185       /* This should be returned with the type so that when the type
2186          is evaluated, this can be evaluated.  For now, we avoid
2187          evaluation when the context might.  */
2188       if (!skip_evaluation && was_vm)
2189         {
2190           tree e = expr.value;
2191
2192           /* If the expression is not of a type to which we cannot assign a line
2193              number, wrap the thing in a no-op NOP_EXPR.  */
2194           if (DECL_P (e) || CONSTANT_CLASS_P (e))
2195             e = build1 (NOP_EXPR, void_type_node, e);
2196
2197           if (CAN_HAVE_LOCATION_P (e))
2198             SET_EXPR_LOCATION (e, input_location);
2199
2200           add_stmt (e);
2201         }
2202       pop_maybe_used (was_vm);
2203     }
2204   c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
2205   return ret;
2206 }
2207
2208 /* Parse a declarator, possibly an abstract declarator (C90 6.5.4,
2209    6.5.5, C99 6.7.5, 6.7.6).  If TYPE_SEEN_P then a typedef name may
2210    be redeclared; otherwise it may not.  KIND indicates which kind of
2211    declarator is wanted.  Returns a valid declarator except in the
2212    case of a syntax error in which case NULL is returned.  *SEEN_ID is
2213    set to true if an identifier being declared is seen; this is used
2214    to diagnose bad forms of abstract array declarators and to
2215    determine whether an identifier list is syntactically permitted.
2216
2217    declarator:
2218      pointer[opt] direct-declarator
2219
2220    direct-declarator:
2221      identifier
2222      ( attributes[opt] declarator )
2223      direct-declarator array-declarator
2224      direct-declarator ( parameter-type-list )
2225      direct-declarator ( identifier-list[opt] )
2226
2227    pointer:
2228      * type-qualifier-list[opt]
2229      * type-qualifier-list[opt] pointer
2230
2231    type-qualifier-list:
2232      type-qualifier
2233      attributes
2234      type-qualifier-list type-qualifier
2235      type-qualifier-list attributes
2236
2237    parameter-type-list:
2238      parameter-list
2239      parameter-list , ...
2240
2241    parameter-list:
2242      parameter-declaration
2243      parameter-list , parameter-declaration
2244
2245    parameter-declaration:
2246      declaration-specifiers declarator attributes[opt]
2247      declaration-specifiers abstract-declarator[opt] attributes[opt]
2248
2249    identifier-list:
2250      identifier
2251      identifier-list , identifier
2252
2253    abstract-declarator:
2254      pointer
2255      pointer[opt] direct-abstract-declarator
2256
2257    direct-abstract-declarator:
2258      ( attributes[opt] abstract-declarator )
2259      direct-abstract-declarator[opt] array-declarator
2260      direct-abstract-declarator[opt] ( parameter-type-list[opt] )
2261
2262    GNU extensions:
2263
2264    direct-declarator:
2265      direct-declarator ( parameter-forward-declarations
2266                          parameter-type-list[opt] )
2267
2268    direct-abstract-declarator:
2269      direct-abstract-declarator[opt] ( parameter-forward-declarations
2270                                        parameter-type-list[opt] )
2271
2272    parameter-forward-declarations:
2273      parameter-list ;
2274      parameter-forward-declarations parameter-list ;
2275
2276    The uses of attributes shown above are GNU extensions.
2277
2278    Some forms of array declarator are not included in C99 in the
2279    syntax for abstract declarators; these are disallowed elsewhere.
2280    This may be a defect (DR#289).
2281
2282    This function also accepts an omitted abstract declarator as being
2283    an abstract declarator, although not part of the formal syntax.  */
2284
2285 static struct c_declarator *
2286 c_parser_declarator (c_parser *parser, bool type_seen_p, c_dtr_syn kind,
2287                      bool *seen_id)
2288 {
2289   /* Parse any initial pointer part.  */
2290   if (c_parser_next_token_is (parser, CPP_MULT))
2291     {
2292       struct c_declspecs *quals_attrs = build_null_declspecs ();
2293       struct c_declarator *inner;
2294       c_parser_consume_token (parser);
2295       c_parser_declspecs (parser, quals_attrs, false, false, true);
2296       inner = c_parser_declarator (parser, type_seen_p, kind, seen_id);
2297       if (inner == NULL)
2298         return NULL;
2299       else
2300         return make_pointer_declarator (quals_attrs, inner);
2301     }
2302   /* Now we have a direct declarator, direct abstract declarator or
2303      nothing (which counts as a direct abstract declarator here).  */
2304   return c_parser_direct_declarator (parser, type_seen_p, kind, seen_id);
2305 }
2306
2307 /* Parse a direct declarator or direct abstract declarator; arguments
2308    as c_parser_declarator.  */
2309
2310 static struct c_declarator *
2311 c_parser_direct_declarator (c_parser *parser, bool type_seen_p, c_dtr_syn kind,
2312                             bool *seen_id)
2313 {
2314   /* The direct declarator must start with an identifier (possibly
2315      omitted) or a parenthesized declarator (possibly abstract).  In
2316      an ordinary declarator, initial parentheses must start a
2317      parenthesized declarator.  In an abstract declarator or parameter
2318      declarator, they could start a parenthesized declarator or a
2319      parameter list.  To tell which, the open parenthesis and any
2320      following attributes must be read.  If a declaration specifier
2321      follows, then it is a parameter list; if the specifier is a
2322      typedef name, there might be an ambiguity about redeclaring it,
2323      which is resolved in the direction of treating it as a typedef
2324      name.  If a close parenthesis follows, it is also an empty
2325      parameter list, as the syntax does not permit empty abstract
2326      declarators.  Otherwise, it is a parenthesized declarator (in
2327      which case the analysis may be repeated inside it, recursively).
2328
2329      ??? There is an ambiguity in a parameter declaration "int
2330      (__attribute__((foo)) x)", where x is not a typedef name: it
2331      could be an abstract declarator for a function, or declare x with
2332      parentheses.  The proper resolution of this ambiguity needs
2333      documenting.  At present we follow an accident of the old
2334      parser's implementation, whereby the first parameter must have
2335      some declaration specifiers other than just attributes.  Thus as
2336      a parameter declaration it is treated as a parenthesized
2337      parameter named x, and as an abstract declarator it is
2338      rejected.
2339
2340      ??? Also following the old parser, attributes inside an empty
2341      parameter list are ignored, making it a list not yielding a
2342      prototype, rather than giving an error or making it have one
2343      parameter with implicit type int.
2344
2345      ??? Also following the old parser, typedef names may be
2346      redeclared in declarators, but not Objective-C class names.  */
2347
2348   if (kind != C_DTR_ABSTRACT
2349       && c_parser_next_token_is (parser, CPP_NAME)
2350       && ((type_seen_p
2351            && c_parser_peek_token (parser)->id_kind == C_ID_TYPENAME)
2352           || c_parser_peek_token (parser)->id_kind == C_ID_ID))
2353     {
2354       struct c_declarator *inner
2355         = build_id_declarator (c_parser_peek_token (parser)->value);
2356       *seen_id = true;
2357       inner->id_loc = c_parser_peek_token (parser)->location;
2358       c_parser_consume_token (parser);
2359       return c_parser_direct_declarator_inner (parser, *seen_id, inner);
2360     }
2361
2362   if (kind != C_DTR_NORMAL
2363       && c_parser_next_token_is (parser, CPP_OPEN_SQUARE))
2364     {
2365       struct c_declarator *inner = build_id_declarator (NULL_TREE);
2366       return c_parser_direct_declarator_inner (parser, *seen_id, inner);
2367     }
2368
2369   /* Either we are at the end of an abstract declarator, or we have
2370      parentheses.  */
2371
2372   if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
2373     {
2374       tree attrs;
2375       struct c_declarator *inner;
2376       c_parser_consume_token (parser);
2377       attrs = c_parser_attributes (parser);
2378       if (kind != C_DTR_NORMAL
2379           && (c_parser_next_token_starts_declspecs (parser)
2380               || c_parser_next_token_is (parser, CPP_CLOSE_PAREN)))
2381         {
2382           struct c_arg_info *args
2383             = c_parser_parms_declarator (parser, kind == C_DTR_NORMAL,
2384                                          attrs);
2385           if (args == NULL)
2386             return NULL;
2387           else
2388             {
2389               inner
2390                 = build_function_declarator (args,
2391                                              build_id_declarator (NULL_TREE));
2392               return c_parser_direct_declarator_inner (parser, *seen_id,
2393                                                        inner);
2394             }
2395         }
2396       /* A parenthesized declarator.  */
2397       inner = c_parser_declarator (parser, type_seen_p, kind, seen_id);
2398       if (inner != NULL && attrs != NULL)
2399         inner = build_attrs_declarator (attrs, inner);
2400       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2401         {
2402           c_parser_consume_token (parser);
2403           if (inner == NULL)
2404             return NULL;
2405           else
2406             return c_parser_direct_declarator_inner (parser, *seen_id, inner);
2407         }
2408       else
2409         {
2410           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2411                                      "expected %<)%>");
2412           return NULL;
2413         }
2414     }
2415   else
2416     {
2417       if (kind == C_DTR_NORMAL)
2418         {
2419           c_parser_error (parser, "expected identifier or %<(%>");
2420           return NULL;
2421         }
2422       else
2423         return build_id_declarator (NULL_TREE);
2424     }
2425 }
2426
2427 /* Parse part of a direct declarator or direct abstract declarator,
2428    given that some (in INNER) has already been parsed; ID_PRESENT is
2429    true if an identifier is present, false for an abstract
2430    declarator.  */
2431
2432 static struct c_declarator *
2433 c_parser_direct_declarator_inner (c_parser *parser, bool id_present,
2434                                   struct c_declarator *inner)
2435 {
2436   /* Parse a sequence of array declarators and parameter lists.  */
2437   if (c_parser_next_token_is (parser, CPP_OPEN_SQUARE))
2438     {
2439       struct c_declarator *declarator;
2440       struct c_declspecs *quals_attrs = build_null_declspecs ();
2441       bool static_seen;
2442       bool star_seen;
2443       tree dimen;
2444       c_parser_consume_token (parser);
2445       c_parser_declspecs (parser, quals_attrs, false, false, true);
2446       static_seen = c_parser_next_token_is_keyword (parser, RID_STATIC);
2447       if (static_seen)
2448         c_parser_consume_token (parser);
2449       if (static_seen && !quals_attrs->declspecs_seen_p)
2450         c_parser_declspecs (parser, quals_attrs, false, false, true);
2451       if (!quals_attrs->declspecs_seen_p)
2452         quals_attrs = NULL;
2453       /* If "static" is present, there must be an array dimension.
2454          Otherwise, there may be a dimension, "*", or no
2455          dimension.  */
2456       if (static_seen)
2457         {
2458           star_seen = false;
2459           dimen = c_parser_expr_no_commas (parser, NULL).value;
2460         }
2461       else
2462         {
2463           if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
2464             {
2465               dimen = NULL_TREE;
2466               star_seen = false;
2467             }
2468           else if (c_parser_next_token_is (parser, CPP_MULT))
2469             {
2470               if (c_parser_peek_2nd_token (parser)->type == CPP_CLOSE_SQUARE)
2471                 {
2472                   dimen = NULL_TREE;
2473                   star_seen = true;
2474                   c_parser_consume_token (parser);
2475                 }
2476               else
2477                 {
2478                   star_seen = false;
2479                   dimen = c_parser_expr_no_commas (parser, NULL).value;
2480                 }
2481             }
2482           else
2483             {
2484               star_seen = false;
2485               dimen = c_parser_expr_no_commas (parser, NULL).value;
2486             }
2487         }
2488       if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
2489         c_parser_consume_token (parser);
2490       else
2491         {
2492           c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
2493                                      "expected %<]%>");
2494           return NULL;
2495         }
2496       declarator = build_array_declarator (dimen, quals_attrs, static_seen,
2497                                            star_seen);
2498       if (declarator == NULL)
2499         return NULL;
2500       inner = set_array_declarator_inner (declarator, inner);
2501       return c_parser_direct_declarator_inner (parser, id_present, inner);
2502     }
2503   else if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
2504     {
2505       tree attrs;
2506       struct c_arg_info *args;
2507       c_parser_consume_token (parser);
2508       attrs = c_parser_attributes (parser);
2509       args = c_parser_parms_declarator (parser, id_present, attrs);
2510       if (args == NULL)
2511         return NULL;
2512       else
2513         {
2514           inner = build_function_declarator (args, inner);
2515           return c_parser_direct_declarator_inner (parser, id_present, inner);
2516         }
2517     }
2518   return inner;
2519 }
2520
2521 /* Parse a parameter list or identifier list, including the closing
2522    parenthesis but not the opening one.  ATTRS are the attributes at
2523    the start of the list.  ID_LIST_OK is true if an identifier list is
2524    acceptable; such a list must not have attributes at the start.  */
2525
2526 static struct c_arg_info *
2527 c_parser_parms_declarator (c_parser *parser, bool id_list_ok, tree attrs)
2528 {
2529   push_scope ();
2530   declare_parm_level ();
2531   /* If the list starts with an identifier, it is an identifier list.
2532      Otherwise, it is either a prototype list or an empty list.  */
2533   if (id_list_ok
2534       && !attrs
2535       && c_parser_next_token_is (parser, CPP_NAME)
2536       && c_parser_peek_token (parser)->id_kind == C_ID_ID)
2537     {
2538       tree list = NULL_TREE, *nextp = &list;
2539       while (c_parser_next_token_is (parser, CPP_NAME)
2540              && c_parser_peek_token (parser)->id_kind == C_ID_ID)
2541         {
2542           *nextp = build_tree_list (NULL_TREE,
2543                                     c_parser_peek_token (parser)->value);
2544           nextp = & TREE_CHAIN (*nextp);
2545           c_parser_consume_token (parser);
2546           if (c_parser_next_token_is_not (parser, CPP_COMMA))
2547             break;
2548           c_parser_consume_token (parser);
2549           if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2550             {
2551               c_parser_error (parser, "expected identifier");
2552               break;
2553             }
2554         }
2555       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2556         {
2557           struct c_arg_info *ret = XOBNEW (&parser_obstack, struct c_arg_info);
2558           ret->parms = 0;
2559           ret->tags = 0;
2560           ret->types = list;
2561           ret->others = 0;
2562           ret->pending_sizes = 0;
2563           ret->had_vla_unspec = 0;
2564           c_parser_consume_token (parser);
2565           pop_scope ();
2566           return ret;
2567         }
2568       else
2569         {
2570           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2571                                      "expected %<)%>");
2572           pop_scope ();
2573           return NULL;
2574         }
2575     }
2576   else
2577     {
2578       struct c_arg_info *ret = c_parser_parms_list_declarator (parser, attrs);
2579       pop_scope ();
2580       return ret;
2581     }
2582 }
2583
2584 /* Parse a parameter list (possibly empty), including the closing
2585    parenthesis but not the opening one.  ATTRS are the attributes at
2586    the start of the list.  */
2587
2588 static struct c_arg_info *
2589 c_parser_parms_list_declarator (c_parser *parser, tree attrs)
2590 {
2591   bool good_parm = false;
2592   /* ??? Following the old parser, forward parameter declarations may
2593      use abstract declarators, and if no real parameter declarations
2594      follow the forward declarations then this is not diagnosed.  Also
2595      note as above that attributes are ignored as the only contents of
2596      the parentheses, or as the only contents after forward
2597      declarations.  */
2598   if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2599     {
2600       struct c_arg_info *ret = XOBNEW (&parser_obstack, struct c_arg_info);
2601       ret->parms = 0;
2602       ret->tags = 0;
2603       ret->types = 0;
2604       ret->others = 0;
2605       ret->pending_sizes = 0;
2606       ret->had_vla_unspec = 0;
2607       c_parser_consume_token (parser);
2608       return ret;
2609     }
2610   if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
2611     {
2612       struct c_arg_info *ret = XOBNEW (&parser_obstack, struct c_arg_info);
2613       ret->parms = 0;
2614       ret->tags = 0;
2615       ret->others = 0;
2616       ret->pending_sizes = 0;
2617       ret->had_vla_unspec = 0;
2618       /* Suppress -Wold-style-definition for this case.  */
2619       ret->types = error_mark_node;
2620       error ("%HISO C requires a named argument before %<...%>",
2621              &c_parser_peek_token (parser)->location);
2622       c_parser_consume_token (parser);
2623       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2624         {
2625           c_parser_consume_token (parser);
2626           return ret;
2627         }
2628       else
2629         {
2630           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2631                                      "expected %<)%>");
2632           return NULL;
2633         }
2634     }
2635   /* Nonempty list of parameters, either terminated with semicolon
2636      (forward declarations; recurse) or with close parenthesis (normal
2637      function) or with ", ... )" (variadic function).  */
2638   while (true)
2639     {
2640       /* Parse a parameter.  */
2641       struct c_parm *parm = c_parser_parameter_declaration (parser, attrs);
2642       attrs = NULL_TREE;
2643       if (parm != NULL)
2644         {
2645           good_parm = true;
2646           push_parm_decl (parm);
2647         }
2648       if (c_parser_next_token_is (parser, CPP_SEMICOLON))
2649         {
2650           tree new_attrs;
2651           c_parser_consume_token (parser);
2652           mark_forward_parm_decls ();
2653           new_attrs = c_parser_attributes (parser);
2654           return c_parser_parms_list_declarator (parser, new_attrs);
2655         }
2656       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2657         {
2658           c_parser_consume_token (parser);
2659           if (good_parm)
2660             return get_parm_info (false);
2661           else
2662             {
2663               struct c_arg_info *ret
2664                 = XOBNEW (&parser_obstack, struct c_arg_info);
2665               ret->parms = 0;
2666               ret->tags = 0;
2667               ret->types = 0;
2668               ret->others = 0;
2669               ret->pending_sizes = 0;
2670               ret->had_vla_unspec = 0;
2671               return ret;
2672             }
2673         }
2674       if (!c_parser_require (parser, CPP_COMMA,
2675                              "expected %<;%>, %<,%> or %<)%>"))
2676         {
2677           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
2678           return NULL;
2679         }
2680       if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
2681         {
2682           c_parser_consume_token (parser);
2683           if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2684             {
2685               c_parser_consume_token (parser);
2686               if (good_parm)
2687                 return get_parm_info (true);
2688               else
2689                 {
2690                   struct c_arg_info *ret
2691                     = XOBNEW (&parser_obstack, struct c_arg_info);
2692                   ret->parms = 0;
2693                   ret->tags = 0;
2694                   ret->types = 0;
2695                   ret->others = 0;
2696                   ret->pending_sizes = 0;
2697                   ret->had_vla_unspec = 0;
2698                   return ret;
2699                 }
2700             }
2701           else
2702             {
2703               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2704                                          "expected %<)%>");
2705               return NULL;
2706             }
2707         }
2708     }
2709 }
2710
2711 /* Parse a parameter declaration.  ATTRS are the attributes at the
2712    start of the declaration if it is the first parameter.  */
2713
2714 static struct c_parm *
2715 c_parser_parameter_declaration (c_parser *parser, tree attrs)
2716 {
2717   struct c_declspecs *specs;
2718   struct c_declarator *declarator;
2719   tree prefix_attrs;
2720   tree postfix_attrs = NULL_TREE;
2721   bool dummy = false;
2722   if (!c_parser_next_token_starts_declspecs (parser))
2723     {
2724       /* ??? In some Objective-C cases '...' isn't applicable so there
2725          should be a different message.  */
2726       c_parser_error (parser,
2727                       "expected declaration specifiers or %<...%>");
2728       c_parser_skip_to_end_of_parameter (parser);
2729       return NULL;
2730     }
2731   specs = build_null_declspecs ();
2732   if (attrs)
2733     {
2734       declspecs_add_attrs (specs, attrs);
2735       attrs = NULL_TREE;
2736     }
2737   c_parser_declspecs (parser, specs, true, true, true);
2738   finish_declspecs (specs);
2739   pending_xref_error ();
2740   prefix_attrs = specs->attrs;
2741   specs->attrs = NULL_TREE;
2742   declarator = c_parser_declarator (parser, specs->type_seen_p,
2743                                     C_DTR_PARM, &dummy);
2744   if (declarator == NULL)
2745     {
2746       c_parser_skip_until_found (parser, CPP_COMMA, NULL);
2747       return NULL;
2748     }
2749   if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
2750     postfix_attrs = c_parser_attributes (parser);
2751   return build_c_parm (specs, chainon (postfix_attrs, prefix_attrs),
2752                        declarator);
2753 }
2754
2755 /* Parse a string literal in an asm expression.  It should not be
2756    translated, and wide string literals are an error although
2757    permitted by the syntax.  This is a GNU extension.
2758
2759    asm-string-literal:
2760      string-literal
2761
2762    ??? At present, following the old parser, the caller needs to have
2763    set lex_untranslated_string to 1.  It would be better to follow the
2764    C++ parser rather than using this kludge.  */
2765
2766 static tree
2767 c_parser_asm_string_literal (c_parser *parser)
2768 {
2769   tree str;
2770   if (c_parser_next_token_is (parser, CPP_STRING))
2771     {
2772       str = c_parser_peek_token (parser)->value;
2773       c_parser_consume_token (parser);
2774     }
2775   else if (c_parser_next_token_is (parser, CPP_WSTRING))
2776     {
2777       error ("%Hwide string literal in %<asm%>",
2778              &c_parser_peek_token (parser)->location);
2779       str = build_string (1, "");
2780       c_parser_consume_token (parser);
2781     }
2782   else
2783     {
2784       c_parser_error (parser, "expected string literal");
2785       str = NULL_TREE;
2786     }
2787   return str;
2788 }
2789
2790 /* Parse a simple asm expression.  This is used in restricted
2791    contexts, where a full expression with inputs and outputs does not
2792    make sense.  This is a GNU extension.
2793
2794    simple-asm-expr:
2795      asm ( asm-string-literal )
2796 */
2797
2798 static tree
2799 c_parser_simple_asm_expr (c_parser *parser)
2800 {
2801   tree str;
2802   gcc_assert (c_parser_next_token_is_keyword (parser, RID_ASM));
2803   /* ??? Follow the C++ parser rather than using the
2804      lex_untranslated_string kludge.  */
2805   parser->lex_untranslated_string = true;
2806   c_parser_consume_token (parser);
2807   if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
2808     {
2809       parser->lex_untranslated_string = false;
2810       return NULL_TREE;
2811     }
2812   str = c_parser_asm_string_literal (parser);
2813   parser->lex_untranslated_string = false;
2814   if (!c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
2815     {
2816       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
2817       return NULL_TREE;
2818     }
2819   return str;
2820 }
2821
2822 /* Parse (possibly empty) attributes.  This is a GNU extension.
2823
2824    attributes:
2825      empty
2826      attributes attribute
2827
2828    attribute:
2829      __attribute__ ( ( attribute-list ) )
2830
2831    attribute-list:
2832      attrib
2833      attribute_list , attrib
2834
2835    attrib:
2836      empty
2837      any-word
2838      any-word ( identifier )
2839      any-word ( identifier , nonempty-expr-list )
2840      any-word ( expr-list )
2841
2842    where the "identifier" must not be declared as a type, and
2843    "any-word" may be any identifier (including one declared as a
2844    type), a reserved word storage class specifier, type specifier or
2845    type qualifier.  ??? This still leaves out most reserved keywords
2846    (following the old parser), shouldn't we include them, and why not
2847    allow identifiers declared as types to start the arguments?  */
2848
2849 static tree
2850 c_parser_attributes (c_parser *parser)
2851 {
2852   tree attrs = NULL_TREE;
2853   while (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
2854     {
2855       /* ??? Follow the C++ parser rather than using the
2856          lex_untranslated_string kludge.  */
2857       parser->lex_untranslated_string = true;
2858       c_parser_consume_token (parser);
2859       if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
2860         {
2861           parser->lex_untranslated_string = false;
2862           return attrs;
2863         }
2864       if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
2865         {
2866           parser->lex_untranslated_string = false;
2867           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
2868           return attrs;
2869         }
2870       /* Parse the attribute list.  */
2871       while (c_parser_next_token_is (parser, CPP_COMMA)
2872              || c_parser_next_token_is (parser, CPP_NAME)
2873              || c_parser_next_token_is (parser, CPP_KEYWORD))
2874         {
2875           tree attr, attr_name, attr_args;
2876           if (c_parser_next_token_is (parser, CPP_COMMA))
2877             {
2878               c_parser_consume_token (parser);
2879               continue;
2880             }
2881           if (c_parser_next_token_is (parser, CPP_KEYWORD))
2882             {
2883               /* ??? See comment above about what keywords are
2884                  accepted here.  */
2885               bool ok;
2886               switch (c_parser_peek_token (parser)->keyword)
2887                 {
2888                 case RID_STATIC:
2889                 case RID_UNSIGNED:
2890                 case RID_LONG:
2891                 case RID_CONST:
2892                 case RID_EXTERN:
2893                 case RID_REGISTER:
2894                 case RID_TYPEDEF:
2895                 case RID_SHORT:
2896                 case RID_INLINE:
2897                 case RID_VOLATILE:
2898                 case RID_SIGNED:
2899                 case RID_AUTO:
2900                 case RID_RESTRICT:
2901                 case RID_COMPLEX:
2902                 case RID_THREAD:
2903                 case RID_INT:
2904                 case RID_CHAR:
2905                 case RID_FLOAT:
2906                 case RID_DOUBLE:
2907                 case RID_VOID:
2908                 case RID_DFLOAT32:
2909                 case RID_DFLOAT64:
2910                 case RID_DFLOAT128:
2911                 case RID_BOOL:
2912                 case RID_FRACT:
2913                 case RID_ACCUM:
2914                 case RID_SAT:
2915                   ok = true;
2916                   break;
2917                 default:
2918                   ok = false;
2919                   break;
2920                 }
2921               if (!ok)
2922                 break;
2923             }
2924           attr_name = c_parser_peek_token (parser)->value;
2925           c_parser_consume_token (parser);
2926           if (c_parser_next_token_is_not (parser, CPP_OPEN_PAREN))
2927             {
2928               attr = build_tree_list (attr_name, NULL_TREE);
2929               attrs = chainon (attrs, attr);
2930               continue;
2931             }
2932           c_parser_consume_token (parser);
2933           /* Parse the attribute contents.  If they start with an
2934              identifier which is followed by a comma or close
2935              parenthesis, then the arguments start with that
2936              identifier; otherwise they are an expression list.  */
2937           if (c_parser_next_token_is (parser, CPP_NAME)
2938               && c_parser_peek_token (parser)->id_kind == C_ID_ID
2939               && ((c_parser_peek_2nd_token (parser)->type == CPP_COMMA)
2940                   || (c_parser_peek_2nd_token (parser)->type
2941                       == CPP_CLOSE_PAREN)))
2942             {
2943               tree arg1 = c_parser_peek_token (parser)->value;
2944               c_parser_consume_token (parser);
2945               if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2946                 attr_args = build_tree_list (NULL_TREE, arg1);
2947               else
2948                 {
2949                   c_parser_consume_token (parser);
2950                   attr_args = tree_cons (NULL_TREE, arg1,
2951                                          c_parser_expr_list (parser, false));
2952                 }
2953             }
2954           else
2955             {
2956               if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2957                 attr_args = NULL_TREE;
2958               else
2959                 attr_args = c_parser_expr_list (parser, false);
2960             }
2961           attr = build_tree_list (attr_name, attr_args);
2962           if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2963             c_parser_consume_token (parser);
2964           else
2965             {
2966               parser->lex_untranslated_string = false;
2967               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2968                                          "expected %<)%>");
2969               return attrs;
2970             }
2971           attrs = chainon (attrs, attr);
2972         }
2973       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2974         c_parser_consume_token (parser);
2975       else
2976         {
2977           parser->lex_untranslated_string = false;
2978           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2979                                      "expected %<)%>");
2980           return attrs;
2981         }
2982       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2983         c_parser_consume_token (parser);
2984       else
2985         {
2986           parser->lex_untranslated_string = false;
2987           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2988                                      "expected %<)%>");
2989           return attrs;
2990         }
2991       parser->lex_untranslated_string = false;
2992     }
2993   return attrs;
2994 }
2995
2996 /* Parse a type name (C90 6.5.5, C99 6.7.6).
2997
2998    type-name:
2999      specifier-qualifier-list abstract-declarator[opt]
3000 */
3001
3002 static struct c_type_name *
3003 c_parser_type_name (c_parser *parser)
3004 {
3005   struct c_declspecs *specs = build_null_declspecs ();
3006   struct c_declarator *declarator;
3007   struct c_type_name *ret;
3008   bool dummy = false;
3009   c_parser_declspecs (parser, specs, false, true, true);
3010   if (!specs->declspecs_seen_p)
3011     {
3012       c_parser_error (parser, "expected specifier-qualifier-list");
3013       return NULL;
3014     }
3015   pending_xref_error ();
3016   finish_declspecs (specs);
3017   declarator = c_parser_declarator (parser, specs->type_seen_p,
3018                                     C_DTR_ABSTRACT, &dummy);
3019   if (declarator == NULL)
3020     return NULL;
3021   ret = XOBNEW (&parser_obstack, struct c_type_name);
3022   ret->specs = specs;
3023   ret->declarator = declarator;
3024   return ret;
3025 }
3026
3027 /* Parse an initializer (C90 6.5.7, C99 6.7.8).
3028
3029    initializer:
3030      assignment-expression
3031      { initializer-list }
3032      { initializer-list , }
3033
3034    initializer-list:
3035      designation[opt] initializer
3036      initializer-list , designation[opt] initializer
3037
3038    designation:
3039      designator-list =
3040
3041    designator-list:
3042      designator
3043      designator-list designator
3044
3045    designator:
3046      array-designator
3047      . identifier
3048
3049    array-designator:
3050      [ constant-expression ]
3051
3052    GNU extensions:
3053
3054    initializer:
3055      { }
3056
3057    designation:
3058      array-designator
3059      identifier :
3060
3061    array-designator:
3062      [ constant-expression ... constant-expression ]
3063
3064    Any expression without commas is accepted in the syntax for the
3065    constant-expressions, with non-constant expressions rejected later.
3066
3067    This function is only used for top-level initializers; for nested
3068    ones, see c_parser_initval.  */
3069
3070 static struct c_expr
3071 c_parser_initializer (c_parser *parser)
3072 {
3073   if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
3074     return c_parser_braced_init (parser, NULL_TREE, false);
3075   else
3076     {
3077       struct c_expr ret;
3078       ret = c_parser_expr_no_commas (parser, NULL);
3079       if (TREE_CODE (ret.value) != STRING_CST
3080           && TREE_CODE (ret.value) != COMPOUND_LITERAL_EXPR)
3081         ret = default_function_array_conversion (ret);
3082       return ret;
3083     }
3084 }
3085
3086 /* Parse a braced initializer list.  TYPE is the type specified for a
3087    compound literal, and NULL_TREE for other initializers and for
3088    nested braced lists.  NESTED_P is true for nested braced lists,
3089    false for the list of a compound literal or the list that is the
3090    top-level initializer in a declaration.  */
3091
3092 static struct c_expr
3093 c_parser_braced_init (c_parser *parser, tree type, bool nested_p)
3094 {
3095   location_t brace_loc = c_parser_peek_token (parser)->location;
3096   gcc_assert (c_parser_next_token_is (parser, CPP_OPEN_BRACE));
3097   c_parser_consume_token (parser);
3098   if (nested_p)
3099     push_init_level (0);
3100   else
3101     really_start_incremental_init (type);
3102   if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
3103     {
3104       if (pedantic)
3105         pedwarn ("%HISO C forbids empty initializer braces", &brace_loc);
3106     }
3107   else
3108     {
3109       /* Parse a non-empty initializer list, possibly with a trailing
3110          comma.  */
3111       while (true)
3112         {
3113           c_parser_initelt (parser);
3114           if (parser->error)
3115             break;
3116           if (c_parser_next_token_is (parser, CPP_COMMA))
3117             c_parser_consume_token (parser);
3118           else
3119             break;
3120           if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
3121             break;
3122         }
3123     }
3124   if (c_parser_next_token_is_not (parser, CPP_CLOSE_BRACE))
3125     {
3126       struct c_expr ret;
3127       ret.value = error_mark_node;
3128       ret.original_code = ERROR_MARK;
3129       c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, "expected %<}%>");
3130       return ret;
3131     }
3132   c_parser_consume_token (parser);
3133   return pop_init_level (0);
3134 }
3135
3136 /* Parse a nested initializer, including designators.  */
3137
3138 static void
3139 c_parser_initelt (c_parser *parser)
3140 {
3141   /* Parse any designator or designator list.  A single array
3142      designator may have the subsequent "=" omitted in GNU C, but a
3143      longer list or a structure member designator may not.  */
3144   if (c_parser_next_token_is (parser, CPP_NAME)
3145       && c_parser_peek_2nd_token (parser)->type == CPP_COLON)
3146     {
3147       /* Old-style structure member designator.  */
3148       set_init_label (c_parser_peek_token (parser)->value);
3149       if (pedantic)
3150         {
3151           /* Use the colon as the error location.  */
3152           pedwarn ("%Hobsolete use of designated initializer with %<:%>",
3153                    &c_parser_peek_2nd_token (parser)->location);
3154         }
3155       c_parser_consume_token (parser);
3156       c_parser_consume_token (parser);
3157     }
3158   else
3159     {
3160       /* des_seen is 0 if there have been no designators, 1 if there
3161          has been a single array designator and 2 otherwise.  */
3162       int des_seen = 0;
3163       /* Location of a designator.  */
3164       location_t des_loc;
3165       while (c_parser_next_token_is (parser, CPP_OPEN_SQUARE)
3166              || c_parser_next_token_is (parser, CPP_DOT))
3167         {
3168           int des_prev = des_seen;
3169           if (!des_seen)
3170             des_loc = c_parser_peek_token (parser)->location;
3171           if (des_seen < 2)
3172             des_seen++;
3173           if (c_parser_next_token_is (parser, CPP_DOT))
3174             {
3175               des_seen = 2;
3176               c_parser_consume_token (parser);
3177               if (c_parser_next_token_is (parser, CPP_NAME))
3178                 {
3179                   set_init_label (c_parser_peek_token (parser)->value);
3180                   c_parser_consume_token (parser);
3181                 }
3182               else
3183                 {
3184                   struct c_expr init;
3185                   init.value = error_mark_node;
3186                   init.original_code = ERROR_MARK;
3187                   c_parser_error (parser, "expected identifier");
3188                   c_parser_skip_until_found (parser, CPP_COMMA, NULL);
3189                   process_init_element (init);
3190                   return;
3191                 }
3192             }
3193           else
3194             {
3195               tree first, second;
3196               location_t ellipsis_loc;
3197               /* ??? Following the old parser, [ objc-receiver
3198                  objc-message-args ] is accepted as an initializer,
3199                  being distinguished from a designator by what follows
3200                  the first assignment expression inside the square
3201                  brackets, but after a first array designator a
3202                  subsequent square bracket is for Objective-C taken to
3203                  start an expression, using the obsolete form of
3204                  designated initializer without '=', rather than
3205                  possibly being a second level of designation: in LALR
3206                  terms, the '[' is shifted rather than reducing
3207                  designator to designator-list.  */
3208               if (des_prev == 1 && c_dialect_objc ())
3209                 {
3210                   des_seen = des_prev;
3211                   break;
3212                 }
3213               if (des_prev == 0 && c_dialect_objc ())
3214                 {
3215                   /* This might be an array designator or an
3216                      Objective-C message expression.  If the former,
3217                      continue parsing here; if the latter, parse the
3218                      remainder of the initializer given the starting
3219                      primary-expression.  ??? It might make sense to
3220                      distinguish when des_prev == 1 as well; see
3221                      previous comment.  */
3222                   tree rec, args;
3223                   struct c_expr mexpr;
3224                   c_parser_consume_token (parser);
3225                   if (c_parser_peek_token (parser)->type == CPP_NAME
3226                       && ((c_parser_peek_token (parser)->id_kind
3227                            == C_ID_TYPENAME)
3228                           || (c_parser_peek_token (parser)->id_kind
3229                               == C_ID_CLASSNAME)))
3230                     {
3231                       /* Type name receiver.  */
3232                       tree id = c_parser_peek_token (parser)->value;
3233                       c_parser_consume_token (parser);
3234                       rec = objc_get_class_reference (id);
3235                       goto parse_message_args;
3236                     }
3237                   first = c_parser_expr_no_commas (parser, NULL).value;
3238                   if (c_parser_next_token_is (parser, CPP_ELLIPSIS)
3239                       || c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
3240                     goto array_desig_after_first;
3241                   /* Expression receiver.  So far only one part
3242                      without commas has been parsed; there might be
3243                      more of the expression.  */
3244                   rec = first;
3245                   while (c_parser_next_token_is (parser, CPP_COMMA))
3246                     {
3247                       struct c_expr next;
3248                       c_parser_consume_token (parser);
3249                       next = c_parser_expr_no_commas (parser, NULL);
3250                       next = default_function_array_conversion (next);
3251                       rec = build_compound_expr (rec, next.value);
3252                     }
3253                 parse_message_args:
3254                   /* Now parse the objc-message-args.  */
3255                   args = c_parser_objc_message_args (parser);
3256                   c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
3257                                              "expected %<]%>");
3258                   mexpr.value
3259                     = objc_build_message_expr (build_tree_list (rec, args));
3260                   mexpr.original_code = ERROR_MARK;
3261                   /* Now parse and process the remainder of the
3262                      initializer, starting with this message
3263                      expression as a primary-expression.  */
3264                   c_parser_initval (parser, &mexpr);
3265                   return;
3266                 }
3267               c_parser_consume_token (parser);
3268               first = c_parser_expr_no_commas (parser, NULL).value;
3269             array_desig_after_first:
3270               if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
3271                 {
3272                   ellipsis_loc = c_parser_peek_token (parser)->location;
3273                   c_parser_consume_token (parser);
3274                   second = c_parser_expr_no_commas (parser, NULL).value;
3275                 }
3276               else
3277                 second = NULL_TREE;
3278               if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
3279                 {
3280                   c_parser_consume_token (parser);
3281                   set_init_index (first, second);
3282                   if (pedantic && second)
3283                     pedwarn ("%HISO C forbids specifying range of "
3284                              "elements to initialize", &ellipsis_loc);
3285                 }
3286               else
3287                 c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
3288                                            "expected %<]%>");
3289             }
3290         }
3291       if (des_seen >= 1)
3292         {
3293           if (c_parser_next_token_is (parser, CPP_EQ))
3294             {
3295               if (pedantic && !flag_isoc99)
3296                 pedwarn ("%HISO C90 forbids specifying subobject "
3297                          "to initialize", &des_loc);
3298               c_parser_consume_token (parser);
3299             }
3300           else
3301             {
3302               if (des_seen == 1)
3303                 {
3304                   if (pedantic)
3305                     pedwarn ("%Hobsolete use of designated initializer "
3306                              "without %<=%>",
3307                              &c_parser_peek_token (parser)->location);
3308                 }
3309               else
3310                 {
3311                   struct c_expr init;
3312                   init.value = error_mark_node;
3313                   init.original_code = ERROR_MARK;
3314                   c_parser_error (parser, "expected %<=%>");
3315                   c_parser_skip_until_found (parser, CPP_COMMA, NULL);
3316                   process_init_element (init);
3317                   return;
3318                 }
3319             }
3320         }
3321     }
3322   c_parser_initval (parser, NULL);
3323 }
3324
3325 /* Parse a nested initializer; as c_parser_initializer but parses
3326    initializers within braced lists, after any designators have been
3327    applied.  If AFTER is not NULL then it is an Objective-C message
3328    expression which is the primary-expression starting the
3329    initializer.  */
3330
3331 static void
3332 c_parser_initval (c_parser *parser, struct c_expr *after)
3333 {
3334   struct c_expr init;
3335   gcc_assert (!after || c_dialect_objc ());
3336   if (c_parser_next_token_is (parser, CPP_OPEN_BRACE) && !after)
3337     init = c_parser_braced_init (parser, NULL_TREE, true);
3338   else
3339     {
3340       init = c_parser_expr_no_commas (parser, after);
3341       if (init.value != NULL_TREE
3342           && TREE_CODE (init.value) != STRING_CST
3343           && TREE_CODE (init.value) != COMPOUND_LITERAL_EXPR)
3344         init = default_function_array_conversion (init);
3345     }
3346   process_init_element (init);
3347 }
3348
3349 /* Parse a compound statement (possibly a function body) (C90 6.6.2,
3350    C99 6.8.2).
3351
3352    compound-statement:
3353      { block-item-list[opt] }
3354      { label-declarations block-item-list }
3355
3356    block-item-list:
3357      block-item
3358      block-item-list block-item
3359
3360    block-item:
3361      nested-declaration
3362      statement
3363
3364    nested-declaration:
3365      declaration
3366
3367    GNU extensions:
3368
3369    compound-statement:
3370      { label-declarations block-item-list }
3371
3372    nested-declaration:
3373      __extension__ nested-declaration
3374      nested-function-definition
3375
3376    label-declarations:
3377      label-declaration
3378      label-declarations label-declaration
3379
3380    label-declaration:
3381      __label__ identifier-list ;
3382
3383    Allowing the mixing of declarations and code is new in C99.  The
3384    GNU syntax also permits (not shown above) labels at the end of
3385    compound statements, which yield an error.  We don't allow labels
3386    on declarations; this might seem like a natural extension, but
3387    there would be a conflict between attributes on the label and
3388    prefix attributes on the declaration.  ??? The syntax follows the
3389    old parser in requiring something after label declarations.
3390    Although they are erroneous if the labels declared aren't defined,
3391    is it useful for the syntax to be this way?
3392    
3393    OpenMP:
3394    
3395    block-item:
3396      openmp-directive
3397
3398    openmp-directive:
3399      barrier-directive
3400      flush-directive  */
3401
3402 static tree
3403 c_parser_compound_statement (c_parser *parser)
3404 {
3405   tree stmt;
3406   if (!c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>"))
3407     return error_mark_node;
3408   stmt = c_begin_compound_stmt (true);
3409   c_parser_compound_statement_nostart (parser);
3410   return c_end_compound_stmt (stmt, true);
3411 }
3412
3413 /* Parse a compound statement except for the opening brace.  This is
3414    used for parsing both compound statements and statement expressions
3415    (which follow different paths to handling the opening).  */
3416
3417 static void
3418 c_parser_compound_statement_nostart (c_parser *parser)
3419 {
3420   bool last_stmt = false;
3421   bool last_label = false;
3422   location_t label_loc;
3423   if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
3424     {
3425       c_parser_consume_token (parser);
3426       return;
3427     }
3428   if (c_parser_next_token_is_keyword (parser, RID_LABEL))
3429     {
3430       location_t err_loc = c_parser_peek_token (parser)->location;
3431       /* Read zero or more forward-declarations for labels that nested
3432          functions can jump to.  */
3433       while (c_parser_next_token_is_keyword (parser, RID_LABEL))
3434         {
3435           c_parser_consume_token (parser);
3436           /* Any identifiers, including those declared as type names,
3437              are OK here.  */
3438           while (true)
3439             {
3440               tree label;
3441               if (c_parser_next_token_is_not (parser, CPP_NAME))
3442                 {
3443                   c_parser_error (parser, "expected identifier");
3444                   break;
3445                 }
3446               label
3447                 = declare_label (c_parser_peek_token (parser)->value);
3448               C_DECLARED_LABEL_FLAG (label) = 1;
3449               add_stmt (build_stmt (DECL_EXPR, label));
3450               c_parser_consume_token (parser);
3451               if (c_parser_next_token_is (parser, CPP_COMMA))
3452                 c_parser_consume_token (parser);
3453               else
3454                 break;
3455             }
3456           c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
3457         }
3458       if (pedantic)
3459         pedwarn ("%HISO C forbids label declarations", &err_loc);
3460     }
3461   /* We must now have at least one statement, label or declaration.  */
3462   if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
3463     {
3464       c_parser_error (parser, "expected declaration or statement");
3465       c_parser_consume_token (parser);
3466       return;
3467     }
3468   while (c_parser_next_token_is_not (parser, CPP_CLOSE_BRACE))
3469     {
3470       location_t loc = c_parser_peek_token (parser)->location;
3471       if (c_parser_next_token_is_keyword (parser, RID_CASE)
3472           || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
3473           || (c_parser_next_token_is (parser, CPP_NAME)
3474               && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
3475         {
3476           if (c_parser_next_token_is_keyword (parser, RID_CASE))
3477             label_loc = c_parser_peek_2nd_token (parser)->location;
3478           else
3479             label_loc = c_parser_peek_token (parser)->location;
3480           last_label = true;
3481           last_stmt = false;
3482           c_parser_label (parser);
3483         }
3484       else if (!last_label
3485                && c_parser_next_token_starts_declspecs (parser))
3486         {
3487           last_label = false;
3488           c_parser_declaration_or_fndef (parser, true, true, true, true);
3489           if (last_stmt
3490               && ((pedantic && !flag_isoc99)
3491                   || warn_declaration_after_statement))
3492             pedwarn_c90 ("%HISO C90 forbids mixed declarations and code",
3493                          &loc);
3494           last_stmt = false;
3495         }
3496       else if (!last_label
3497                && c_parser_next_token_is_keyword (parser, RID_EXTENSION))
3498         {
3499           /* __extension__ can start a declaration, but is also an
3500              unary operator that can start an expression.  Consume all
3501              but the last of a possible series of __extension__ to
3502              determine which.  */
3503           while (c_parser_peek_2nd_token (parser)->type == CPP_KEYWORD
3504                  && (c_parser_peek_2nd_token (parser)->keyword
3505                      == RID_EXTENSION))
3506             c_parser_consume_token (parser);
3507           if (c_token_starts_declspecs (c_parser_peek_2nd_token (parser)))
3508             {
3509               int ext;
3510               ext = disable_extension_diagnostics ();
3511               c_parser_consume_token (parser);
3512               last_label = false;
3513               c_parser_declaration_or_fndef (parser, true, true, true, true);
3514               /* Following the old parser, __extension__ does not
3515                  disable this diagnostic.  */
3516               restore_extension_diagnostics (ext);
3517               if (last_stmt
3518                   && ((pedantic && !flag_isoc99)
3519                       || warn_declaration_after_statement))
3520                 pedwarn_c90 ("%HISO C90 forbids mixed declarations and code",
3521                              &loc);
3522               last_stmt = false;
3523             }
3524           else
3525             goto statement;
3526         }
3527       else if (c_parser_next_token_is (parser, CPP_PRAGMA))
3528         {
3529           /* External pragmas, and some omp pragmas, are not associated
3530              with regular c code, and so are not to be considered statements
3531              syntactically.  This ensures that the user doesn't put them
3532              places that would turn into syntax errors if the directive
3533              were ignored.  */
3534           if (c_parser_pragma (parser, pragma_compound))
3535             last_label = false, last_stmt = true;
3536         }
3537       else if (c_parser_next_token_is (parser, CPP_EOF))
3538         {
3539           c_parser_error (parser, "expected declaration or statement");
3540           return;
3541         }
3542       else if (c_parser_next_token_is_keyword (parser, RID_ELSE))
3543         {
3544           if (parser->in_if_block) 
3545             {
3546               error ("%H""expected %<}%> before %<else%>", &loc);
3547               return;
3548             }
3549           else 
3550             {
3551               error ("%H%<else%> without a previous %<if%>", &loc);
3552               c_parser_consume_token (parser);
3553               continue;
3554             }
3555         }
3556       else
3557         {
3558         statement:
3559           last_label = false;
3560           last_stmt = true;
3561           c_parser_statement_after_labels (parser);
3562         }
3563
3564       parser->error = false;
3565     }
3566   if (last_label)
3567     error ("%Hlabel at end of compound statement", &label_loc);
3568   c_parser_consume_token (parser);
3569 }
3570
3571 /* Parse a label (C90 6.6.1, C99 6.8.1).
3572
3573    label:
3574      identifier : attributes[opt]
3575      case constant-expression :
3576      default :
3577
3578    GNU extensions:
3579
3580    label:
3581      case constant-expression ... constant-expression :
3582
3583    The use of attributes on labels is a GNU extension.  The syntax in
3584    GNU C accepts any expressions without commas, non-constant
3585    expressions being rejected later.  */
3586
3587 static void
3588 c_parser_label (c_parser *parser)
3589 {
3590   location_t loc1 = c_parser_peek_token (parser)->location;
3591   tree label = NULL_TREE;
3592   if (c_parser_next_token_is_keyword (parser, RID_CASE))
3593     {
3594       tree exp1, exp2;
3595       c_parser_consume_token (parser);
3596       exp1 = c_parser_expr_no_commas (parser, NULL).value;
3597       if (c_parser_next_token_is (parser, CPP_COLON))
3598         {
3599           c_parser_consume_token (parser);
3600           label = do_case (exp1, NULL_TREE);
3601         }
3602       else if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
3603         {
3604           c_parser_consume_token (parser);
3605           exp2 = c_parser_expr_no_commas (parser, NULL).value;
3606           if (c_parser_require (parser, CPP_COLON, "expected %<:%>"))
3607             label = do_case (exp1, exp2);
3608         }
3609       else
3610         c_parser_error (parser, "expected %<:%> or %<...%>");
3611     }
3612   else if (c_parser_next_token_is_keyword (parser, RID_DEFAULT))
3613     {
3614       c_parser_consume_token (parser);
3615       if (c_parser_require (parser, CPP_COLON, "expected %<:%>"))
3616         label = do_case (NULL_TREE, NULL_TREE);
3617     }
3618   else
3619     {
3620       tree name = c_parser_peek_token (parser)->value;
3621       tree tlab;
3622       tree attrs;
3623       location_t loc2 = c_parser_peek_token (parser)->location;
3624       gcc_assert (c_parser_next_token_is (parser, CPP_NAME));
3625       c_parser_consume_token (parser);
3626       gcc_assert (c_parser_next_token_is (parser, CPP_COLON));
3627       c_parser_consume_token (parser);
3628       attrs = c_parser_attributes (parser);
3629       tlab = define_label (loc2, name);
3630       if (tlab)
3631         {
3632           decl_attributes (&tlab, attrs, 0);
3633           label = add_stmt (build_stmt (LABEL_EXPR, tlab));
3634         }
3635     }
3636   if (label)
3637     {
3638       SET_EXPR_LOCATION (label, loc1);
3639       if (c_parser_next_token_starts_declspecs (parser)
3640           && !(c_parser_next_token_is (parser, CPP_NAME)
3641                && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
3642         {
3643           error ("%Ha label can only be part of a statement and "
3644                  "a declaration is not a statement",
3645                  &c_parser_peek_token (parser)->location);
3646           c_parser_declaration_or_fndef (parser, /*fndef_ok*/ false, 
3647                                          /*nested*/ true, /*empty_ok*/ false,
3648                                          /*start_attr_ok*/ true);
3649         }
3650     }
3651 }
3652
3653 /* Parse a statement (C90 6.6, C99 6.8).
3654
3655    statement:
3656      labeled-statement
3657      compound-statement
3658      expression-statement
3659      selection-statement
3660      iteration-statement
3661      jump-statement
3662
3663    labeled-statement:
3664      label statement
3665
3666    expression-statement:
3667      expression[opt] ;
3668
3669    selection-statement:
3670      if-statement
3671      switch-statement
3672
3673    iteration-statement:
3674      while-statement
3675      do-statement
3676      for-statement
3677
3678    jump-statement:
3679      goto identifier ;
3680      continue ;
3681      break ;
3682      return expression[opt] ;
3683
3684    GNU extensions:
3685
3686    statement:
3687      asm-statement
3688
3689    jump-statement:
3690      goto * expression ;
3691
3692    Objective-C:
3693
3694    statement:
3695      objc-throw-statement
3696      objc-try-catch-statement
3697      objc-synchronized-statement
3698
3699    objc-throw-statement:
3700      @throw expression ;
3701      @throw ;
3702
3703    OpenMP:
3704
3705    statement:
3706      openmp-construct
3707
3708    openmp-construct:
3709      parallel-construct
3710      for-construct
3711      sections-construct
3712      single-construct
3713      parallel-for-construct
3714      parallel-sections-construct
3715      master-construct
3716      critical-construct
3717      atomic-construct
3718      ordered-construct
3719
3720    parallel-construct:
3721      parallel-directive structured-block
3722
3723    for-construct:
3724      for-directive iteration-statement
3725
3726    sections-construct:
3727      sections-directive section-scope
3728
3729    single-construct:
3730      single-directive structured-block
3731
3732    parallel-for-construct:
3733      parallel-for-directive iteration-statement
3734
3735    parallel-sections-construct:
3736      parallel-sections-directive section-scope
3737
3738    master-construct:
3739      master-directive structured-block
3740
3741    critical-construct:
3742      critical-directive structured-block
3743
3744    atomic-construct:
3745      atomic-directive expression-statement
3746
3747    ordered-construct:
3748      ordered-directive structured-block  */
3749
3750 static void
3751 c_parser_statement (c_parser *parser)
3752 {
3753   while (c_parser_next_token_is_keyword (parser, RID_CASE)
3754          || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
3755          || (c_parser_next_token_is (parser, CPP_NAME)
3756              && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
3757     c_parser_label (parser);
3758   c_parser_statement_after_labels (parser);
3759 }
3760
3761 /* Parse a statement, other than a labeled statement.  */
3762
3763 static void
3764 c_parser_statement_after_labels (c_parser *parser)
3765 {
3766   location_t loc = c_parser_peek_token (parser)->location;
3767   tree stmt = NULL_TREE;
3768   bool in_if_block = parser->in_if_block;
3769   parser->in_if_block = false;
3770   switch (c_parser_peek_token (parser)->type)
3771     {
3772     case CPP_OPEN_BRACE:
3773       add_stmt (c_parser_compound_statement (parser));
3774       break;
3775     case CPP_KEYWORD:
3776       switch (c_parser_peek_token (parser)->keyword)
3777         {
3778         case RID_IF:
3779           c_parser_if_statement (parser);
3780           break;
3781         case RID_SWITCH:
3782           c_parser_switch_statement (parser);
3783           break;
3784         case RID_WHILE:
3785           c_parser_while_statement (parser);
3786           break;
3787         case RID_DO:
3788           c_parser_do_statement (parser);
3789           break;
3790         case RID_FOR:
3791           c_parser_for_statement (parser);
3792           break;
3793         case RID_GOTO:
3794           c_parser_consume_token (parser);
3795           if (c_parser_next_token_is (parser, CPP_NAME))
3796             {
3797               stmt = c_finish_goto_label (c_parser_peek_token (parser)->value);
3798               c_parser_consume_token (parser);
3799             }
3800           else if (c_parser_next_token_is (parser, CPP_MULT))
3801             {
3802               c_parser_consume_token (parser);
3803               stmt = c_finish_goto_ptr (c_parser_expression (parser).value);
3804             }
3805           else
3806             c_parser_error (parser, "expected identifier or %<*%>");
3807           goto expect_semicolon;
3808         case RID_CONTINUE:
3809           c_parser_consume_token (parser);
3810           stmt = c_finish_bc_stmt (&c_cont_label, false);
3811           goto expect_semicolon;
3812         case RID_BREAK:
3813           c_parser_consume_token (parser);
3814           stmt = c_finish_bc_stmt (&c_break_label, true);
3815           goto expect_semicolon;
3816         case RID_RETURN:
3817           c_parser_consume_token (parser);
3818           if (c_parser_next_token_is (parser, CPP_SEMICOLON))
3819             {
3820               stmt = c_finish_return (NULL_TREE);
3821               c_parser_consume_token (parser);
3822             }
3823           else
3824             {
3825               stmt = c_finish_return (c_parser_expression_conv (parser).value);
3826               goto expect_semicolon;
3827             }
3828           break;
3829         case RID_ASM:
3830           stmt = c_parser_asm_statement (parser);
3831           break;
3832         case RID_AT_THROW:
3833           gcc_assert (c_dialect_objc ());
3834           c_parser_consume_token (parser);
3835           if (c_parser_next_token_is (parser, CPP_SEMICOLON))
3836             {
3837               stmt = objc_build_throw_stmt (NULL_TREE);
3838               c_parser_consume_token (parser);
3839             }
3840           else
3841             {
3842               stmt
3843                 = objc_build_throw_stmt (c_parser_expression (parser).value);
3844               goto expect_semicolon;
3845             }
3846           break;
3847         case RID_AT_TRY:
3848           gcc_assert (c_dialect_objc ());
3849           c_parser_objc_try_catch_statement (parser);
3850           break;
3851         case RID_AT_SYNCHRONIZED:
3852           gcc_assert (c_dialect_objc ());
3853           c_parser_objc_synchronized_statement (parser);
3854           break;
3855         default:
3856           goto expr_stmt;
3857         }
3858       break;
3859     case CPP_SEMICOLON:
3860       c_parser_consume_token (parser);
3861       break;
3862     case CPP_CLOSE_PAREN:
3863     case CPP_CLOSE_SQUARE:
3864       /* Avoid infinite loop in error recovery:
3865          c_parser_skip_until_found stops at a closing nesting
3866          delimiter without consuming it, but here we need to consume
3867          it to proceed further.  */
3868       c_parser_error (parser, "expected statement");
3869       c_parser_consume_token (parser);
3870       break;
3871     case CPP_PRAGMA:
3872       c_parser_pragma (parser, pragma_stmt);
3873       break;
3874     default:
3875     expr_stmt:
3876       stmt = c_finish_expr_stmt (c_parser_expression_conv (parser).value);
3877     expect_semicolon:
3878       c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
3879       break;
3880     }
3881   /* Two cases cannot and do not have line numbers associated: If stmt
3882      is degenerate, such as "2;", then stmt is an INTEGER_CST, which
3883      cannot hold line numbers.  But that's OK because the statement
3884      will either be changed to a MODIFY_EXPR during gimplification of
3885      the statement expr, or discarded.  If stmt was compound, but
3886      without new variables, we will have skipped the creation of a
3887      BIND and will have a bare STATEMENT_LIST.  But that's OK because
3888      (recursively) all of the component statements should already have
3889      line numbers assigned.  ??? Can we discard no-op statements
3890      earlier?  */
3891   if (stmt && CAN_HAVE_LOCATION_P (stmt))
3892     SET_EXPR_LOCATION (stmt, loc);
3893
3894   parser->in_if_block = in_if_block;
3895 }
3896
3897 /* Parse a parenthesized condition from an if, do or while statement.
3898
3899    condition:
3900      ( expression )
3901 */
3902 static tree
3903 c_parser_paren_condition (c_parser *parser)
3904 {
3905   location_t loc;
3906   tree cond;
3907   if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
3908     return error_mark_node;
3909   loc = c_parser_peek_token (parser)->location;
3910   cond = c_objc_common_truthvalue_conversion
3911     (c_parser_expression_conv (parser).value);
3912   if (CAN_HAVE_LOCATION_P (cond))
3913     SET_EXPR_LOCATION (cond, loc);
3914   c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
3915   return cond;
3916 }
3917
3918 /* Parse a statement which is a block in C99.  */
3919
3920 static tree
3921 c_parser_c99_block_statement (c_parser *parser)
3922 {
3923   tree block = c_begin_compound_stmt (flag_isoc99);
3924   c_parser_statement (parser);
3925   return c_end_compound_stmt (block, flag_isoc99);
3926 }
3927
3928 /* Parse the body of an if statement.  This is just parsing a
3929    statement but (a) it is a block in C99, (b) we track whether the
3930    body is an if statement for the sake of -Wparentheses warnings, (c)
3931    we handle an empty body specially for the sake of -Wempty-body
3932    warnings, and (d) we call parser_compound_statement directly
3933    because c_parser_statement_after_labels resets
3934    parser->in_if_block.  */
3935
3936 static tree
3937 c_parser_if_body (c_parser *parser, bool *if_p)
3938 {
3939   tree block = c_begin_compound_stmt (flag_isoc99);
3940   while (c_parser_next_token_is_keyword (parser, RID_CASE)
3941          || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
3942          || (c_parser_next_token_is (parser, CPP_NAME)
3943              && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
3944     c_parser_label (parser);
3945   *if_p = c_parser_next_token_is_keyword (parser, RID_IF);
3946   if (c_parser_next_token_is (parser, CPP_SEMICOLON))
3947     {
3948       add_stmt (build_empty_stmt ());
3949       c_parser_consume_token (parser);
3950     }
3951   else if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
3952     add_stmt (c_parser_compound_statement (parser));
3953   else
3954     c_parser_statement_after_labels (parser);
3955   return c_end_compound_stmt (block, flag_isoc99);
3956 }
3957
3958 /* Parse the else body of an if statement.  This is just parsing a
3959    statement but (a) it is a block in C99, (b) we handle an empty body
3960    specially for the sake of -Wempty-body warnings.  */
3961
3962 static tree
3963 c_parser_else_body (c_parser *parser)
3964 {
3965   tree block = c_begin_compound_stmt (flag_isoc99);
3966   while (c_parser_next_token_is_keyword (parser, RID_CASE)
3967          || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
3968          || (c_parser_next_token_is (parser, CPP_NAME)
3969              && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
3970     c_parser_label (parser);
3971   if (c_parser_next_token_is (parser, CPP_SEMICOLON))
3972     {
3973       add_stmt (build_empty_stmt ());
3974       c_parser_consume_token (parser);
3975     }
3976   else 
3977     c_parser_statement_after_labels (parser);
3978   return c_end_compound_stmt (block, flag_isoc99);
3979 }
3980
3981 /* Parse an if statement (C90 6.6.4, C99 6.8.4).
3982
3983    if-statement:
3984      if ( expression ) statement
3985      if ( expression ) statement else statement
3986 */
3987
3988 static void
3989 c_parser_if_statement (c_parser *parser)
3990 {
3991   tree block;
3992   location_t loc;
3993   tree cond;
3994   bool first_if = false;
3995   tree first_body, second_body;
3996   bool in_if_block;
3997
3998   gcc_assert (c_parser_next_token_is_keyword (parser, RID_IF));
3999   c_parser_consume_token (parser);
4000   block = c_begin_compound_stmt (flag_isoc99);
4001   loc = c_parser_peek_token (parser)->location;
4002   cond = c_parser_paren_condition (parser);
4003   in_if_block = parser->in_if_block;
4004   parser->in_if_block = true;
4005   first_body = c_parser_if_body (parser, &first_if);
4006   parser->in_if_block = in_if_block;
4007   if (c_parser_next_token_is_keyword (parser, RID_ELSE))
4008     {
4009       c_parser_consume_token (parser);
4010       second_body = c_parser_else_body (parser);
4011     }
4012   else
4013     second_body = NULL_TREE;
4014   c_finish_if_stmt (loc, cond, first_body, second_body, first_if);
4015   add_stmt (c_end_compound_stmt (block, flag_isoc99));
4016 }
4017
4018 /* Parse a switch statement (C90 6.6.4, C99 6.8.4).
4019
4020    switch-statement:
4021      switch (expression) statement
4022 */
4023
4024 static void
4025 c_parser_switch_statement (c_parser *parser)
4026 {
4027   tree block, expr, body, save_break;
4028   gcc_assert (c_parser_next_token_is_keyword (parser, RID_SWITCH));
4029   c_parser_consume_token (parser);
4030   block = c_begin_compound_stmt (flag_isoc99);
4031   if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
4032     {
4033       expr = c_parser_expression (parser).value;
4034       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
4035     }
4036   else
4037     expr = error_mark_node;
4038   c_start_case (expr);
4039   save_break = c_break_label;
4040   c_break_label = NULL_TREE;
4041   body = c_parser_c99_block_statement (parser);
4042   c_finish_case (body);
4043   if (c_break_label)
4044     add_stmt (build1 (LABEL_EXPR, void_type_node, c_break_label));
4045   c_break_label = save_break;
4046   add_stmt (c_end_compound_stmt (block, flag_isoc99));
4047 }
4048
4049 /* Parse a while statement (C90 6.6.5, C99 6.8.5).
4050
4051    while-statement:
4052       while (expression) statement
4053 */
4054
4055 static void
4056 c_parser_while_statement (c_parser *parser)
4057 {
4058   tree block, cond, body, save_break, save_cont;
4059   location_t loc;
4060   gcc_assert (c_parser_next_token_is_keyword (parser, RID_WHILE));
4061   c_parser_consume_token (parser);
4062   block = c_begin_compound_stmt (flag_isoc99);
4063   loc = c_parser_peek_token (parser)->location;
4064   cond = c_parser_paren_condition (parser);
4065   save_break = c_break_label;
4066   c_break_label = NULL_TREE;
4067   save_cont = c_cont_label;
4068   c_cont_label = NULL_TREE;
4069   body = c_parser_c99_block_statement (parser);
4070   c_finish_loop (loc, cond, NULL, body, c_break_label, c_cont_label, true);
4071   add_stmt (c_end_compound_stmt (block, flag_isoc99));
4072   c_break_label = save_break;
4073   c_cont_label = save_cont;
4074 }
4075
4076 /* Parse a do statement (C90 6.6.5, C99 6.8.5).
4077
4078    do-statement:
4079      do statement while ( expression ) ;
4080 */
4081
4082 static void
4083 c_parser_do_statement (c_parser *parser)
4084 {
4085   tree block, cond, body, save_break, save_cont, new_break, new_cont;
4086   location_t loc;
4087   gcc_assert (c_parser_next_token_is_keyword (parser, RID_DO));
4088   c_parser_consume_token (parser);
4089   if (c_parser_next_token_is (parser, CPP_SEMICOLON))
4090     warning (OPT_Wempty_body,
4091              "%Hsuggest braces around empty body in %<do%> statement",
4092              &c_parser_peek_token (parser)->location);
4093   block = c_begin_compound_stmt (flag_isoc99);
4094   loc = c_parser_peek_token (parser)->location;
4095   save_break = c_break_label;