OSDN Git Service

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