OSDN Git Service

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