OSDN Git Service

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