OSDN Git Service

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