OSDN Git Service

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