OSDN Git Service

PR c/28504
[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->pending_sizes = 0;
2541           ret->had_vla_unspec = 0;
2542           c_parser_consume_token (parser);
2543           pop_scope ();
2544           return ret;
2545         }
2546       else
2547         {
2548           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2549                                      "expected %<)%>");
2550           pop_scope ();
2551           return NULL;
2552         }
2553     }
2554   else
2555     {
2556       struct c_arg_info *ret = c_parser_parms_list_declarator (parser, attrs);
2557       pop_scope ();
2558       return ret;
2559     }
2560 }
2561
2562 /* Parse a parameter list (possibly empty), including the closing
2563    parenthesis but not the opening one.  ATTRS are the attributes at
2564    the start of the list.  */
2565
2566 static struct c_arg_info *
2567 c_parser_parms_list_declarator (c_parser *parser, tree attrs)
2568 {
2569   bool good_parm = false;
2570   /* ??? Following the old parser, forward parameter declarations may
2571      use abstract declarators, and if no real parameter declarations
2572      follow the forward declarations then this is not diagnosed.  Also
2573      note as above that attributes are ignored as the only contents of
2574      the parentheses, or as the only contents after forward
2575      declarations.  */
2576   if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2577     {
2578       struct c_arg_info *ret = XOBNEW (&parser_obstack, struct c_arg_info);
2579       ret->parms = 0;
2580       ret->tags = 0;
2581       ret->types = 0;
2582       ret->others = 0;
2583       ret->pending_sizes = 0;
2584       ret->had_vla_unspec = 0;
2585       c_parser_consume_token (parser);
2586       return ret;
2587     }
2588   if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
2589     {
2590       struct c_arg_info *ret = XOBNEW (&parser_obstack, struct c_arg_info);
2591       ret->parms = 0;
2592       ret->tags = 0;
2593       ret->others = 0;
2594       ret->pending_sizes = 0;
2595       ret->had_vla_unspec = 0;
2596       /* Suppress -Wold-style-definition for this case.  */
2597       ret->types = error_mark_node;
2598       error ("ISO C requires a named argument before %<...%>");
2599       c_parser_consume_token (parser);
2600       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2601         {
2602           c_parser_consume_token (parser);
2603           return ret;
2604         }
2605       else
2606         {
2607           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2608                                      "expected %<)%>");
2609           return NULL;
2610         }
2611     }
2612   /* Nonempty list of parameters, either terminated with semicolon
2613      (forward declarations; recurse) or with close parenthesis (normal
2614      function) or with ", ... )" (variadic function).  */
2615   while (true)
2616     {
2617       /* Parse a parameter.  */
2618       struct c_parm *parm = c_parser_parameter_declaration (parser, attrs);
2619       attrs = NULL_TREE;
2620       if (parm != NULL)
2621         {
2622           good_parm = true;
2623           push_parm_decl (parm);
2624         }
2625       if (c_parser_next_token_is (parser, CPP_SEMICOLON))
2626         {
2627           tree new_attrs;
2628           c_parser_consume_token (parser);
2629           mark_forward_parm_decls ();
2630           new_attrs = c_parser_attributes (parser);
2631           return c_parser_parms_list_declarator (parser, new_attrs);
2632         }
2633       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2634         {
2635           c_parser_consume_token (parser);
2636           if (good_parm)
2637             return get_parm_info (false);
2638           else
2639             {
2640               struct c_arg_info *ret
2641                 = XOBNEW (&parser_obstack, struct c_arg_info);
2642               ret->parms = 0;
2643               ret->tags = 0;
2644               ret->types = 0;
2645               ret->others = 0;
2646               ret->pending_sizes = 0;
2647               ret->had_vla_unspec = 0;
2648               return ret;
2649             }
2650         }
2651       if (!c_parser_require (parser, CPP_COMMA,
2652                              "expected %<;%>, %<,%> or %<)%>"))
2653         {
2654           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
2655           return NULL;
2656         }
2657       if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
2658         {
2659           c_parser_consume_token (parser);
2660           if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2661             {
2662               c_parser_consume_token (parser);
2663               if (good_parm)
2664                 return get_parm_info (true);
2665               else
2666                 {
2667                   struct c_arg_info *ret
2668                     = XOBNEW (&parser_obstack, struct c_arg_info);
2669                   ret->parms = 0;
2670                   ret->tags = 0;
2671                   ret->types = 0;
2672                   ret->others = 0;
2673                   ret->pending_sizes = 0;
2674                   ret->had_vla_unspec = 0;
2675                   return ret;
2676                 }
2677             }
2678           else
2679             {
2680               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2681                                          "expected %<)%>");
2682               return NULL;
2683             }
2684         }
2685     }
2686 }
2687
2688 /* Parse a parameter declaration.  ATTRS are the attributes at the
2689    start of the declaration if it is the first parameter.  */
2690
2691 static struct c_parm *
2692 c_parser_parameter_declaration (c_parser *parser, tree attrs)
2693 {
2694   struct c_declspecs *specs;
2695   struct c_declarator *declarator;
2696   tree prefix_attrs;
2697   tree postfix_attrs = NULL_TREE;
2698   bool dummy = false;
2699   if (!c_parser_next_token_starts_declspecs (parser))
2700     {
2701       /* ??? In some Objective-C cases '...' isn't applicable so there
2702          should be a different message.  */
2703       c_parser_error (parser,
2704                       "expected declaration specifiers or %<...%>");
2705       c_parser_skip_to_end_of_parameter (parser);
2706       return NULL;
2707     }
2708   specs = build_null_declspecs ();
2709   if (attrs)
2710     {
2711       declspecs_add_attrs (specs, attrs);
2712       attrs = NULL_TREE;
2713     }
2714   c_parser_declspecs (parser, specs, true, true, true);
2715   finish_declspecs (specs);
2716   pending_xref_error ();
2717   prefix_attrs = specs->attrs;
2718   specs->attrs = NULL_TREE;
2719   declarator = c_parser_declarator (parser, specs->type_seen_p,
2720                                     C_DTR_PARM, &dummy);
2721   if (declarator == NULL)
2722     {
2723       c_parser_skip_until_found (parser, CPP_COMMA, NULL);
2724       return NULL;
2725     }
2726   if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
2727     postfix_attrs = c_parser_attributes (parser);
2728   return build_c_parm (specs, chainon (postfix_attrs, prefix_attrs),
2729                        declarator);
2730 }
2731
2732 /* Parse a string literal in an asm expression.  It should not be
2733    translated, and wide string literals are an error although
2734    permitted by the syntax.  This is a GNU extension.
2735
2736    asm-string-literal:
2737      string-literal
2738
2739    ??? At present, following the old parser, the caller needs to have
2740    set c_lex_string_translate to 0.  It would be better to follow the
2741    C++ parser rather than using the c_lex_string_translate kludge.  */
2742
2743 static tree
2744 c_parser_asm_string_literal (c_parser *parser)
2745 {
2746   tree str;
2747   if (c_parser_next_token_is (parser, CPP_STRING))
2748     {
2749       str = c_parser_peek_token (parser)->value;
2750       c_parser_consume_token (parser);
2751     }
2752   else if (c_parser_next_token_is (parser, CPP_WSTRING))
2753     {
2754       error ("wide string literal in %<asm%>");
2755       str = build_string (1, "");
2756       c_parser_consume_token (parser);
2757     }
2758   else
2759     {
2760       c_parser_error (parser, "expected string literal");
2761       str = NULL_TREE;
2762     }
2763   return str;
2764 }
2765
2766 /* Parse a simple asm expression.  This is used in restricted
2767    contexts, where a full expression with inputs and outputs does not
2768    make sense.  This is a GNU extension.
2769
2770    simple-asm-expr:
2771      asm ( asm-string-literal )
2772 */
2773
2774 static tree
2775 c_parser_simple_asm_expr (c_parser *parser)
2776 {
2777   tree str;
2778   gcc_assert (c_parser_next_token_is_keyword (parser, RID_ASM));
2779   /* ??? Follow the C++ parser rather than using the
2780      c_lex_string_translate kludge.  */
2781   c_lex_string_translate = 0;
2782   c_parser_consume_token (parser);
2783   if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
2784     {
2785       c_lex_string_translate = 1;
2786       return NULL_TREE;
2787     }
2788   str = c_parser_asm_string_literal (parser);
2789   c_lex_string_translate = 1;
2790   if (!c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
2791     {
2792       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
2793       return NULL_TREE;
2794     }
2795   return str;
2796 }
2797
2798 /* Parse (possibly empty) attributes.  This is a GNU extension.
2799
2800    attributes:
2801      empty
2802      attributes attribute
2803
2804    attribute:
2805      __attribute__ ( ( attribute-list ) )
2806
2807    attribute-list:
2808      attrib
2809      attribute_list , attrib
2810
2811    attrib:
2812      empty
2813      any-word
2814      any-word ( identifier )
2815      any-word ( identifier , nonempty-expr-list )
2816      any-word ( expr-list )
2817
2818    where the "identifier" must not be declared as a type, and
2819    "any-word" may be any identifier (including one declared as a
2820    type), a reserved word storage class specifier, type specifier or
2821    type qualifier.  ??? This still leaves out most reserved keywords
2822    (following the old parser), shouldn't we include them, and why not
2823    allow identifiers declared as types to start the arguments?  */
2824
2825 static tree
2826 c_parser_attributes (c_parser *parser)
2827 {
2828   tree attrs = NULL_TREE;
2829   while (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
2830     {
2831       /* ??? Follow the C++ parser rather than using the
2832          c_lex_string_translate kludge.  */
2833       c_lex_string_translate = 0;
2834       c_parser_consume_token (parser);
2835       if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
2836         {
2837           c_lex_string_translate = 1;
2838           return attrs;
2839         }
2840       if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
2841         {
2842           c_lex_string_translate = 1;
2843           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
2844           return attrs;
2845         }
2846       /* Parse the attribute list.  */
2847       while (c_parser_next_token_is (parser, CPP_COMMA)
2848              || c_parser_next_token_is (parser, CPP_NAME)
2849              || c_parser_next_token_is (parser, CPP_KEYWORD))
2850         {
2851           tree attr, attr_name, attr_args;
2852           if (c_parser_next_token_is (parser, CPP_COMMA))
2853             {
2854               c_parser_consume_token (parser);
2855               continue;
2856             }
2857           if (c_parser_next_token_is (parser, CPP_KEYWORD))
2858             {
2859               /* ??? See comment above about what keywords are
2860                  accepted here.  */
2861               bool ok;
2862               switch (c_parser_peek_token (parser)->keyword)
2863                 {
2864                 case RID_STATIC:
2865                 case RID_UNSIGNED:
2866                 case RID_LONG:
2867                 case RID_CONST:
2868                 case RID_EXTERN:
2869                 case RID_REGISTER:
2870                 case RID_TYPEDEF:
2871                 case RID_SHORT:
2872                 case RID_INLINE:
2873                 case RID_VOLATILE:
2874                 case RID_SIGNED:
2875                 case RID_AUTO:
2876                 case RID_RESTRICT:
2877                 case RID_COMPLEX:
2878                 case RID_THREAD:
2879                 case RID_INT:
2880                 case RID_CHAR:
2881                 case RID_FLOAT:
2882                 case RID_DOUBLE:
2883                 case RID_VOID:
2884                 case RID_DFLOAT32:
2885                 case RID_DFLOAT64:
2886                 case RID_DFLOAT128:
2887                 case RID_BOOL:
2888                   ok = true;
2889                   break;
2890                 default:
2891                   ok = false;
2892                   break;
2893                 }
2894               if (!ok)
2895                 break;
2896             }
2897           attr_name = c_parser_peek_token (parser)->value;
2898           c_parser_consume_token (parser);
2899           if (c_parser_next_token_is_not (parser, CPP_OPEN_PAREN))
2900             {
2901               attr = build_tree_list (attr_name, NULL_TREE);
2902               attrs = chainon (attrs, attr);
2903               continue;
2904             }
2905           c_parser_consume_token (parser);
2906           /* Parse the attribute contents.  If they start with an
2907              identifier which is followed by a comma or close
2908              parenthesis, then the arguments start with that
2909              identifier; otherwise they are an expression list.  */
2910           if (c_parser_next_token_is (parser, CPP_NAME)
2911               && c_parser_peek_token (parser)->id_kind == C_ID_ID
2912               && ((c_parser_peek_2nd_token (parser)->type == CPP_COMMA)
2913                   || (c_parser_peek_2nd_token (parser)->type
2914                       == CPP_CLOSE_PAREN)))
2915             {
2916               tree arg1 = c_parser_peek_token (parser)->value;
2917               c_parser_consume_token (parser);
2918               if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2919                 attr_args = build_tree_list (NULL_TREE, arg1);
2920               else
2921                 {
2922                   c_parser_consume_token (parser);
2923                   attr_args = tree_cons (NULL_TREE, arg1,
2924                                          c_parser_expr_list (parser, false));
2925                 }
2926             }
2927           else
2928             {
2929               if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2930                 attr_args = NULL_TREE;
2931               else
2932                 attr_args = c_parser_expr_list (parser, false);
2933             }
2934           attr = build_tree_list (attr_name, attr_args);
2935           if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2936             c_parser_consume_token (parser);
2937           else
2938             {
2939               c_lex_string_translate = 1;
2940               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2941                                          "expected %<)%>");
2942               return attrs;
2943             }
2944           attrs = chainon (attrs, attr);
2945         }
2946       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2947         c_parser_consume_token (parser);
2948       else
2949         {
2950           c_lex_string_translate = 1;
2951           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2952                                      "expected %<)%>");
2953           return attrs;
2954         }
2955       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2956         c_parser_consume_token (parser);
2957       else
2958         {
2959           c_lex_string_translate = 1;
2960           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2961                                      "expected %<)%>");
2962           return attrs;
2963         }
2964       c_lex_string_translate = 1;
2965     }
2966   return attrs;
2967 }
2968
2969 /* Parse a type name (C90 6.5.5, C99 6.7.6).
2970
2971    type-name:
2972      specifier-qualifier-list abstract-declarator[opt]
2973 */
2974
2975 static struct c_type_name *
2976 c_parser_type_name (c_parser *parser)
2977 {
2978   struct c_declspecs *specs = build_null_declspecs ();
2979   struct c_declarator *declarator;
2980   struct c_type_name *ret;
2981   bool dummy = false;
2982   c_parser_declspecs (parser, specs, false, true, true);
2983   if (!specs->declspecs_seen_p)
2984     {
2985       c_parser_error (parser, "expected specifier-qualifier-list");
2986       return NULL;
2987     }
2988   pending_xref_error ();
2989   finish_declspecs (specs);
2990   declarator = c_parser_declarator (parser, specs->type_seen_p,
2991                                     C_DTR_ABSTRACT, &dummy);
2992   if (declarator == NULL)
2993     return NULL;
2994   ret = XOBNEW (&parser_obstack, struct c_type_name);
2995   ret->specs = specs;
2996   ret->declarator = declarator;
2997   return ret;
2998 }
2999
3000 /* Parse an initializer (C90 6.5.7, C99 6.7.8).
3001
3002    initializer:
3003      assignment-expression
3004      { initializer-list }
3005      { initializer-list , }
3006
3007    initializer-list:
3008      designation[opt] initializer
3009      initializer-list , designation[opt] initializer
3010
3011    designation:
3012      designator-list =
3013
3014    designator-list:
3015      designator
3016      designator-list designator
3017
3018    designator:
3019      array-designator
3020      . identifier
3021
3022    array-designator:
3023      [ constant-expression ]
3024
3025    GNU extensions:
3026
3027    initializer:
3028      { }
3029
3030    designation:
3031      array-designator
3032      identifier :
3033
3034    array-designator:
3035      [ constant-expression ... constant-expression ]
3036
3037    Any expression without commas is accepted in the syntax for the
3038    constant-expressions, with non-constant expressions rejected later.
3039
3040    This function is only used for top-level initializers; for nested
3041    ones, see c_parser_initval.  */
3042
3043 static struct c_expr
3044 c_parser_initializer (c_parser *parser)
3045 {
3046   if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
3047     return c_parser_braced_init (parser, NULL_TREE, false);
3048   else
3049     {
3050       struct c_expr ret;
3051       ret = c_parser_expr_no_commas (parser, NULL);
3052       if (TREE_CODE (ret.value) != STRING_CST
3053           && TREE_CODE (ret.value) != COMPOUND_LITERAL_EXPR)
3054         ret = default_function_array_conversion (ret);
3055       return ret;
3056     }
3057 }
3058
3059 /* Parse a braced initializer list.  TYPE is the type specified for a
3060    compound literal, and NULL_TREE for other initializers and for
3061    nested braced lists.  NESTED_P is true for nested braced lists,
3062    false for the list of a compound literal or the list that is the
3063    top-level initializer in a declaration.  */
3064
3065 static struct c_expr
3066 c_parser_braced_init (c_parser *parser, tree type, bool nested_p)
3067 {
3068   gcc_assert (c_parser_next_token_is (parser, CPP_OPEN_BRACE));
3069   c_parser_consume_token (parser);
3070   if (nested_p)
3071     push_init_level (0);
3072   else
3073     really_start_incremental_init (type);
3074   if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
3075     {
3076       if (pedantic)
3077         pedwarn ("ISO C forbids empty initializer braces");
3078     }
3079   else
3080     {
3081       /* Parse a non-empty initializer list, possibly with a trailing
3082          comma.  */
3083       while (true)
3084         {
3085           c_parser_initelt (parser);
3086           if (parser->error)
3087             break;
3088           if (c_parser_next_token_is (parser, CPP_COMMA))
3089             c_parser_consume_token (parser);
3090           else
3091             break;
3092           if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
3093             break;
3094         }
3095     }
3096   if (c_parser_next_token_is_not (parser, CPP_CLOSE_BRACE))
3097     {
3098       struct c_expr ret;
3099       ret.value = error_mark_node;
3100       ret.original_code = ERROR_MARK;
3101       c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, "expected %<}%>");
3102       return ret;
3103     }
3104   c_parser_consume_token (parser);
3105   return pop_init_level (0);
3106 }
3107
3108 /* Parse a nested initializer, including designators.  */
3109
3110 static void
3111 c_parser_initelt (c_parser *parser)
3112 {
3113   /* Parse any designator or designator list.  A single array
3114      designator may have the subsequent "=" omitted in GNU C, but a
3115      longer list or a structure member designator may not.  */
3116   if (c_parser_next_token_is (parser, CPP_NAME)
3117       && c_parser_peek_2nd_token (parser)->type == CPP_COLON)
3118     {
3119       /* Old-style structure member designator.  */
3120       set_init_label (c_parser_peek_token (parser)->value);
3121       if (pedantic)
3122         pedwarn ("obsolete use of designated initializer with %<:%>");
3123       c_parser_consume_token (parser);
3124       c_parser_consume_token (parser);
3125     }
3126   else
3127     {
3128       /* des_seen is 0 if there have been no designators, 1 if there
3129          has been a single array designator and 2 otherwise.  */
3130       int des_seen = 0;
3131       while (c_parser_next_token_is (parser, CPP_OPEN_SQUARE)
3132              || c_parser_next_token_is (parser, CPP_DOT))
3133         {
3134           int des_prev = des_seen;
3135           if (des_seen < 2)
3136             des_seen++;
3137           if (c_parser_next_token_is (parser, CPP_DOT))
3138             {
3139               des_seen = 2;
3140               c_parser_consume_token (parser);
3141               if (c_parser_next_token_is (parser, CPP_NAME))
3142                 {
3143                   set_init_label (c_parser_peek_token (parser)->value);
3144                   c_parser_consume_token (parser);
3145                 }
3146               else
3147                 {
3148                   struct c_expr init;
3149                   init.value = error_mark_node;
3150                   init.original_code = ERROR_MARK;
3151                   c_parser_error (parser, "expected identifier");
3152                   c_parser_skip_until_found (parser, CPP_COMMA, NULL);
3153                   process_init_element (init);
3154                   return;
3155                 }
3156             }
3157           else
3158             {
3159               tree first, second;
3160               /* ??? Following the old parser, [ objc-receiver
3161                  objc-message-args ] is accepted as an initializer,
3162                  being distinguished from a designator by what follows
3163                  the first assignment expression inside the square
3164                  brackets, but after a first array designator a
3165                  subsequent square bracket is for Objective-C taken to
3166                  start an expression, using the obsolete form of
3167                  designated initializer without '=', rather than
3168                  possibly being a second level of designation: in LALR
3169                  terms, the '[' is shifted rather than reducing
3170                  designator to designator-list.  */
3171               if (des_prev == 1 && c_dialect_objc ())
3172                 {
3173                   des_seen = des_prev;
3174                   break;
3175                 }
3176               if (des_prev == 0 && c_dialect_objc ())
3177                 {
3178                   /* This might be an array designator or an
3179                      Objective-C message expression.  If the former,
3180                      continue parsing here; if the latter, parse the
3181                      remainder of the initializer given the starting
3182                      primary-expression.  ??? It might make sense to
3183                      distinguish when des_prev == 1 as well; see
3184                      previous comment.  */
3185                   tree rec, args;
3186                   struct c_expr mexpr;
3187                   c_parser_consume_token (parser);
3188                   if (c_parser_peek_token (parser)->type == CPP_NAME
3189                       && ((c_parser_peek_token (parser)->id_kind
3190                            == C_ID_TYPENAME)
3191                           || (c_parser_peek_token (parser)->id_kind
3192                               == C_ID_CLASSNAME)))
3193                     {
3194                       /* Type name receiver.  */
3195                       tree id = c_parser_peek_token (parser)->value;
3196                       c_parser_consume_token (parser);
3197                       rec = objc_get_class_reference (id);
3198                       goto parse_message_args;
3199                     }
3200                   first = c_parser_expr_no_commas (parser, NULL).value;
3201                   if (c_parser_next_token_is (parser, CPP_ELLIPSIS)
3202                       || c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
3203                     goto array_desig_after_first;
3204                   /* Expression receiver.  So far only one part
3205                      without commas has been parsed; there might be
3206                      more of the expression.  */
3207                   rec = first;
3208                   while (c_parser_next_token_is (parser, CPP_COMMA))
3209                     {
3210                       struct c_expr next;
3211                       c_parser_consume_token (parser);
3212                       next = c_parser_expr_no_commas (parser, NULL);
3213                       next = default_function_array_conversion (next);
3214                       rec = build_compound_expr (rec, next.value);
3215                     }
3216                 parse_message_args:
3217                   /* Now parse the objc-message-args.  */
3218                   args = c_parser_objc_message_args (parser);
3219                   c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
3220                                              "expected %<]%>");
3221                   mexpr.value
3222                     = objc_build_message_expr (build_tree_list (rec, args));
3223                   mexpr.original_code = ERROR_MARK;
3224                   /* Now parse and process the remainder of the
3225                      initializer, starting with this message
3226                      expression as a primary-expression.  */
3227                   c_parser_initval (parser, &mexpr);
3228                   return;
3229                 }
3230               c_parser_consume_token (parser);
3231               first = c_parser_expr_no_commas (parser, NULL).value;
3232             array_desig_after_first:
3233               if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
3234                 {
3235                   c_parser_consume_token (parser);
3236                   second = c_parser_expr_no_commas (parser, NULL).value;
3237                 }
3238               else
3239                 second = NULL_TREE;
3240               if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
3241                 {
3242                   c_parser_consume_token (parser);
3243                   set_init_index (first, second);
3244                   if (pedantic && second)
3245                     pedwarn ("ISO C forbids specifying range of "
3246                              "elements to initialize");
3247                 }
3248               else
3249                 c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
3250                                            "expected %<]%>");
3251             }
3252         }
3253       if (des_seen >= 1)
3254         {
3255           if (c_parser_next_token_is (parser, CPP_EQ))
3256             {
3257               if (pedantic && !flag_isoc99)
3258                 pedwarn ("ISO C90 forbids specifying subobject to initialize");
3259               c_parser_consume_token (parser);
3260             }
3261           else
3262             {
3263               if (des_seen == 1)
3264                 {
3265                   if (pedantic)
3266                     pedwarn ("obsolete use of designated initializer "
3267                              "without %<=%>");
3268                 }
3269               else
3270                 {
3271                   struct c_expr init;
3272                   init.value = error_mark_node;
3273                   init.original_code = ERROR_MARK;
3274                   c_parser_error (parser, "expected %<=%>");
3275                   c_parser_skip_until_found (parser, CPP_COMMA, NULL);
3276                   process_init_element (init);
3277                   return;
3278                 }
3279             }
3280         }
3281     }
3282   c_parser_initval (parser, NULL);
3283 }
3284
3285 /* Parse a nested initializer; as c_parser_initializer but parses
3286    initializers within braced lists, after any designators have been
3287    applied.  If AFTER is not NULL then it is an Objective-C message
3288    expression which is the primary-expression starting the
3289    initializer.  */
3290
3291 static void
3292 c_parser_initval (c_parser *parser, struct c_expr *after)
3293 {
3294   struct c_expr init;
3295   gcc_assert (!after || c_dialect_objc ());
3296   if (c_parser_next_token_is (parser, CPP_OPEN_BRACE) && !after)
3297     init = c_parser_braced_init (parser, NULL_TREE, true);
3298   else
3299     {
3300       init = c_parser_expr_no_commas (parser, after);
3301       if (init.value != NULL_TREE
3302           && TREE_CODE (init.value) != STRING_CST
3303           && TREE_CODE (init.value) != COMPOUND_LITERAL_EXPR)
3304         init = default_function_array_conversion (init);
3305     }
3306   process_init_element (init);
3307 }
3308
3309 /* Parse a compound statement (possibly a function body) (C90 6.6.2,
3310    C99 6.8.2).
3311
3312    compound-statement:
3313      { block-item-list[opt] }
3314      { label-declarations block-item-list }
3315
3316    block-item-list:
3317      block-item
3318      block-item-list block-item
3319
3320    block-item:
3321      nested-declaration
3322      statement
3323
3324    nested-declaration:
3325      declaration
3326
3327    GNU extensions:
3328
3329    compound-statement:
3330      { label-declarations block-item-list }
3331
3332    nested-declaration:
3333      __extension__ nested-declaration
3334      nested-function-definition
3335
3336    label-declarations:
3337      label-declaration
3338      label-declarations label-declaration
3339
3340    label-declaration:
3341      __label__ identifier-list ;
3342
3343    Allowing the mixing of declarations and code is new in C99.  The
3344    GNU syntax also permits (not shown above) labels at the end of
3345    compound statements, which yield an error.  We don't allow labels
3346    on declarations; this might seem like a natural extension, but
3347    there would be a conflict between attributes on the label and
3348    prefix attributes on the declaration.  ??? The syntax follows the
3349    old parser in requiring something after label declarations.
3350    Although they are erroneous if the labels declared aren't defined,
3351    is it useful for the syntax to be this way?
3352    
3353    OpenMP:
3354    
3355    block-item:
3356      openmp-directive
3357
3358    openmp-directive:
3359      barrier-directive
3360      flush-directive  */
3361
3362 static tree
3363 c_parser_compound_statement (c_parser *parser)
3364 {
3365   tree stmt;
3366   if (!c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>"))
3367     return error_mark_node;
3368   stmt = c_begin_compound_stmt (true);
3369   c_parser_compound_statement_nostart (parser);
3370   return c_end_compound_stmt (stmt, true);
3371 }
3372
3373 /* Parse a compound statement except for the opening brace.  This is
3374    used for parsing both compound statements and statement expressions
3375    (which follow different paths to handling the opening).  */
3376
3377 static void
3378 c_parser_compound_statement_nostart (c_parser *parser)
3379 {
3380   bool last_stmt = false;
3381   bool last_label = false;
3382   if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
3383     {
3384       c_parser_consume_token (parser);
3385       return;
3386     }
3387   if (c_parser_next_token_is_keyword (parser, RID_LABEL))
3388     {
3389       /* Read zero or more forward-declarations for labels that nested
3390          functions can jump to.  */
3391       while (c_parser_next_token_is_keyword (parser, RID_LABEL))
3392         {
3393           c_parser_consume_token (parser);
3394           /* Any identifiers, including those declared as type names,
3395              are OK here.  */
3396           while (true)
3397             {
3398               tree label;
3399               if (c_parser_next_token_is_not (parser, CPP_NAME))
3400                 {
3401                   c_parser_error (parser, "expected identifier");
3402                   break;
3403                 }
3404               label
3405                 = declare_label (c_parser_peek_token (parser)->value);
3406               C_DECLARED_LABEL_FLAG (label) = 1;
3407               add_stmt (build_stmt (DECL_EXPR, label));
3408               c_parser_consume_token (parser);
3409               if (c_parser_next_token_is (parser, CPP_COMMA))
3410                 c_parser_consume_token (parser);
3411               else
3412                 break;
3413             }
3414           c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
3415         }
3416       /* ??? Locating this diagnostic on the token after the
3417          declarations end follows the old parser, but it might be
3418          better to locate it where the declarations start instead.  */
3419       if (pedantic)
3420         pedwarn ("ISO C forbids label declarations");
3421     }
3422   /* We must now have at least one statement, label or declaration.  */
3423   if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
3424     {
3425       c_parser_error (parser, "expected declaration or statement");
3426       c_parser_consume_token (parser);
3427       return;
3428     }
3429   while (c_parser_next_token_is_not (parser, CPP_CLOSE_BRACE))
3430     {
3431       location_t loc = c_parser_peek_token (parser)->location;
3432       if (c_parser_next_token_is_keyword (parser, RID_CASE)
3433           || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
3434           || (c_parser_next_token_is (parser, CPP_NAME)
3435               && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
3436         {
3437           last_label = true;
3438           last_stmt = false;
3439           c_parser_label (parser);
3440         }
3441       else if (!last_label
3442                && c_parser_next_token_starts_declspecs (parser))
3443         {
3444           last_label = false;
3445           c_parser_declaration_or_fndef (parser, true, true, true, true);
3446           if (last_stmt
3447               && ((pedantic && !flag_isoc99)
3448                   || warn_declaration_after_statement))
3449             pedwarn_c90 ("%HISO C90 forbids mixed declarations and code",
3450                          &loc);
3451           last_stmt = false;
3452         }
3453       else if (!last_label
3454                && c_parser_next_token_is_keyword (parser, RID_EXTENSION))
3455         {
3456           /* __extension__ can start a declaration, but is also an
3457              unary operator that can start an expression.  Consume all
3458              but the last of a possible series of __extension__ to
3459              determine which.  */
3460           while (c_parser_peek_2nd_token (parser)->type == CPP_KEYWORD
3461                  && (c_parser_peek_2nd_token (parser)->keyword
3462                      == RID_EXTENSION))
3463             c_parser_consume_token (parser);
3464           if (c_token_starts_declspecs (c_parser_peek_2nd_token (parser)))
3465             {
3466               int ext;
3467               ext = disable_extension_diagnostics ();
3468               c_parser_consume_token (parser);
3469               last_label = false;
3470               c_parser_declaration_or_fndef (parser, true, true, true, true);
3471               /* Following the old parser, __extension__ does not
3472                  disable this diagnostic.  */
3473               restore_extension_diagnostics (ext);
3474               if (last_stmt