OSDN Git Service

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