OSDN Git Service

bf66a584ba8e580b2f37162f7fc30c667fe8af5f
[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
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       ret.spec = TREE_TYPE (expr.value);
2175       was_vm = variably_modified_type_p (ret.spec, NULL_TREE);
2176       /* This is returned with the type so that when the type is
2177          evaluated, this can be evaluated.  */
2178       if (was_vm)
2179         ret.expr = c_fully_fold (expr.value, false, &ret.expr_const_operands);
2180       pop_maybe_used (was_vm);
2181     }
2182   c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
2183   return ret;
2184 }
2185
2186 /* Parse a declarator, possibly an abstract declarator (C90 6.5.4,
2187    6.5.5, C99 6.7.5, 6.7.6).  If TYPE_SEEN_P then a typedef name may
2188    be redeclared; otherwise it may not.  KIND indicates which kind of
2189    declarator is wanted.  Returns a valid declarator except in the
2190    case of a syntax error in which case NULL is returned.  *SEEN_ID is
2191    set to true if an identifier being declared is seen; this is used
2192    to diagnose bad forms of abstract array declarators and to
2193    determine whether an identifier list is syntactically permitted.
2194
2195    declarator:
2196      pointer[opt] direct-declarator
2197
2198    direct-declarator:
2199      identifier
2200      ( attributes[opt] declarator )
2201      direct-declarator array-declarator
2202      direct-declarator ( parameter-type-list )
2203      direct-declarator ( identifier-list[opt] )
2204
2205    pointer:
2206      * type-qualifier-list[opt]
2207      * type-qualifier-list[opt] pointer
2208
2209    type-qualifier-list:
2210      type-qualifier
2211      attributes
2212      type-qualifier-list type-qualifier
2213      type-qualifier-list attributes
2214
2215    parameter-type-list:
2216      parameter-list
2217      parameter-list , ...
2218
2219    parameter-list:
2220      parameter-declaration
2221      parameter-list , parameter-declaration
2222
2223    parameter-declaration:
2224      declaration-specifiers declarator attributes[opt]
2225      declaration-specifiers abstract-declarator[opt] attributes[opt]
2226
2227    identifier-list:
2228      identifier
2229      identifier-list , identifier
2230
2231    abstract-declarator:
2232      pointer
2233      pointer[opt] direct-abstract-declarator
2234
2235    direct-abstract-declarator:
2236      ( attributes[opt] abstract-declarator )
2237      direct-abstract-declarator[opt] array-declarator
2238      direct-abstract-declarator[opt] ( parameter-type-list[opt] )
2239
2240    GNU extensions:
2241
2242    direct-declarator:
2243      direct-declarator ( parameter-forward-declarations
2244                          parameter-type-list[opt] )
2245
2246    direct-abstract-declarator:
2247      direct-abstract-declarator[opt] ( parameter-forward-declarations
2248                                        parameter-type-list[opt] )
2249
2250    parameter-forward-declarations:
2251      parameter-list ;
2252      parameter-forward-declarations parameter-list ;
2253
2254    The uses of attributes shown above are GNU extensions.
2255
2256    Some forms of array declarator are not included in C99 in the
2257    syntax for abstract declarators; these are disallowed elsewhere.
2258    This may be a defect (DR#289).
2259
2260    This function also accepts an omitted abstract declarator as being
2261    an abstract declarator, although not part of the formal syntax.  */
2262
2263 static struct c_declarator *
2264 c_parser_declarator (c_parser *parser, bool type_seen_p, c_dtr_syn kind,
2265                      bool *seen_id)
2266 {
2267   /* Parse any initial pointer part.  */
2268   if (c_parser_next_token_is (parser, CPP_MULT))
2269     {
2270       struct c_declspecs *quals_attrs = build_null_declspecs ();
2271       struct c_declarator *inner;
2272       c_parser_consume_token (parser);
2273       c_parser_declspecs (parser, quals_attrs, false, false, true);
2274       inner = c_parser_declarator (parser, type_seen_p, kind, seen_id);
2275       if (inner == NULL)
2276         return NULL;
2277       else
2278         return make_pointer_declarator (quals_attrs, inner);
2279     }
2280   /* Now we have a direct declarator, direct abstract declarator or
2281      nothing (which counts as a direct abstract declarator here).  */
2282   return c_parser_direct_declarator (parser, type_seen_p, kind, seen_id);
2283 }
2284
2285 /* Parse a direct declarator or direct abstract declarator; arguments
2286    as c_parser_declarator.  */
2287
2288 static struct c_declarator *
2289 c_parser_direct_declarator (c_parser *parser, bool type_seen_p, c_dtr_syn kind,
2290                             bool *seen_id)
2291 {
2292   /* The direct declarator must start with an identifier (possibly
2293      omitted) or a parenthesized declarator (possibly abstract).  In
2294      an ordinary declarator, initial parentheses must start a
2295      parenthesized declarator.  In an abstract declarator or parameter
2296      declarator, they could start a parenthesized declarator or a
2297      parameter list.  To tell which, the open parenthesis and any
2298      following attributes must be read.  If a declaration specifier
2299      follows, then it is a parameter list; if the specifier is a
2300      typedef name, there might be an ambiguity about redeclaring it,
2301      which is resolved in the direction of treating it as a typedef
2302      name.  If a close parenthesis follows, it is also an empty
2303      parameter list, as the syntax does not permit empty abstract
2304      declarators.  Otherwise, it is a parenthesized declarator (in
2305      which case the analysis may be repeated inside it, recursively).
2306
2307      ??? There is an ambiguity in a parameter declaration "int
2308      (__attribute__((foo)) x)", where x is not a typedef name: it
2309      could be an abstract declarator for a function, or declare x with
2310      parentheses.  The proper resolution of this ambiguity needs
2311      documenting.  At present we follow an accident of the old
2312      parser's implementation, whereby the first parameter must have
2313      some declaration specifiers other than just attributes.  Thus as
2314      a parameter declaration it is treated as a parenthesized
2315      parameter named x, and as an abstract declarator it is
2316      rejected.
2317
2318      ??? Also following the old parser, attributes inside an empty
2319      parameter list are ignored, making it a list not yielding a
2320      prototype, rather than giving an error or making it have one
2321      parameter with implicit type int.
2322
2323      ??? Also following the old parser, typedef names may be
2324      redeclared in declarators, but not Objective-C class names.  */
2325
2326   if (kind != C_DTR_ABSTRACT
2327       && c_parser_next_token_is (parser, CPP_NAME)
2328       && ((type_seen_p
2329            && c_parser_peek_token (parser)->id_kind == C_ID_TYPENAME)
2330           || c_parser_peek_token (parser)->id_kind == C_ID_ID))
2331     {
2332       struct c_declarator *inner
2333         = build_id_declarator (c_parser_peek_token (parser)->value);
2334       *seen_id = true;
2335       inner->id_loc = c_parser_peek_token (parser)->location;
2336       c_parser_consume_token (parser);
2337       return c_parser_direct_declarator_inner (parser, *seen_id, inner);
2338     }
2339
2340   if (kind != C_DTR_NORMAL
2341       && c_parser_next_token_is (parser, CPP_OPEN_SQUARE))
2342     {
2343       struct c_declarator *inner = build_id_declarator (NULL_TREE);
2344       return c_parser_direct_declarator_inner (parser, *seen_id, inner);
2345     }
2346
2347   /* Either we are at the end of an abstract declarator, or we have
2348      parentheses.  */
2349
2350   if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
2351     {
2352       tree attrs;
2353       struct c_declarator *inner;
2354       c_parser_consume_token (parser);
2355       attrs = c_parser_attributes (parser);
2356       if (kind != C_DTR_NORMAL
2357           && (c_parser_next_token_starts_declspecs (parser)
2358               || c_parser_next_token_is (parser, CPP_CLOSE_PAREN)))
2359         {
2360           struct c_arg_info *args
2361             = c_parser_parms_declarator (parser, kind == C_DTR_NORMAL,
2362                                          attrs);
2363           if (args == NULL)
2364             return NULL;
2365           else
2366             {
2367               inner
2368                 = build_function_declarator (args,
2369                                              build_id_declarator (NULL_TREE));
2370               return c_parser_direct_declarator_inner (parser, *seen_id,
2371                                                        inner);
2372             }
2373         }
2374       /* A parenthesized declarator.  */
2375       inner = c_parser_declarator (parser, type_seen_p, kind, seen_id);
2376       if (inner != NULL && attrs != NULL)
2377         inner = build_attrs_declarator (attrs, inner);
2378       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2379         {
2380           c_parser_consume_token (parser);
2381           if (inner == NULL)
2382             return NULL;
2383           else
2384             return c_parser_direct_declarator_inner (parser, *seen_id, inner);
2385         }
2386       else
2387         {
2388           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2389                                      "expected %<)%>");
2390           return NULL;
2391         }
2392     }
2393   else
2394     {
2395       if (kind == C_DTR_NORMAL)
2396         {
2397           c_parser_error (parser, "expected identifier or %<(%>");
2398           return NULL;
2399         }
2400       else
2401         return build_id_declarator (NULL_TREE);
2402     }
2403 }
2404
2405 /* Parse part of a direct declarator or direct abstract declarator,
2406    given that some (in INNER) has already been parsed; ID_PRESENT is
2407    true if an identifier is present, false for an abstract
2408    declarator.  */
2409
2410 static struct c_declarator *
2411 c_parser_direct_declarator_inner (c_parser *parser, bool id_present,
2412                                   struct c_declarator *inner)
2413 {
2414   /* Parse a sequence of array declarators and parameter lists.  */
2415   if (c_parser_next_token_is (parser, CPP_OPEN_SQUARE))
2416     {
2417       location_t brace_loc = c_parser_peek_token (parser)->location;
2418       struct c_declarator *declarator;
2419       struct c_declspecs *quals_attrs = build_null_declspecs ();
2420       bool static_seen;
2421       bool star_seen;
2422       tree dimen;
2423       c_parser_consume_token (parser);
2424       c_parser_declspecs (parser, quals_attrs, false, false, true);
2425       static_seen = c_parser_next_token_is_keyword (parser, RID_STATIC);
2426       if (static_seen)
2427         c_parser_consume_token (parser);
2428       if (static_seen && !quals_attrs->declspecs_seen_p)
2429         c_parser_declspecs (parser, quals_attrs, false, false, true);
2430       if (!quals_attrs->declspecs_seen_p)
2431         quals_attrs = NULL;
2432       /* If "static" is present, there must be an array dimension.
2433          Otherwise, there may be a dimension, "*", or no
2434          dimension.  */
2435       if (static_seen)
2436         {
2437           star_seen = false;
2438           dimen = c_parser_expr_no_commas (parser, NULL).value;
2439         }
2440       else
2441         {
2442           if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
2443             {
2444               dimen = NULL_TREE;
2445               star_seen = false;
2446             }
2447           else if (c_parser_next_token_is (parser, CPP_MULT))
2448             {
2449               if (c_parser_peek_2nd_token (parser)->type == CPP_CLOSE_SQUARE)
2450                 {
2451                   dimen = NULL_TREE;
2452                   star_seen = true;
2453                   c_parser_consume_token (parser);
2454                 }
2455               else
2456                 {
2457                   star_seen = false;
2458                   dimen = c_parser_expr_no_commas (parser, NULL).value;
2459                 }
2460             }
2461           else
2462             {
2463               star_seen = false;
2464               dimen = c_parser_expr_no_commas (parser, NULL).value;
2465             }
2466         }
2467       if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
2468         c_parser_consume_token (parser);
2469       else
2470         {
2471           c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
2472                                      "expected %<]%>");
2473           return NULL;
2474         }
2475       declarator = build_array_declarator (brace_loc, dimen, quals_attrs,
2476                                            static_seen, star_seen);
2477       if (declarator == NULL)
2478         return NULL;
2479       inner = set_array_declarator_inner (declarator, inner);
2480       return c_parser_direct_declarator_inner (parser, id_present, inner);
2481     }
2482   else if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
2483     {
2484       tree attrs;
2485       struct c_arg_info *args;
2486       c_parser_consume_token (parser);
2487       attrs = c_parser_attributes (parser);
2488       args = c_parser_parms_declarator (parser, id_present, attrs);
2489       if (args == NULL)
2490         return NULL;
2491       else
2492         {
2493           inner = build_function_declarator (args, inner);
2494           return c_parser_direct_declarator_inner (parser, id_present, inner);
2495         }
2496     }
2497   return inner;
2498 }
2499
2500 /* Parse a parameter list or identifier list, including the closing
2501    parenthesis but not the opening one.  ATTRS are the attributes at
2502    the start of the list.  ID_LIST_OK is true if an identifier list is
2503    acceptable; such a list must not have attributes at the start.  */
2504
2505 static struct c_arg_info *
2506 c_parser_parms_declarator (c_parser *parser, bool id_list_ok, tree attrs)
2507 {
2508   push_scope ();
2509   declare_parm_level ();
2510   /* If the list starts with an identifier, it is an identifier list.
2511      Otherwise, it is either a prototype list or an empty list.  */
2512   if (id_list_ok
2513       && !attrs
2514       && c_parser_next_token_is (parser, CPP_NAME)
2515       && c_parser_peek_token (parser)->id_kind == C_ID_ID)
2516     {
2517       tree list = NULL_TREE, *nextp = &list;
2518       while (c_parser_next_token_is (parser, CPP_NAME)
2519              && c_parser_peek_token (parser)->id_kind == C_ID_ID)
2520         {
2521           *nextp = build_tree_list (NULL_TREE,
2522                                     c_parser_peek_token (parser)->value);
2523           nextp = & TREE_CHAIN (*nextp);
2524           c_parser_consume_token (parser);
2525           if (c_parser_next_token_is_not (parser, CPP_COMMA))
2526             break;
2527           c_parser_consume_token (parser);
2528           if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2529             {
2530               c_parser_error (parser, "expected identifier");
2531               break;
2532             }
2533         }
2534       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2535         {
2536           struct c_arg_info *ret = XOBNEW (&parser_obstack, struct c_arg_info);
2537           ret->parms = 0;
2538           ret->tags = 0;
2539           ret->types = list;
2540           ret->others = 0;
2541           ret->pending_sizes = 0;
2542           ret->had_vla_unspec = 0;
2543           c_parser_consume_token (parser);
2544           pop_scope ();
2545           return ret;
2546         }
2547       else
2548         {
2549           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2550                                      "expected %<)%>");
2551           pop_scope ();
2552           return NULL;
2553         }
2554     }
2555   else
2556     {
2557       struct c_arg_info *ret = c_parser_parms_list_declarator (parser, attrs);
2558       pop_scope ();
2559       return ret;
2560     }
2561 }
2562
2563 /* Parse a parameter list (possibly empty), including the closing
2564    parenthesis but not the opening one.  ATTRS are the attributes at
2565    the start of the list.  */
2566
2567 static struct c_arg_info *
2568 c_parser_parms_list_declarator (c_parser *parser, tree attrs)
2569 {
2570   bool good_parm = false;
2571   /* ??? Following the old parser, forward parameter declarations may
2572      use abstract declarators, and if no real parameter declarations
2573      follow the forward declarations then this is not diagnosed.  Also
2574      note as above that attributes are ignored as the only contents of
2575      the parentheses, or as the only contents after forward
2576      declarations.  */
2577   if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2578     {
2579       struct c_arg_info *ret = XOBNEW (&parser_obstack, struct c_arg_info);
2580       ret->parms = 0;
2581       ret->tags = 0;
2582       ret->types = 0;
2583       ret->others = 0;
2584       ret->pending_sizes = 0;
2585       ret->had_vla_unspec = 0;
2586       c_parser_consume_token (parser);
2587       return ret;
2588     }
2589   if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
2590     {
2591       struct c_arg_info *ret = XOBNEW (&parser_obstack, struct c_arg_info);
2592       ret->parms = 0;
2593       ret->tags = 0;
2594       ret->others = 0;
2595       ret->pending_sizes = 0;
2596       ret->had_vla_unspec = 0;
2597       /* Suppress -Wold-style-definition for this case.  */
2598       ret->types = error_mark_node;
2599       error_at (c_parser_peek_token (parser)->location,
2600                 "ISO C requires a named argument before %<...%>");
2601       c_parser_consume_token (parser);
2602       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2603         {
2604           c_parser_consume_token (parser);
2605           return ret;
2606         }
2607       else
2608         {
2609           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2610                                      "expected %<)%>");
2611           return NULL;
2612         }
2613     }
2614   /* Nonempty list of parameters, either terminated with semicolon
2615      (forward declarations; recurse) or with close parenthesis (normal
2616      function) or with ", ... )" (variadic function).  */
2617   while (true)
2618     {
2619       /* Parse a parameter.  */
2620       struct c_parm *parm = c_parser_parameter_declaration (parser, attrs);
2621       attrs = NULL_TREE;
2622       if (parm != NULL)
2623         {
2624           good_parm = true;
2625           push_parm_decl (parm);
2626         }
2627       if (c_parser_next_token_is (parser, CPP_SEMICOLON))
2628         {
2629           tree new_attrs;
2630           c_parser_consume_token (parser);
2631           mark_forward_parm_decls ();
2632           new_attrs = c_parser_attributes (parser);
2633           return c_parser_parms_list_declarator (parser, new_attrs);
2634         }
2635       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2636         {
2637           c_parser_consume_token (parser);
2638           if (good_parm)
2639             return get_parm_info (false);
2640           else
2641             {
2642               struct c_arg_info *ret
2643                 = XOBNEW (&parser_obstack, struct c_arg_info);
2644               ret->parms = 0;
2645               ret->tags = 0;
2646               ret->types = 0;
2647               ret->others = 0;
2648               ret->pending_sizes = 0;
2649               ret->had_vla_unspec = 0;
2650               return ret;
2651             }
2652         }
2653       if (!c_parser_require (parser, CPP_COMMA,
2654                              "expected %<;%>, %<,%> or %<)%>"))
2655         {
2656           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
2657           get_pending_sizes ();
2658           return NULL;
2659         }
2660       if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
2661         {
2662           c_parser_consume_token (parser);
2663           if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2664             {
2665               c_parser_consume_token (parser);
2666               if (good_parm)
2667                 return get_parm_info (true);
2668               else
2669                 {
2670                   struct c_arg_info *ret
2671                     = XOBNEW (&parser_obstack, struct c_arg_info);
2672                   ret->parms = 0;
2673                   ret->tags = 0;
2674                   ret->types = 0;
2675                   ret->others = 0;
2676                   ret->pending_sizes = 0;
2677                   ret->had_vla_unspec = 0;
2678                   return ret;
2679                 }
2680             }
2681           else
2682             {
2683               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2684                                          "expected %<)%>");
2685               get_pending_sizes ();
2686               return NULL;
2687             }
2688         }
2689     }
2690 }
2691
2692 /* Parse a parameter declaration.  ATTRS are the attributes at the
2693    start of the declaration if it is the first parameter.  */
2694
2695 static struct c_parm *
2696 c_parser_parameter_declaration (c_parser *parser, tree attrs)
2697 {
2698   struct c_declspecs *specs;
2699   struct c_declarator *declarator;
2700   tree prefix_attrs;
2701   tree postfix_attrs = NULL_TREE;
2702   bool dummy = false;
2703   if (!c_parser_next_token_starts_declspecs (parser))
2704     {
2705       /* ??? In some Objective-C cases '...' isn't applicable so there
2706          should be a different message.  */
2707       c_parser_error (parser,
2708                       "expected declaration specifiers or %<...%>");
2709       c_parser_skip_to_end_of_parameter (parser);
2710       return NULL;
2711     }
2712   specs = build_null_declspecs ();
2713   if (attrs)
2714     {
2715       declspecs_add_attrs (specs, attrs);
2716       attrs = NULL_TREE;
2717     }
2718   c_parser_declspecs (parser, specs, true, true, true);
2719   finish_declspecs (specs);
2720   pending_xref_error ();
2721   prefix_attrs = specs->attrs;
2722   specs->attrs = NULL_TREE;
2723   declarator = c_parser_declarator (parser, specs->type_seen_p,
2724                                     C_DTR_PARM, &dummy);
2725   if (declarator == NULL)
2726     {
2727       c_parser_skip_until_found (parser, CPP_COMMA, NULL);
2728       return NULL;
2729     }
2730   if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
2731     postfix_attrs = c_parser_attributes (parser);
2732   return build_c_parm (specs, chainon (postfix_attrs, prefix_attrs),
2733                        declarator);
2734 }
2735
2736 /* Parse a string literal in an asm expression.  It should not be
2737    translated, and wide string literals are an error although
2738    permitted by the syntax.  This is a GNU extension.
2739
2740    asm-string-literal:
2741      string-literal
2742
2743    ??? At present, following the old parser, the caller needs to have
2744    set lex_untranslated_string to 1.  It would be better to follow the
2745    C++ parser rather than using this kludge.  */
2746
2747 static tree
2748 c_parser_asm_string_literal (c_parser *parser)
2749 {
2750   tree str;
2751   if (c_parser_next_token_is (parser, CPP_STRING))
2752     {
2753       str = c_parser_peek_token (parser)->value;
2754       c_parser_consume_token (parser);
2755     }
2756   else if (c_parser_next_token_is (parser, CPP_WSTRING))
2757     {
2758       error_at (c_parser_peek_token (parser)->location,
2759                 "wide string literal in %<asm%>");
2760       str = build_string (1, "");
2761       c_parser_consume_token (parser);
2762     }
2763   else
2764     {
2765       c_parser_error (parser, "expected string literal");
2766       str = NULL_TREE;
2767     }
2768   return str;
2769 }
2770
2771 /* Parse a simple asm expression.  This is used in restricted
2772    contexts, where a full expression with inputs and outputs does not
2773    make sense.  This is a GNU extension.
2774
2775    simple-asm-expr:
2776      asm ( asm-string-literal )
2777 */
2778
2779 static tree
2780 c_parser_simple_asm_expr (c_parser *parser)
2781 {
2782   tree str;
2783   gcc_assert (c_parser_next_token_is_keyword (parser, RID_ASM));
2784   /* ??? Follow the C++ parser rather than using the
2785      lex_untranslated_string kludge.  */
2786   parser->lex_untranslated_string = true;
2787   c_parser_consume_token (parser);
2788   if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
2789     {
2790       parser->lex_untranslated_string = false;
2791       return NULL_TREE;
2792     }
2793   str = c_parser_asm_string_literal (parser);
2794   parser->lex_untranslated_string = false;
2795   if (!c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
2796     {
2797       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
2798       return NULL_TREE;
2799     }
2800   return str;
2801 }
2802
2803 /* Parse (possibly empty) attributes.  This is a GNU extension.
2804
2805    attributes:
2806      empty
2807      attributes attribute
2808
2809    attribute:
2810      __attribute__ ( ( attribute-list ) )
2811
2812    attribute-list:
2813      attrib
2814      attribute_list , attrib
2815
2816    attrib:
2817      empty
2818      any-word
2819      any-word ( identifier )
2820      any-word ( identifier , nonempty-expr-list )
2821      any-word ( expr-list )
2822
2823    where the "identifier" must not be declared as a type, and
2824    "any-word" may be any identifier (including one declared as a
2825    type), a reserved word storage class specifier, type specifier or
2826    type qualifier.  ??? This still leaves out most reserved keywords
2827    (following the old parser), shouldn't we include them, and why not
2828    allow identifiers declared as types to start the arguments?  */
2829
2830 static tree
2831 c_parser_attributes (c_parser *parser)
2832 {
2833   tree attrs = NULL_TREE;
2834   while (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
2835     {
2836       /* ??? Follow the C++ parser rather than using the
2837          lex_untranslated_string kludge.  */
2838       parser->lex_untranslated_string = true;
2839       c_parser_consume_token (parser);
2840       if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
2841         {
2842           parser->lex_untranslated_string = false;
2843           return attrs;
2844         }
2845       if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
2846         {
2847           parser->lex_untranslated_string = false;
2848           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
2849           return attrs;
2850         }
2851       /* Parse the attribute list.  */
2852       while (c_parser_next_token_is (parser, CPP_COMMA)
2853              || c_parser_next_token_is (parser, CPP_NAME)
2854              || c_parser_next_token_is (parser, CPP_KEYWORD))
2855         {
2856           tree attr, attr_name, attr_args;
2857           VEC(tree,gc) *expr_list;
2858           if (c_parser_next_token_is (parser, CPP_COMMA))
2859             {
2860               c_parser_consume_token (parser);
2861               continue;
2862             }
2863           if (c_parser_next_token_is (parser, CPP_KEYWORD))
2864             {
2865               /* ??? See comment above about what keywords are
2866                  accepted here.  */
2867               bool ok;
2868               switch (c_parser_peek_token (parser)->keyword)
2869                 {
2870                 case RID_STATIC:
2871                 case RID_UNSIGNED:
2872                 case RID_LONG:
2873                 case RID_CONST:
2874                 case RID_EXTERN:
2875                 case RID_REGISTER:
2876                 case RID_TYPEDEF:
2877                 case RID_SHORT:
2878                 case RID_INLINE:
2879                 case RID_VOLATILE:
2880                 case RID_SIGNED:
2881                 case RID_AUTO:
2882                 case RID_RESTRICT:
2883                 case RID_COMPLEX:
2884                 case RID_THREAD:
2885                 case RID_INT:
2886                 case RID_CHAR:
2887                 case RID_FLOAT:
2888                 case RID_DOUBLE:
2889                 case RID_VOID:
2890                 case RID_DFLOAT32:
2891                 case RID_DFLOAT64:
2892                 case RID_DFLOAT128:
2893                 case RID_BOOL:
2894                 case RID_FRACT:
2895                 case RID_ACCUM:
2896                 case RID_SAT:
2897                   ok = true;
2898                   break;
2899                 default:
2900                   ok = false;
2901                   break;
2902                 }
2903               if (!ok)
2904                 break;
2905               /* Accept __attribute__((__const)) as __attribute__((const))
2906                  etc.  */
2907               attr_name
2908                 = ridpointers[(int) c_parser_peek_token (parser)->keyword];
2909             }
2910           else
2911             attr_name = c_parser_peek_token (parser)->value;
2912           c_parser_consume_token (parser);
2913           if (c_parser_next_token_is_not (parser, CPP_OPEN_PAREN))
2914             {
2915               attr = build_tree_list (attr_name, NULL_TREE);
2916               attrs = chainon (attrs, attr);
2917               continue;
2918             }
2919           c_parser_consume_token (parser);
2920           /* Parse the attribute contents.  If they start with an
2921              identifier which is followed by a comma or close
2922              parenthesis, then the arguments start with that
2923              identifier; otherwise they are an expression list.  */
2924           if (c_parser_next_token_is (parser, CPP_NAME)
2925               && c_parser_peek_token (parser)->id_kind == C_ID_ID
2926               && ((c_parser_peek_2nd_token (parser)->type == CPP_COMMA)
2927                   || (c_parser_peek_2nd_token (parser)->type
2928                       == CPP_CLOSE_PAREN)))
2929             {
2930               tree arg1 = c_parser_peek_token (parser)->value;
2931               c_parser_consume_token (parser);
2932               if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2933                 attr_args = build_tree_list (NULL_TREE, arg1);
2934               else
2935                 {
2936                   tree tree_list;
2937                   c_parser_consume_token (parser);
2938                   expr_list = c_parser_expr_list (parser, false, true, NULL);
2939                   tree_list = build_tree_list_vec (expr_list);
2940                   attr_args = tree_cons (NULL_TREE, arg1, tree_list);
2941                   release_tree_vector (expr_list);
2942                 }
2943             }
2944           else
2945             {
2946               if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2947                 attr_args = NULL_TREE;
2948               else
2949                 {
2950                   expr_list = c_parser_expr_list (parser, false, true, NULL);
2951                   attr_args = build_tree_list_vec (expr_list);
2952                   release_tree_vector (expr_list);
2953                 }
2954             }
2955           attr = build_tree_list (attr_name, attr_args);
2956           if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2957             c_parser_consume_token (parser);
2958           else
2959             {
2960               parser->lex_untranslated_string = false;
2961               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2962                                          "expected %<)%>");
2963               return attrs;
2964             }
2965           attrs = chainon (attrs, attr);
2966         }
2967       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2968         c_parser_consume_token (parser);
2969       else
2970         {
2971           parser->lex_untranslated_string = false;
2972           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2973                                      "expected %<)%>");
2974           return attrs;
2975         }
2976       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2977         c_parser_consume_token (parser);
2978       else
2979         {
2980           parser->lex_untranslated_string = false;
2981           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2982                                      "expected %<)%>");
2983           return attrs;
2984         }
2985       parser->lex_untranslated_string = false;
2986     }
2987   return attrs;
2988 }
2989
2990 /* Parse a type name (C90 6.5.5, C99 6.7.6).
2991
2992    type-name:
2993      specifier-qualifier-list abstract-declarator[opt]
2994 */
2995
2996 static struct c_type_name *
2997 c_parser_type_name (c_parser *parser)
2998 {
2999   struct c_declspecs *specs = build_null_declspecs ();
3000   struct c_declarator *declarator;
3001   struct c_type_name *ret;
3002   bool dummy = false;
3003   c_parser_declspecs (parser, specs, false, true, true);
3004   if (!specs->declspecs_seen_p)
3005     {
3006       c_parser_error (parser, "expected specifier-qualifier-list");
3007       return NULL;
3008     }
3009   pending_xref_error ();
3010   finish_declspecs (specs);
3011   declarator = c_parser_declarator (parser, specs->type_seen_p,
3012                                     C_DTR_ABSTRACT, &dummy);
3013   if (declarator == NULL)
3014     return NULL;
3015   ret = XOBNEW (&parser_obstack, struct c_type_name);
3016   ret->specs = specs;
3017   ret->declarator = declarator;
3018   return ret;
3019 }
3020
3021 /* Parse an initializer (C90 6.5.7, C99 6.7.8).
3022
3023    initializer:
3024      assignment-expression
3025      { initializer-list }
3026      { initializer-list , }
3027
3028    initializer-list:
3029      designation[opt] initializer
3030      initializer-list , designation[opt] initializer
3031
3032    designation:
3033      designator-list =
3034
3035    designator-list:
3036      designator
3037      designator-list designator
3038
3039    designator:
3040      array-designator
3041      . identifier
3042
3043    array-designator:
3044      [ constant-expression ]
3045
3046    GNU extensions:
3047
3048    initializer:
3049      { }
3050
3051    designation:
3052      array-designator
3053      identifier :
3054
3055    array-designator:
3056      [ constant-expression ... constant-expression ]
3057
3058    Any expression without commas is accepted in the syntax for the
3059    constant-expressions, with non-constant expressions rejected later.
3060
3061    This function is only used for top-level initializers; for nested
3062    ones, see c_parser_initval.  */
3063
3064 static struct c_expr
3065 c_parser_initializer (c_parser *parser)
3066 {
3067   if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
3068     return c_parser_braced_init (parser, NULL_TREE, false);
3069   else
3070     {
3071       struct c_expr ret;
3072       location_t loc = c_parser_peek_token (parser)->location;
3073       ret = c_parser_expr_no_commas (parser, NULL);
3074       if (TREE_CODE (ret.value) != STRING_CST
3075           && TREE_CODE (ret.value) != COMPOUND_LITERAL_EXPR)
3076         ret = default_function_array_conversion (loc, ret);
3077       return ret;
3078     }
3079 }
3080
3081 /* Parse a braced initializer list.  TYPE is the type specified for a
3082    compound literal, and NULL_TREE for other initializers and for
3083    nested braced lists.  NESTED_P is true for nested braced lists,
3084    false for the list of a compound literal or the list that is the
3085    top-level initializer in a declaration.  */
3086
3087 static struct c_expr
3088 c_parser_braced_init (c_parser *parser, tree type, bool nested_p)
3089 {
3090   location_t brace_loc = c_parser_peek_token (parser)->location;
3091   gcc_assert (c_parser_next_token_is (parser, CPP_OPEN_BRACE));
3092   c_parser_consume_token (parser);
3093   if (nested_p)
3094     push_init_level (0);
3095   else
3096     really_start_incremental_init (type);
3097   if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
3098     {
3099       pedwarn (brace_loc, OPT_pedantic, "ISO C forbids empty initializer braces");
3100     }
3101   else
3102     {
3103       /* Parse a non-empty initializer list, possibly with a trailing
3104          comma.  */
3105       while (true)
3106         {
3107           c_parser_initelt (parser);
3108           if (parser->error)
3109             break;
3110           if (c_parser_next_token_is (parser, CPP_COMMA))
3111             c_parser_consume_token (parser);
3112           else
3113             break;
3114           if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
3115             break;
3116         }
3117     }
3118   if (c_parser_next_token_is_not (parser, CPP_CLOSE_BRACE))
3119     {
3120       struct c_expr ret;
3121       ret.value = error_mark_node;
3122       ret.original_code = ERROR_MARK;
3123       ret.original_type = NULL;
3124       c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, "expected %<}%>");
3125       pop_init_level (0);
3126       return ret;
3127     }
3128   c_parser_consume_token (parser);
3129   return pop_init_level (0);
3130 }
3131
3132 /* Parse a nested initializer, including designators.  */
3133
3134 static void
3135 c_parser_initelt (c_parser *parser)
3136 {
3137   /* Parse any designator or designator list.  A single array
3138      designator may have the subsequent "=" omitted in GNU C, but a
3139      longer list or a structure member designator may not.  */
3140   if (c_parser_next_token_is (parser, CPP_NAME)
3141       && c_parser_peek_2nd_token (parser)->type == CPP_COLON)
3142     {
3143       /* Old-style structure member designator.  */
3144       set_init_label (c_parser_peek_token (parser)->value);
3145       /* Use the colon as the error location.  */
3146       pedwarn (c_parser_peek_2nd_token (parser)->location, OPT_pedantic,
3147                "obsolete use of designated initializer with %<:%>");
3148       c_parser_consume_token (parser);
3149       c_parser_consume_token (parser);
3150     }
3151   else
3152     {
3153       /* des_seen is 0 if there have been no designators, 1 if there
3154          has been a single array designator and 2 otherwise.  */
3155       int des_seen = 0;
3156       /* Location of a designator.  */
3157       location_t des_loc = UNKNOWN_LOCATION;  /* Quiet warning.  */
3158       while (c_parser_next_token_is (parser, CPP_OPEN_SQUARE)
3159              || c_parser_next_token_is (parser, CPP_DOT))
3160         {
3161           int des_prev = des_seen;
3162           if (!des_seen)
3163             des_loc = c_parser_peek_token (parser)->location;
3164           if (des_seen < 2)
3165             des_seen++;
3166           if (c_parser_next_token_is (parser, CPP_DOT))
3167             {
3168               des_seen = 2;
3169               c_parser_consume_token (parser);
3170               if (c_parser_next_token_is (parser, CPP_NAME))
3171                 {
3172                   set_init_label (c_parser_peek_token (parser)->value);
3173                   c_parser_consume_token (parser);
3174                 }
3175               else
3176                 {
3177                   struct c_expr init;
3178                   init.value = error_mark_node;
3179                   init.original_code = ERROR_MARK;
3180                   init.original_type = NULL;
3181                   c_parser_error (parser, "expected identifier");
3182                   c_parser_skip_until_found (parser, CPP_COMMA, NULL);
3183                   process_init_element (init, false);
3184                   return;
3185                 }
3186             }
3187           else
3188             {
3189               tree first, second;
3190               location_t ellipsis_loc = UNKNOWN_LOCATION;  /* Quiet warning.  */
3191               /* ??? Following the old parser, [ objc-receiver
3192                  objc-message-args ] is accepted as an initializer,
3193                  being distinguished from a designator by what follows
3194                  the first assignment expression inside the square
3195                  brackets, but after a first array designator a
3196                  subsequent square bracket is for Objective-C taken to
3197                  start an expression, using the obsolete form of
3198                  designated initializer without '=', rather than
3199                  possibly being a second level of designation: in LALR
3200                  terms, the '[' is shifted rather than reducing
3201                  designator to designator-list.  */
3202               if (des_prev == 1 && c_dialect_objc ())
3203                 {
3204                   des_seen = des_prev;
3205                   break;
3206                 }
3207               if (des_prev == 0 && c_dialect_objc ())
3208                 {
3209                   /* This might be an array designator or an
3210                      Objective-C message expression.  If the former,
3211                      continue parsing here; if the latter, parse the
3212                      remainder of the initializer given the starting
3213                      primary-expression.  ??? It might make sense to
3214                      distinguish when des_prev == 1 as well; see
3215                      previous comment.  */
3216                   tree rec, args;
3217                   struct c_expr mexpr;
3218                   c_parser_consume_token (parser);
3219                   if (c_parser_peek_token (parser)->type == CPP_NAME
3220                       && ((c_parser_peek_token (parser)->id_kind
3221                            == C_ID_TYPENAME)
3222                           || (c_parser_peek_token (parser)->id_kind
3223                               == C_ID_CLASSNAME)))
3224                     {
3225                       /* Type name receiver.  */
3226                       tree id = c_parser_peek_token (parser)->value;
3227                       c_parser_consume_token (parser);
3228                       rec = objc_get_class_reference (id);
3229                       goto parse_message_args;
3230                     }
3231                   first = c_parser_expr_no_commas (parser, NULL).value;
3232                   if (c_parser_next_token_is (parser, CPP_ELLIPSIS)
3233                       || c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
3234                     goto array_desig_after_first;
3235                   /* Expression receiver.  So far only one part
3236                      without commas has been parsed; there might be
3237                      more of the expression.  */
3238                   rec = first;
3239                   while (c_parser_next_token_is (parser, CPP_COMMA))
3240                     {
3241                       struct c_expr next;
3242                       location_t comma_loc, exp_loc;
3243                       comma_loc = c_parser_peek_token (parser)->location;
3244                       c_parser_consume_token (parser);
3245                       exp_loc = c_parser_peek_token (parser)->location;
3246                       next = c_parser_expr_no_commas (parser, NULL);
3247                       next = default_function_array_conversion (exp_loc, next);
3248                       rec = build_compound_expr (comma_loc, rec, next.value);
3249                     }
3250                 parse_message_args:
3251                   /* Now parse the objc-message-args.  */
3252                   args = c_parser_objc_message_args (parser);
3253                   c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
3254                                              "expected %<]%>");
3255                   mexpr.value
3256                     = objc_build_message_expr (build_tree_list (rec, args));
3257                   mexpr.original_code = ERROR_MARK;
3258                   mexpr.original_type = NULL;
3259                   /* Now parse and process the remainder of the
3260                      initializer, starting with this message
3261                      expression as a primary-expression.  */
3262                   c_parser_initval (parser, &mexpr);
3263                   return;
3264                 }
3265               c_parser_consume_token (parser);
3266               first = c_parser_expr_no_commas (parser, NULL).value;
3267             array_desig_after_first:
3268               if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
3269                 {
3270                   ellipsis_loc = c_parser_peek_token (parser)->location;
3271                   c_parser_consume_token (parser);
3272                   second = c_parser_expr_no_commas (parser, NULL).value;
3273                 }
3274               else
3275                 second = NULL_TREE;
3276               if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
3277                 {
3278                   c_parser_consume_token (parser);
3279                   set_init_index (first, second);
3280                   if (second)
3281                     pedwarn (ellipsis_loc, OPT_pedantic,
3282                              "ISO C forbids specifying range of elements to initialize");
3283                 }
3284               else
3285                 c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
3286                                            "expected %<]%>");
3287             }
3288         }
3289       if (des_seen >= 1)
3290         {
3291           if (c_parser_next_token_is (parser, CPP_EQ))
3292             {
3293               if (!flag_isoc99)
3294                 pedwarn (des_loc, OPT_pedantic,
3295                          "ISO C90 forbids specifying subobject to initialize");
3296               c_parser_consume_token (parser);
3297             }
3298           else
3299             {
3300               if (des_seen == 1)
3301                 pedwarn (c_parser_peek_token (parser)->location, OPT_pedantic,
3302                          "obsolete use of designated initializer without %<=%>");
3303               else
3304                 {
3305                   struct c_expr init;
3306                   init.value = error_mark_node;
3307                   init.original_code = ERROR_MARK;
3308                   init.original_type = NULL;
3309                   c_parser_error (parser, "expected %<=%>");
3310                   c_parser_skip_until_found (parser, CPP_COMMA, NULL);
3311                   process_init_element (init, false);
3312                   return;
3313                 }
3314             }
3315         }
3316     }
3317   c_parser_initval (parser, NULL);
3318 }
3319
3320 /* Parse a nested initializer; as c_parser_initializer but parses
3321    initializers within braced lists, after any designators have been
3322    applied.  If AFTER is not NULL then it is an Objective-C message
3323    expression which is the primary-expression starting the
3324    initializer.  */
3325
3326 static void
3327 c_parser_initval (c_parser *parser, struct c_expr *after)
3328 {
3329   struct c_expr init;
3330   gcc_assert (!after || c_dialect_objc ());
3331   if (c_parser_next_token_is (parser, CPP_OPEN_BRACE) && !after)
3332     init = c_parser_braced_init (parser, NULL_TREE, true);
3333   else
3334     {
3335       location_t loc = c_parser_peek_token (parser)->location;
3336       init = c_parser_expr_no_commas (parser, after);
3337       if (init.value != NULL_TREE
3338           && TREE_CODE (init.value) != STRING_CST
3339           && TREE_CODE (init.value) != COMPOUND_LITERAL_EXPR)
3340         init = default_function_array_conversion (loc, init);
3341     }
3342   process_init_element (init, false);
3343 }
3344
3345 /* Parse a compound statement (possibly a function body) (C90 6.6.2,
3346    C99 6.8.2).
3347
3348    compound-statement:
3349      { block-item-list[opt] }
3350      { label-declarations block-item-list }
3351
3352    block-item-list:
3353      block-item
3354      block-item-list block-item
3355
3356    block-item:
3357      nested-declaration
3358      statement
3359
3360    nested-declaration:
3361      declaration
3362
3363    GNU extensions:
3364
3365    compound-statement:
3366      { label-declarations block-item-list }
3367
3368    nested-declaration:
3369      __extension__ nested-declaration
3370      nested-function-definition
3371
3372    label-declarations:
3373      label-declaration
3374      label-declarations label-declaration
3375
3376    label-declaration:
3377      __label__ identifier-list ;
3378
3379    Allowing the mixing of declarations and code is new in C99.  The
3380    GNU syntax also permits (not shown above) labels at the end of
3381    compound statements, which yield an error.  We don't allow labels
3382    on declarations; this might seem like a natural extension, but
3383    there would be a conflict between attributes on the label and
3384    prefix attributes on the declaration.  ??? The syntax follows the
3385    old parser in requiring something after label declarations.
3386    Although they are erroneous if the labels declared aren't defined,
3387    is it useful for the syntax to be this way?
3388
3389    OpenMP:
3390
3391    block-item:
3392      openmp-directive
3393
3394    openmp-directive:
3395      barrier-directive
3396      flush-directive  */
3397
3398 static tree
3399 c_parser_compound_statement (c_parser *parser)
3400 {
3401   tree stmt;
3402   location_t brace_loc;
3403   brace_loc = c_parser_peek_token (parser)->location;
3404   if (!c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>"))
3405     {
3406       /* Ensure a scope is entered and left anyway to avoid confusion
3407          if we have just prepared to enter a function body.  */
3408       stmt = c_begin_compound_stmt (true);
3409       c_end_compound_stmt (brace_loc, stmt, true);
3410       return error_mark_node;
3411     }
3412   stmt = c_begin_compound_stmt (true);
3413   c_parser_compound_statement_nostart (parser);
3414   return c_end_compound_stmt (brace_loc, stmt, true);
3415 }
3416
3417 /* Parse a compound statement except for the opening brace.  This is
3418    used for parsing both compound statements and statement expressions
3419    (which follow different paths to handling the opening).  */
3420
3421 static void
3422 c_parser_compound_statement_nostart (c_parser *parser)
3423 {
3424   bool last_stmt = false;
3425   bool last_label = false;
3426   bool save_valid_for_pragma = valid_location_for_stdc_pragma_p ();
3427   location_t label_loc = UNKNOWN_LOCATION;  /* Quiet warning.  */
3428   if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
3429     {
3430       c_parser_consume_token (parser);
3431       return;
3432     }
3433   mark_valid_location_for_stdc_pragma (true);
3434   if (c_parser_next_token_is_keyword (parser, RID_LABEL))
3435     {
3436       /* Read zero or more forward-declarations for labels that nested
3437          functions can jump to.  */
3438       mark_valid_location_for_stdc_pragma (false);
3439       while (c_parser_next_token_is_keyword (parser, RID_LABEL))
3440         {
3441           label_loc = c_parser_peek_token (parser)->location;
3442           c_parser_consume_token (parser);
3443           /* Any identifiers, including those declared as type names,
3444              are OK here.  */
3445           while (true)
3446             {
3447               tree label;
3448               if (c_parser_next_token_is_not (parser, CPP_NAME))
3449                 {
3450                   c_parser_error (parser, "expected identifier");
3451                   break;
3452                 }
3453               label
3454                 = declare_label (c_parser_peek_token (parser)->value);
3455               C_DECLARED_LABEL_FLAG (label) = 1;
3456               add_stmt (build_stmt (label_loc, DECL_EXPR, label));
3457               c_parser_consume_token (parser);
3458               if (c_parser_next_token_is (parser, CPP_COMMA))
3459                 c_parser_consume_token (parser);
3460               else
3461                 break;
3462             }
3463           c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
3464         }
3465       pedwarn (label_loc, OPT_pedantic, "ISO C forbids label declarations");
3466     }
3467   /* We must now have at least one statement, label or declaration.  */
3468   if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
3469     {
3470       mark_valid_location_for_stdc_pragma (save_valid_for_pragma);
3471       c_parser_error (parser, "expected declaration or statement");
3472       c_parser_consume_token (parser);
3473       return;
3474     }
3475   while (c_parser_next_token_is_not (parser, CPP_CLOSE_BRACE))
3476     {
3477       location_t loc = c_parser_peek_token (parser)->location;
3478       if (c_parser_next_token_is_keyword (parser, RID_CASE)
3479           || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
3480           || (c_parser_next_token_is (parser, CPP_NAME)
3481               && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
3482         {
3483           if (c_parser_next_token_is_keyword (parser, RID_CASE))
3484             label_loc = c_parser_peek_2nd_token (parser)->location;
3485           else
3486             label_loc = c_parser_peek_token (parser)->location;
3487           last_label = true;
3488           last_stmt = false;
3489           mark_valid_location_for_stdc_pragma (false);
3490           c_parser_label (parser);
3491         }
3492       else if (!last_label
3493                && c_parser_next_token_starts_declspecs (parser))
3494         {
3495           last_label = false;
3496           mark_valid_location_for_stdc_pragma (false);
3497           c_parser_declaration_or_fndef (parser, true, true, true, true);
3498           if (last_stmt)
3499             pedwarn_c90 (loc,
3500                          (pedantic && !flag_isoc99)
3501                          ? OPT_pedantic
3502                          : OPT_Wdeclaration_after_statement,
3503                          "ISO C90 forbids mixed declarations and code");
3504           last_stmt = false;
3505         }
3506       else if (!last_label
3507                && c_parser_next_token_is_keyword (parser, RID_EXTENSION))
3508         {
3509           /* __extension__ can start a declaration, but is also an
3510              unary operator that can start an expression.  Consume all
3511              but the last of a possible series of __extension__ to
3512              determine which.  */
3513           while (c_parser_peek_2nd_token (parser)->type == CPP_KEYWORD
3514                  && (c_parser_peek_2nd_token (parser)->keyword
3515                      == RID_EXTENSION))
3516             c_parser_consume_token (parser);
3517           if (c_token_starts_declspecs (c_parser_peek_2nd_token (parser)))
3518             {
3519               int ext;
3520               ext = disable_extension_diagnostics ();
3521               c_parser_consume_token (parser);
3522               last_label = false;
3523               mark_valid_location_for_stdc_pragma (false);
3524               c_parser_declaration_or_fndef (parser, true, true, true, true);
3525               /* Following the old parser, __extension__ does not
3526                  disable this diagnostic.  */
3527               restore_extension_diagnostics (ext);
3528               if (last_stmt)
3529                 pedwarn_c90 (loc, (pedantic && !flag_isoc99)
3530                              ? OPT_pedantic
3531                              : OPT_Wdeclaration_after_statement,
3532                              "ISO C90 forbids mixed declarations and code");
3533               last_stmt = false;
3534             }
3535           else
3536             goto statement;
3537         }
3538       else if (c_parser_next_token_is (parser, CPP_PRAGMA))
3539         {
3540           /* External pragmas, and some omp pragmas, are not associated
3541              with regular c code, and so are not to be considered statements
3542              syntactically.  This ensures that the user doesn't put them
3543              places that would turn into syntax errors if the directive
3544              were ignored.  */
3545           if (c_parser_pragma (parser, pragma_compound))
3546             last_label = false, last_stmt = true;
3547         }
3548       else if (c_parser_next_token_is (parser, CPP_EOF))
3549         {
3550           mark_valid_location_for_stdc_pragma (save_valid_for_pragma);
3551           c_parser_error (parser, "expected declaration or statement");
3552           return;
3553         }
3554       else if (c_parser_next_token_is_keyword (parser, RID_ELSE))
3555         {
3556           if (parser->in_if_block)
3557             {
3558               mark_valid_location_for_stdc_pragma (save_valid_for_pragma);
3559               error_at (loc, """expected %<}%> before %<else%>");
3560               return;
3561             }
3562           else
3563             {
3564               error_at (loc, "%<else%> without a previous %<if%>");
3565               c_parser_consume_token (parser);
3566               continue;
3567             }
3568         }
3569       else
3570         {
3571         statement:
3572           last_label = false;
3573           last_stmt = true;
3574           mark_valid_location_for_stdc_pragma (false);
3575           c_parser_statement_after_labels (parser);
3576         }
3577
3578       parser->error = false;
3579     }
3580   if (last_label)
3581     error_at (label_loc, "label at end of compound statement");
3582   c_parser_consume_token (parser);
3583   /* Restore the value we started with.  */
3584   mark_valid_location_for_stdc_pragma (save_valid_for_pragma);
3585 }
3586
3587 /* Parse a label (C90 6.6.1, C99 6.8.1).
3588
3589    label:
3590      identifier : attributes[opt]
3591      case constant-expression :
3592      default :
3593
3594    GNU extensions:
3595
3596    label:
3597      case constant-expression ... constant-expression :
3598
3599    The use of attributes on labels is a GNU extension.  The syntax in
3600    GNU C accepts any expressions without commas, non-constant
3601    expressions being rejected later.  */
3602
3603 static void
3604 c_parser_label (c_parser *parser)
3605 {
3606   location_t loc1 = c_parser_peek_token (parser)->location;
3607   tree label = NULL_TREE;
3608   if (c_parser_next_token_is_keyword (parser, RID_CASE))
3609     {
3610       tree exp1, exp2;
3611       c_parser_consume_token (parser);
3612       exp1 = c_parser_expr_no_commas (parser, NULL).value;
3613       if (c_parser_next_token_is (parser, CPP_COLON))
3614         {
3615           c_parser_consume_token (parser);
3616           label = do_case (loc1, exp1, NULL_TREE);
3617         }
3618       else if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
3619         {
3620           c_parser_consume_token (parser);
3621           exp2 = c_parser_expr_no_commas (parser, NULL).value;
3622           if (c_parser_require (parser, CPP_COLON, "expected %<:%>"))
3623             label = do_case (loc1, exp1, exp2);
3624         }
3625       else
3626         c_parser_error (parser, "expected %<:%> or %<...%>");
3627     }
3628   else if (c_parser_next_token_is_keyword (parser, RID_DEFAULT))
3629     {
3630       c_parser_consume_token (parser);
3631       if (c_parser_require (parser, CPP_COLON, "expected %<:%>"))
3632         label = do_case (loc1, NULL_TREE, NULL_TREE);
3633     }
3634   else
3635     {
3636       tree name = c_parser_peek_token (parser)->value;
3637       tree tlab;
3638       tree attrs;
3639       location_t loc2 = c_parser_peek_token (parser)->location;
3640       gcc_assert (c_parser_next_token_is (parser, CPP_NAME));
3641       c_parser_consume_token (parser);
3642       gcc_assert (c_parser_next_token_is (parser, CPP_COLON));
3643       c_parser_consume_token (parser);
3644       attrs = c_parser_attributes (parser);
3645       tlab = define_label (loc2, name);
3646       if (tlab)
3647         {
3648           decl_attributes (&tlab, attrs, 0);
3649           label = add_stmt (build_stmt (loc1, LABEL_EXPR, tlab));
3650         }
3651     }
3652   if (label)
3653     {
3654       if (c_parser_next_token_starts_declspecs (parser)
3655           && !(c_parser_next_token_is (parser, CPP_NAME)
3656                && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
3657         {
3658           error_at (c_parser_peek_token (parser)->location,
3659                     "a label can only be part of a statement and "
3660                     "a declaration is not a statement");
3661           c_parser_declaration_or_fndef (parser, /*fndef_ok*/ false,
3662                                          /*nested*/ true, /*empty_ok*/ false,
3663                                          /*start_attr_ok*/ true);
3664         }
3665     }
3666 }
3667
3668 /* Parse a statement (C90 6.6, C99 6.8).
3669
3670    statement:
3671      labeled-statement
3672      compound-statement
3673      expression-statement
3674      selection-statement
3675      iteration-statement
3676      jump-statement
3677
3678    labeled-statement:
3679      label statement
3680
3681    expression-statement:
3682      expression[opt] ;
3683
3684    selection-statement:
3685      if-statement
3686      switch-statement
3687
3688    iteration-statement:
3689      while-statement
3690      do-statement
3691      for-statement
3692
3693    jump-statement:
3694      goto identifier ;
3695      continue ;
3696      break ;
3697      return expression[opt] ;
3698
3699    GNU extensions:
3700
3701    statement:
3702      asm-statement
3703
3704    jump-statement:
3705      goto * expression ;
3706
3707    Objective-C:
3708
3709    statement:
3710      objc-throw-statement
3711      objc-try-catch-statement
3712      objc-synchronized-statement
3713
3714    objc-throw-statement:
3715      @throw expression ;
3716      @throw ;
3717
3718    OpenMP:
3719
3720    statement:
3721      openmp-construct
3722
3723    openmp-construct:
3724      parallel-construct
3725      for-construct
3726      sections-construct
3727      single-construct
3728      parallel-for-construct
3729      parallel-sections-construct
3730      master-construct
3731      critical-construct
3732      atomic-construct
3733      ordered-construct
3734
3735    parallel-construct:
3736      parallel-directive structured-block
3737
3738    for-construct:
3739      for-directive iteration-statement
3740
3741    sections-construct:
3742      sections-directive section-scope
3743
3744    single-construct:
3745      single-directive structured-block
3746
3747    parallel-for-construct:
3748      parallel-for-directive iteration-statement
3749
3750    parallel-sections-construct:
3751      parallel-sections-directive section-scope
3752
3753    master-construct:
3754      master-directive structured-block
3755
3756    critical-construct:
3757      critical-directive structured-block
3758
3759    atomic-construct:
3760      atomic-directive expression-statement
3761
3762    ordered-construct:
3763      ordered-directive structured-block  */
3764
3765 static void
3766 c_parser_statement (c_parser *parser)
3767 {
3768   while (c_parser_next_token_is_keyword (parser, RID_CASE)
3769          || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
3770          || (c_parser_next_token_is (parser, CPP_NAME)
3771              && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
3772     c_parser_label (parser);
3773   c_parser_statement_after_labels (parser);
3774 }
3775
3776 /* Parse a statement, other than a labeled statement.  */
3777
3778 static void
3779 c_parser_statement_after_labels (c_parser *parser)
3780 {
3781   location_t loc = c_parser_peek_token (parser)->location;
3782   tree stmt = NULL_TREE;
3783   bool in_if_block = parser->in_if_block;
3784   parser->in_if_block = false;
3785   switch (c_parser_peek_token (parser)->type)
3786     {
3787     case CPP_OPEN_BRACE:
3788       add_stmt (c_parser_compound_statement (parser));
3789       break;
3790     case CPP_KEYWORD:
3791       switch (c_parser_peek_token (parser)->keyword)
3792         {
3793         case RID_IF:
3794           c_parser_if_statement (parser);
3795           break;
3796         case RID_SWITCH:
3797           c_parser_switch_statement (parser);
3798           break;
3799         case RID_WHILE:
3800           c_parser_while_statement (parser);
3801           break;
3802         case RID_DO:
3803           c_parser_do_statement (parser);
3804           break;
3805         case RID_FOR:
3806           c_parser_for_statement (parser);
3807           break;
3808         case RID_GOTO:
3809           c_parser_consume_token (parser);
3810           if (c_parser_next_token_is (parser, CPP_NAME))
3811             {
3812               stmt = c_finish_goto_label (loc,
3813                                           c_parser_peek_token (parser)->value);
3814               c_parser_consume_token (parser);
3815             }
3816           else if (c_parser_next_token_is (parser, CPP_MULT))
3817             {
3818               c_parser_consume_token (parser);
3819               stmt = c_finish_goto_ptr (loc,
3820                                         c_parser_expression (parser).value);
3821             }
3822           else
3823             c_parser_error (parser, "expected identifier or %<*%>");
3824           goto expect_semicolon;
3825         case RID_CONTINUE:
3826           c_parser_consume_token (parser);
3827           stmt = c_finish_bc_stmt (loc, &c_cont_label, false);
3828           goto expect_semicolon;
3829         case RID_BREAK:
3830           c_parser_consume_token (parser);
3831           stmt = c_finish_bc_stmt (loc, &c_break_label, true);
3832           goto expect_semicolon;
3833         case RID_RETURN:
3834           c_parser_consume_token (parser);
3835           if (c_parser_next_token_is (parser, CPP_SEMICOLON))
3836             {
3837               stmt = c_finish_return (loc, NULL_TREE, NULL_TREE);
3838               c_parser_consume_token (parser);
3839             }
3840           else
3841             {
3842               struct c_expr expr = c_parser_expression_conv (parser);
3843               stmt = c_finish_return (loc, expr.value, expr.original_type);
3844               goto expect_semicolon;
3845             }
3846           break;
3847         case RID_ASM:
3848           stmt = c_parser_asm_statement (parser);
3849           break;
3850         case RID_THROW:
3851           gcc_assert (c_dialect_objc ());
3852           c_parser_consume_token (parser);
3853           if (c_parser_next_token_is (parser, CPP_SEMICOLON))
3854             {
3855               stmt = objc_build_throw_stmt (loc, NULL_TREE);
3856               c_parser_consume_token (parser);
3857             }
3858           else
3859             {
3860               tree expr = c_parser_expression (parser).value;
3861               expr = c_fully_fold (expr, false, NULL);
3862               stmt = objc_build_throw_stmt (loc, expr);
3863               goto expect_semicolon;
3864             }
3865           break;
3866         case RID_TRY:
3867           gcc_assert (c_dialect_objc ());
3868           c_parser_objc_try_catch_statement (parser);
3869           break;
3870         case RID_AT_SYNCHRONIZED:
3871           gcc_assert (c_dialect_objc ());
3872           c_parser_objc_synchronized_statement (parser);
3873           break;
3874         default:
3875           goto expr_stmt;
3876         }
3877       break;
3878     case CPP_SEMICOLON:
3879       c_parser_consume_token (parser);
3880       break;
3881     case CPP_CLOSE_PAREN:
3882     case CPP_CLOSE_SQUARE:
3883       /* Avoid infinite loop in error recovery:
3884          c_parser_skip_until_found stops at a closing nesting
3885          delimiter without consuming it, but here we need to consume
3886          it to proceed further.  */
3887       c_parser_error (parser, "expected statement");
3888       c_parser_consume_token (parser);
3889       break;
3890     case CPP_PRAGMA:
3891       c_parser_pragma (parser, pragma_stmt);
3892       break;
3893     default:
3894     expr_stmt:
3895       stmt = c_finish_expr_stmt (loc, c_parser_expression_conv (parser).value);
3896     expect_semicolon:
3897       c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
3898       break;
3899     }
3900   /* Two cases cannot and do not have line numbers associated: If stmt
3901      is degenerate, such as "2;", then stmt is an INTEGER_CST, which
3902      cannot hold line numbers.  But that's OK because the statement
3903      will either be changed to a MODIFY_EXPR during gimplification of
3904      the statement expr, or discarded.  If stmt was compound, but
3905      without new variables, we will have skipped the creation of a
3906      BIND and will have a bare STATEMENT_LIST.  But that's OK because
3907      (recursively) all of the component statements should already have
3908      line numbers assigned.  ??? Can we discard no-op statements
3909      earlier?  */
3910   if (CAN_HAVE_LOCATION_P (stmt)
3911       && EXPR_LOCATION (stmt) == UNKNOWN_LOCATION)
3912     SET_EXPR_LOCATION (stmt, loc);
3913
3914   parser->in_if_block = in_if_block;
3915 }
3916
3917 /* Parse the condition from an if, do, while or for statements.  */
3918
3919 static tree
3920 c_parser_condition (c_parser *parser)
3921 {
3922   location_t loc = c_parser_peek_token (parser)->location;
3923   tree cond;
3924   cond = c_parser_expression_conv (parser).value;
3925   cond = c_objc_common_truthvalue_conversion (loc, cond);
3926   cond = c_fully_fold (cond, false, NULL);
3927   if (warn_sequence_point)
3928     verify_sequence_points (cond);
3929   return cond;
3930 }
3931
3932 /* Parse a parenthesized condition from an if, do or while statement.
3933
3934    condition:
3935      ( expression )
3936 */
3937 static tree
3938 c_parser_paren_condition (c_parser *parser)
3939 {
3940   tree cond;
3941   if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
3942     return error_mark_node;
3943   cond = c_parser_condition (parser);
3944   c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
3945   return cond;
3946 }
3947
3948 /* Parse a statement which is a block in C99.  */
3949
3950 static tree
3951 c_parser_c99_block_statement (c_parser *parser)
3952 {
3953   tree block = c_begin_compound_stmt (flag_isoc99);
3954   location_t loc = c_parser_peek_token (parser)->location;
3955   c_parser_statement (parser);
3956   return c_end_compound_stmt (loc, block, flag_isoc99);
3957 }
3958
3959 /* Parse the body of an if statement.  This is just parsing a
3960    statement but (a) it is a block in C99, (b) we track whether the
3961    body is an if statement for the sake of -Wparentheses warnings, (c)
3962    we handle an empty body specially for the sake of -Wempty-body
3963    warnings, and (d) we call parser_compound_statement directly
3964    because c_parser_statement_after_labels resets
3965    parser->in_if_block.  */
3966
3967 static tree
3968 c_parser_if_body (c_parser *parser, bool *if_p)
3969 {
3970   tree block = c_begin_compound_stmt (flag_isoc99);
3971   location_t body_loc = c_parser_peek_token (parser)->location;
3972   while (c_parser_next_token_is_keyword (parser, RID_CASE)
3973          || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
3974          || (c_parser_next_token_is (parser, CPP_NAME)
3975              && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
3976     c_parser_label (parser);
3977   *if_p = c_parser_next_token_is_keyword (parser, RID_IF);
3978   if (c_parser_next_token_is (parser, CPP_SEMICOLON))
3979     {
3980       location_t loc = c_parser_peek_token (parser)->location;
3981       add_stmt (build_empty_stmt (loc));
3982       c_parser_consume_token (parser);
3983       if (!c_parser_next_token_is_keyword (parser, RID_ELSE))
3984         warning_at (loc, OPT_Wempty_body,
3985                     "suggest braces around empty body in an %<if%> statement");
3986     }
3987   else if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
3988     add_stmt (c_parser_compound_statement (parser));
3989   else
3990     c_parser_statement_after_labels (parser);
3991   return c_end_compound_stmt (body_loc, block, flag_isoc99);
3992 }
3993
3994 /* Parse the else body of an if statement.  This is just parsing a
3995    statement but (a) it is a block in C99, (b) we handle an empty body
3996    specially for the sake of -Wempty-body warnings.  */
3997
3998 static tree
3999 c_parser_else_body (c_parser *parser)
4000 {
4001   location_t else_loc = c_parser_peek_token (parser)->location;
4002   tree block = c_begin_compound_stmt (flag_isoc99);
4003   while (c_parser_next_token_is_keyword (parser, RID_CASE)
4004          || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
4005          || (c_parser_next_token_is (parser, CPP_NAME)
4006              && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
4007     c_parser_label (parser);
4008   if (c_parser_next_token_is (parser, CPP_SEMICOLON))
4009     {
4010       location_t loc = c_parser_peek_token (parser)->location;
4011       warning_at (loc,
4012                   OPT_Wempty_body,
4013                  "suggest braces around empty body in an %<else%> statement");
4014       add_stmt (build_empty_stmt (loc));
4015       c_parser_consume_token (parser);
4016     }
4017   else
4018     c_parser_statement_after_labels (parser);
4019   return c_end_compound_stmt (else_loc, block, flag_isoc99);
4020 }
4021
4022 /* Parse an if statement (C90 6.6.4, C99 6.8.4).
4023
4024    if-statement:
4025      if ( expression ) statement
4026      if ( expression ) statement else statement
4027 */
4028
4029 static void
4030 c_parser_if_statement (c_parser *parser)
4031 {
4032   tree block;
4033   location_t loc;
4034   tree cond;
4035   bool first_if = false;
4036   tree first_body, second_body;
4037   bool in_if_block;
4038
4039   gcc_assert (c_parser_next_token_is_keyword (parser, RID_IF));
4040   c_parser_consume_token (parser);
4041   block = c_begin_compound_stmt (flag_isoc99);
4042   loc = c_parser_peek_token (parser)->location;
4043   cond = c_parser_paren_condition (parser);
4044   in_if_block = parser->in_if_block;
4045   parser->in_if_block = true;
4046   first_body = c_parser_if_body (parser, &first_if);
4047   parser->in_if_block = in_if_block;
4048   if (c_parser_next_token_is_keyword (parser, RID_ELSE))
4049     {
4050       c_parser_consume_token (parser);
4051       second_body = c_parser_else_body (parser);
4052     }
4053   else
4054     second_body = NULL_TREE;
4055   c_finish_if_stmt (loc, cond, first_body, second_body, first_if);
4056   add_stmt (c_end_compound_stmt (loc, block, flag_isoc99));
4057 }
4058
4059 /* Parse a switch statement (C90 6.6.4, C99 6.8.4).
4060
4061    switch-statement:
4062      switch (expression) statement
4063 */
4064
4065 static void
4066 c_parser_switch_statement (c_parser *parser)
4067 {
4068   tree block, expr, body, save_break;
4069   location_t switch_loc = c_parser_peek_token (parser)->location;
4070   location_t switch_cond_loc;
4071   gcc_assert (c_parser_next_token_is_keyword (parser, RID_SWITCH));
4072   c_parser_consume_token (parser);
4073   block = c_begin_compound_stmt (flag_isoc99);
4074   if (c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
4075     {
4076       switch_cond_loc = c_parser_peek_token (parser)->location;
4077       expr = c_parser_expression (parser).value;
4078       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
4079     }
4080   else
4081     {
4082       switch_cond_loc = UNKNOWN_LOCATION;
4083       expr = error_mark_node;
4084     }
4085   c_start_case (switch_loc, switch_cond_loc, expr);
4086   save_break = c_break_label;
4087   c_break_label = NULL_TREE;
4088   body = c_parser_c99_block_statement (parser);
4089   c_finish_case (body);
4090   if (c_break_label)
4091     {
4092       location_t here = c_parser_peek_token (parser)->location;
4093       tree t = build1 (LABEL_EXPR, void_type_node, c_break_label);
4094       SET_EXPR_LOCATION (t, here);
4095       add_stmt (t);