OSDN Git Service

* c-common.c (c_common_reswords): Add _Static_assert for C.
[pf3gnuchains/gcc-fork.git] / gcc / c-parser.c
1 /* Parser for C and Objective-C.
2    Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3    1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
4    Free Software Foundation, Inc.
5
6    Parser actions based on the old Bison parser; structure somewhat
7    influenced by and fragments based on the C++ parser.
8
9 This file is part of GCC.
10
11 GCC is free software; you can redistribute it and/or modify it under
12 the terms of the GNU General Public License as published by the Free
13 Software Foundation; either version 3, or (at your option) any later
14 version.
15
16 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
17 WARRANTY; without even the implied warranty of MERCHANTABILITY or
18 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
19 for more details.
20
21 You should have received a copy of the GNU General Public License
22 along with GCC; see the file COPYING3.  If not see
23 <http://www.gnu.org/licenses/>.  */
24
25 /* TODO:
26
27    Make sure all relevant comments, and all relevant code from all
28    actions, brought over from old parser.  Verify exact correspondence
29    of syntax accepted.
30
31    Add testcases covering every input symbol in every state in old and
32    new parsers.
33
34    Include full syntax for GNU C, including erroneous cases accepted
35    with error messages, in syntax productions in comments.
36
37    Make more diagnostics in the front end generally take an explicit
38    location rather than implicitly using input_location.  */
39
40 #include "config.h"
41 #include "system.h"
42 #include "coretypes.h"
43 #include "tm.h"                 /* For rtl.h: needs enum reg_class.  */
44 #include "tree.h"
45 #include "rtl.h"                /* For decl_default_tls_model.  */
46 #include "langhooks.h"
47 #include "input.h"
48 #include "cpplib.h"
49 #include "timevar.h"
50 #include "c-pragma.h"
51 #include "c-tree.h"
52 #include "flags.h"
53 #include "output.h"
54 #include "toplev.h"
55 #include "ggc.h"
56 #include "c-common.h"
57 #include "vec.h"
58 #include "target.h"
59 #include "cgraph.h"
60 #include "plugin.h"
61
62 \f
63 /* Initialization routine for this file.  */
64
65 void
66 c_parse_init (void)
67 {
68   /* The only initialization required is of the reserved word
69      identifiers.  */
70   unsigned int i;
71   tree id;
72   int mask = 0;
73
74   /* Make sure RID_MAX hasn't grown past the 8 bits used to hold the keyword in
75      the c_token structure.  */
76   gcc_assert (RID_MAX <= 255);
77
78   mask |= D_CXXONLY;
79   if (!flag_isoc99)
80     mask |= D_C99;
81   if (flag_no_asm)
82     {
83       mask |= D_ASM | D_EXT;
84       if (!flag_isoc99)
85         mask |= D_EXT89;
86     }
87   if (!c_dialect_objc ())
88     mask |= D_OBJC | D_CXX_OBJC;
89
90   ridpointers = GGC_CNEWVEC (tree, (int) RID_MAX);
91   for (i = 0; i < num_c_common_reswords; i++)
92     {
93       /* If a keyword is disabled, do not enter it into the table
94          and so create a canonical spelling that isn't a keyword.  */
95       if (c_common_reswords[i].disable & mask)
96         {
97           if (warn_cxx_compat
98               && (c_common_reswords[i].disable & D_CXXWARN))
99             {
100               id = get_identifier (c_common_reswords[i].word);
101               C_SET_RID_CODE (id, RID_CXX_COMPAT_WARN);
102               C_IS_RESERVED_WORD (id) = 1;
103             }
104           continue;
105         }
106
107       id = get_identifier (c_common_reswords[i].word);
108       C_SET_RID_CODE (id, c_common_reswords[i].rid);
109       C_IS_RESERVED_WORD (id) = 1;
110       ridpointers [(int) c_common_reswords[i].rid] = id;
111     }
112 }
113 \f
114 /* The C lexer intermediates between the lexer in cpplib and c-lex.c
115    and the C parser.  Unlike the C++ lexer, the parser structure
116    stores the lexer information instead of using a separate structure.
117    Identifiers are separated into ordinary identifiers, type names,
118    keywords and some other Objective-C types of identifiers, and some
119    look-ahead is maintained.
120
121    ??? It might be a good idea to lex the whole file up front (as for
122    C++).  It would then be possible to share more of the C and C++
123    lexer code, if desired.  */
124
125 /* The following local token type is used.  */
126
127 /* A keyword.  */
128 #define CPP_KEYWORD ((enum cpp_ttype) (N_TTYPES + 1))
129
130 /* More information about the type of a CPP_NAME token.  */
131 typedef enum c_id_kind {
132   /* An ordinary identifier.  */
133   C_ID_ID,
134   /* An identifier declared as a typedef name.  */
135   C_ID_TYPENAME,
136   /* An identifier declared as an Objective-C class name.  */
137   C_ID_CLASSNAME,
138   /* An address space identifier.  */
139   C_ID_ADDRSPACE,
140   /* Not an identifier.  */
141   C_ID_NONE
142 } c_id_kind;
143
144 /* A single C token after string literal concatenation and conversion
145    of preprocessing tokens to tokens.  */
146 typedef struct GTY (()) c_token {
147   /* The kind of token.  */
148   ENUM_BITFIELD (cpp_ttype) type : 8;
149   /* If this token is a CPP_NAME, this value indicates whether also
150      declared as some kind of type.  Otherwise, it is C_ID_NONE.  */
151   ENUM_BITFIELD (c_id_kind) id_kind : 8;
152   /* If this token is a keyword, this value indicates which keyword.
153      Otherwise, this value is RID_MAX.  */
154   ENUM_BITFIELD (rid) keyword : 8;
155   /* If this token is a CPP_PRAGMA, this indicates the pragma that
156      was seen.  Otherwise it is PRAGMA_NONE.  */
157   ENUM_BITFIELD (pragma_kind) pragma_kind : 8;
158   /* The location at which this token was found.  */
159   location_t location;
160   /* The value associated with this token, if any.  */
161   tree value;
162 } c_token;
163
164 /* A parser structure recording information about the state and
165    context of parsing.  Includes lexer information with up to two
166    tokens of look-ahead; more are not needed for C.  */
167 typedef struct GTY(()) c_parser {
168   /* The look-ahead tokens.  */
169   c_token tokens[2];
170   /* How many look-ahead tokens are available (0, 1 or 2).  */
171   short tokens_avail;
172   /* True if a syntax error is being recovered from; false otherwise.
173      c_parser_error sets this flag.  It should clear this flag when
174      enough tokens have been consumed to recover from the error.  */
175   BOOL_BITFIELD error : 1;
176   /* True if we're processing a pragma, and shouldn't automatically
177      consume CPP_PRAGMA_EOL.  */
178   BOOL_BITFIELD in_pragma : 1;
179   /* True if we're parsing the outermost block of an if statement.  */
180   BOOL_BITFIELD in_if_block : 1;
181   /* True if we want to lex an untranslated string.  */
182   BOOL_BITFIELD lex_untranslated_string : 1;
183   /* Objective-C specific parser/lexer information.  */
184   BOOL_BITFIELD objc_pq_context : 1;
185   /* The following flag is needed to contextualize Objective-C lexical
186      analysis.  In some cases (e.g., 'int NSObject;'), it is
187      undesirable to bind an identifier to an Objective-C class, even
188      if a class with that name exists.  */
189   BOOL_BITFIELD objc_need_raw_identifier : 1;
190 } c_parser;
191
192
193 /* The actual parser and external interface.  ??? Does this need to be
194    garbage-collected?  */
195
196 static GTY (()) c_parser *the_parser;
197
198
199 /* Read in and lex a single token, storing it in *TOKEN.  */
200
201 static void
202 c_lex_one_token (c_parser *parser, c_token *token)
203 {
204   timevar_push (TV_LEX);
205
206   token->type = c_lex_with_flags (&token->value, &token->location, NULL,
207                                   (parser->lex_untranslated_string
208                                    ? C_LEX_STRING_NO_TRANSLATE : 0));
209   token->id_kind = C_ID_NONE;
210   token->keyword = RID_MAX;
211   token->pragma_kind = PRAGMA_NONE;
212
213   switch (token->type)
214     {
215     case CPP_NAME:
216       {
217         tree decl;
218
219         bool objc_force_identifier = parser->objc_need_raw_identifier;
220         if (c_dialect_objc ())
221           parser->objc_need_raw_identifier = false;
222
223         if (C_IS_RESERVED_WORD (token->value))
224           {
225             enum rid rid_code = C_RID_CODE (token->value);
226
227             if (rid_code == RID_CXX_COMPAT_WARN)
228               {
229                 warning_at (token->location,
230                             OPT_Wc___compat,
231                             "identifier %qE conflicts with C++ keyword",
232                             token->value);
233               }
234             else if (rid_code >= RID_FIRST_ADDR_SPACE
235                      && rid_code <= RID_LAST_ADDR_SPACE)
236               {
237                 token->id_kind = C_ID_ADDRSPACE;
238                 token->keyword = rid_code;
239                 break;
240               }
241             else if (c_dialect_objc ())
242               {
243                 if (!objc_is_reserved_word (token->value)
244                     && (!OBJC_IS_PQ_KEYWORD (rid_code)
245                         || parser->objc_pq_context))
246                   {
247                     /* Return the canonical spelling for this keyword.  */
248                     token->value = ridpointers[(int) rid_code];
249                     token->type = CPP_KEYWORD;
250                     token->keyword = rid_code;
251                     break;
252                   }
253               }
254             else
255               {
256                 token->type = CPP_KEYWORD;
257                 token->keyword = rid_code;
258                 break;
259               }
260           }
261
262         decl = lookup_name (token->value);
263         if (decl)
264           {
265             if (TREE_CODE (decl) == TYPE_DECL)
266               {
267                 token->id_kind = C_ID_TYPENAME;
268                 break;
269               }
270           }
271         else if (c_dialect_objc ())
272           {
273             tree objc_interface_decl = objc_is_class_name (token->value);
274             /* Objective-C class names are in the same namespace as
275                variables and typedefs, and hence are shadowed by local
276                declarations.  */
277             if (objc_interface_decl
278                 && (global_bindings_p ()
279                     || (!objc_force_identifier && !decl)))
280               {
281                 token->value = objc_interface_decl;
282                 token->id_kind = C_ID_CLASSNAME;
283                 break;
284               }
285           }
286         token->id_kind = C_ID_ID;
287       }
288       break;
289     case CPP_AT_NAME:
290       /* This only happens in Objective-C; it must be a keyword.  */
291       token->type = CPP_KEYWORD;
292       token->keyword = C_RID_CODE (token->value);
293       break;
294     case CPP_COLON:
295     case CPP_COMMA:
296     case CPP_CLOSE_PAREN:
297     case CPP_SEMICOLON:
298       /* These tokens may affect the interpretation of any identifiers
299          following, if doing Objective-C.  */
300       if (c_dialect_objc ())
301         parser->objc_need_raw_identifier = false;
302       break;
303     case CPP_PRAGMA:
304       /* We smuggled the cpp_token->u.pragma value in an INTEGER_CST.  */
305       token->pragma_kind = (enum pragma_kind) TREE_INT_CST_LOW (token->value);
306       token->value = NULL;
307       break;
308     default:
309       break;
310     }
311   timevar_pop (TV_LEX);
312 }
313
314 /* Return a pointer to the next token from PARSER, reading it in if
315    necessary.  */
316
317 static inline c_token *
318 c_parser_peek_token (c_parser *parser)
319 {
320   if (parser->tokens_avail == 0)
321     {
322       c_lex_one_token (parser, &parser->tokens[0]);
323       parser->tokens_avail = 1;
324     }
325   return &parser->tokens[0];
326 }
327
328 /* Return true if the next token from PARSER has the indicated
329    TYPE.  */
330
331 static inline bool
332 c_parser_next_token_is (c_parser *parser, enum cpp_ttype type)
333 {
334   return c_parser_peek_token (parser)->type == type;
335 }
336
337 /* Return true if the next token from PARSER does not have the
338    indicated TYPE.  */
339
340 static inline bool
341 c_parser_next_token_is_not (c_parser *parser, enum cpp_ttype type)
342 {
343   return !c_parser_next_token_is (parser, type);
344 }
345
346 /* Return true if the next token from PARSER is the indicated
347    KEYWORD.  */
348
349 static inline bool
350 c_parser_next_token_is_keyword (c_parser *parser, enum rid keyword)
351 {
352   return c_parser_peek_token (parser)->keyword == keyword;
353 }
354
355 /* Return true if TOKEN can start a type name,
356    false otherwise.  */
357 static bool
358 c_token_starts_typename (c_token *token)
359 {
360   switch (token->type)
361     {
362     case CPP_NAME:
363       switch (token->id_kind)
364         {
365         case C_ID_ID:
366           return false;
367         case C_ID_ADDRSPACE:
368           return true;
369         case C_ID_TYPENAME:
370           return true;
371         case C_ID_CLASSNAME:
372           gcc_assert (c_dialect_objc ());
373           return true;
374         default:
375           gcc_unreachable ();
376         }
377     case CPP_KEYWORD:
378       switch (token->keyword)
379         {
380         case RID_UNSIGNED:
381         case RID_LONG:
382         case RID_SHORT:
383         case RID_SIGNED:
384         case RID_COMPLEX:
385         case RID_INT:
386         case RID_CHAR:
387         case RID_FLOAT:
388         case RID_DOUBLE:
389         case RID_VOID:
390         case RID_DFLOAT32:
391         case RID_DFLOAT64:
392         case RID_DFLOAT128:
393         case RID_BOOL:
394         case RID_ENUM:
395         case RID_STRUCT:
396         case RID_UNION:
397         case RID_TYPEOF:
398         case RID_CONST:
399         case RID_VOLATILE:
400         case RID_RESTRICT:
401         case RID_ATTRIBUTE:
402         case RID_FRACT:
403         case RID_ACCUM:
404         case RID_SAT:
405           return true;
406         default:
407           return false;
408         }
409     case CPP_LESS:
410       if (c_dialect_objc ())
411         return true;
412       return false;
413     default:
414       return false;
415     }
416 }
417
418 /* Return true if the next token from PARSER can start a type name,
419    false otherwise.  */
420 static inline bool
421 c_parser_next_token_starts_typename (c_parser *parser)
422 {
423   c_token *token = c_parser_peek_token (parser);
424   return c_token_starts_typename (token);
425 }
426
427 /* Return true if TOKEN can start declaration specifiers, false
428    otherwise.  */
429 static bool
430 c_token_starts_declspecs (c_token *token)
431 {
432   switch (token->type)
433     {
434     case CPP_NAME:
435       switch (token->id_kind)
436         {
437         case C_ID_ID:
438           return false;
439         case C_ID_ADDRSPACE:
440           return true;
441         case C_ID_TYPENAME:
442           return true;
443         case C_ID_CLASSNAME:
444           gcc_assert (c_dialect_objc ());
445           return true;
446         default:
447           gcc_unreachable ();
448         }
449     case CPP_KEYWORD:
450       switch (token->keyword)
451         {
452         case RID_STATIC:
453         case RID_EXTERN:
454         case RID_REGISTER:
455         case RID_TYPEDEF:
456         case RID_INLINE:
457         case RID_AUTO:
458         case RID_THREAD:
459         case RID_UNSIGNED:
460         case RID_LONG:
461         case RID_SHORT:
462         case RID_SIGNED:
463         case RID_COMPLEX:
464         case RID_INT:
465         case RID_CHAR:
466         case RID_FLOAT:
467         case RID_DOUBLE:
468         case RID_VOID:
469         case RID_DFLOAT32:
470         case RID_DFLOAT64:
471         case RID_DFLOAT128:
472         case RID_BOOL:
473         case RID_ENUM:
474         case RID_STRUCT:
475         case RID_UNION:
476         case RID_TYPEOF:
477         case RID_CONST:
478         case RID_VOLATILE:
479         case RID_RESTRICT:
480         case RID_ATTRIBUTE:
481         case RID_FRACT:
482         case RID_ACCUM:
483         case RID_SAT:
484           return true;
485         default:
486           return false;
487         }
488     case CPP_LESS:
489       if (c_dialect_objc ())
490         return true;
491       return false;
492     default:
493       return false;
494     }
495 }
496
497
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      _Decimal32
1579      _Decimal64
1580      _Decimal128
1581      _Fract
1582      _Accum
1583      _Sat
1584
1585   (_Fract, _Accum, and _Sat are new from ISO/IEC DTR 18037:
1586    http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1169.pdf)
1587
1588    Objective-C:
1589
1590    type-specifier:
1591      class-name objc-protocol-refs[opt]
1592      typedef-name objc-protocol-refs
1593      objc-protocol-refs
1594 */
1595
1596 static void
1597 c_parser_declspecs (c_parser *parser, struct c_declspecs *specs,
1598                     bool scspec_ok, bool typespec_ok, bool start_attr_ok)
1599 {
1600   bool attrs_ok = start_attr_ok;
1601   bool seen_type = specs->type_seen_p;
1602   while (c_parser_next_token_is (parser, CPP_NAME)
1603          || c_parser_next_token_is (parser, CPP_KEYWORD)
1604          || (c_dialect_objc () && c_parser_next_token_is (parser, CPP_LESS)))
1605     {
1606       struct c_typespec t;
1607       tree attrs;
1608       location_t loc = c_parser_peek_token (parser)->location;
1609       if (c_parser_next_token_is (parser, CPP_NAME))
1610         {
1611           tree value = c_parser_peek_token (parser)->value;
1612           c_id_kind kind = c_parser_peek_token (parser)->id_kind;
1613
1614           if (kind == C_ID_ADDRSPACE)
1615             {
1616               addr_space_t as
1617                 = c_parser_peek_token (parser)->keyword - RID_FIRST_ADDR_SPACE;
1618               declspecs_add_addrspace (specs, as);
1619               c_parser_consume_token (parser);
1620               attrs_ok = true;
1621               continue;
1622             }
1623
1624           /* This finishes the specifiers unless a type name is OK, it
1625              is declared as a type name and a type name hasn't yet
1626              been seen.  */
1627           if (!typespec_ok || seen_type
1628               || (kind != C_ID_TYPENAME && kind != C_ID_CLASSNAME))
1629             break;
1630           c_parser_consume_token (parser);
1631           seen_type = true;
1632           attrs_ok = true;
1633           if (kind == C_ID_TYPENAME
1634               && (!c_dialect_objc ()
1635                   || c_parser_next_token_is_not (parser, CPP_LESS)))
1636             {
1637               t.kind = ctsk_typedef;
1638               /* For a typedef name, record the meaning, not the name.
1639                  In case of 'foo foo, bar;'.  */
1640               t.spec = lookup_name (value);
1641               t.expr = NULL_TREE;
1642               t.expr_const_operands = true;
1643             }
1644           else
1645             {
1646               tree proto = NULL_TREE;
1647               gcc_assert (c_dialect_objc ());
1648               t.kind = ctsk_objc;
1649               if (c_parser_next_token_is (parser, CPP_LESS))
1650                 proto = c_parser_objc_protocol_refs (parser);
1651               t.spec = objc_get_protocol_qualified_type (value, proto);
1652               t.expr = NULL_TREE;
1653               t.expr_const_operands = true;
1654             }
1655           declspecs_add_type (loc, specs, t);
1656           continue;
1657         }
1658       if (c_parser_next_token_is (parser, CPP_LESS))
1659         {
1660           /* Make "<SomeProtocol>" equivalent to "id <SomeProtocol>" -
1661              nisse@lysator.liu.se.  */
1662           tree proto;
1663           gcc_assert (c_dialect_objc ());
1664           if (!typespec_ok || seen_type)
1665             break;
1666           proto = c_parser_objc_protocol_refs (parser);
1667           t.kind = ctsk_objc;
1668           t.spec = objc_get_protocol_qualified_type (NULL_TREE, proto);
1669           t.expr = NULL_TREE;
1670           t.expr_const_operands = true;
1671           declspecs_add_type (loc, specs, t);
1672           continue;
1673         }
1674       gcc_assert (c_parser_next_token_is (parser, CPP_KEYWORD));
1675       switch (c_parser_peek_token (parser)->keyword)
1676         {
1677         case RID_STATIC:
1678         case RID_EXTERN:
1679         case RID_REGISTER:
1680         case RID_TYPEDEF:
1681         case RID_INLINE:
1682         case RID_AUTO:
1683         case RID_THREAD:
1684           if (!scspec_ok)
1685             goto out;
1686           attrs_ok = true;
1687           /* TODO: Distinguish between function specifiers (inline)
1688              and storage class specifiers, either here or in
1689              declspecs_add_scspec.  */
1690           declspecs_add_scspec (specs, c_parser_peek_token (parser)->value);
1691           c_parser_consume_token (parser);
1692           break;
1693         case RID_UNSIGNED:
1694         case RID_LONG:
1695         case RID_SHORT:
1696         case RID_SIGNED:
1697         case RID_COMPLEX:
1698         case RID_INT:
1699         case RID_CHAR:
1700         case RID_FLOAT:
1701         case RID_DOUBLE:
1702         case RID_VOID:
1703         case RID_DFLOAT32:
1704         case RID_DFLOAT64:
1705         case RID_DFLOAT128:
1706         case RID_BOOL:
1707         case RID_FRACT:
1708         case RID_ACCUM:
1709         case RID_SAT:
1710           if (!typespec_ok)
1711             goto out;
1712           attrs_ok = true;
1713           seen_type = true;
1714           if (c_dialect_objc ())
1715             parser->objc_need_raw_identifier = true;
1716           t.kind = ctsk_resword;
1717           t.spec = c_parser_peek_token (parser)->value;
1718           t.expr = NULL_TREE;
1719           t.expr_const_operands = true;
1720           declspecs_add_type (loc, specs, t);
1721           c_parser_consume_token (parser);
1722           break;
1723         case RID_ENUM:
1724           if (!typespec_ok)
1725             goto out;
1726           attrs_ok = true;
1727           seen_type = true;
1728           t = c_parser_enum_specifier (parser);
1729           declspecs_add_type (loc, specs, t);
1730           break;
1731         case RID_STRUCT:
1732         case RID_UNION:
1733           if (!typespec_ok)
1734             goto out;
1735           attrs_ok = true;
1736           seen_type = true;
1737           t = c_parser_struct_or_union_specifier (parser);
1738           invoke_plugin_callbacks (PLUGIN_FINISH_TYPE, t.spec);
1739           declspecs_add_type (loc, specs, t);
1740           break;
1741         case RID_TYPEOF:
1742           /* ??? The old parser rejected typeof after other type
1743              specifiers, but is a syntax error the best way of
1744              handling this?  */
1745           if (!typespec_ok || seen_type)
1746             goto out;
1747           attrs_ok = true;
1748           seen_type = true;
1749           t = c_parser_typeof_specifier (parser);
1750           declspecs_add_type (loc, specs, t);
1751           break;
1752         case RID_CONST:
1753         case RID_VOLATILE:
1754         case RID_RESTRICT:
1755           attrs_ok = true;
1756           declspecs_add_qual (specs, c_parser_peek_token (parser)->value);
1757           c_parser_consume_token (parser);
1758           break;
1759         case RID_ATTRIBUTE:
1760           if (!attrs_ok)
1761             goto out;
1762           attrs = c_parser_attributes (parser);
1763           declspecs_add_attrs (specs, attrs);
1764           break;
1765         default:
1766           goto out;
1767         }
1768     }
1769  out: ;
1770 }
1771
1772 /* Parse an enum specifier (C90 6.5.2.2, C99 6.7.2.2).
1773
1774    enum-specifier:
1775      enum attributes[opt] identifier[opt] { enumerator-list } attributes[opt]
1776      enum attributes[opt] identifier[opt] { enumerator-list , } attributes[opt]
1777      enum attributes[opt] identifier
1778
1779    The form with trailing comma is new in C99.  The forms with
1780    attributes are GNU extensions.  In GNU C, we accept any expression
1781    without commas in the syntax (assignment expressions, not just
1782    conditional expressions); assignment expressions will be diagnosed
1783    as non-constant.
1784
1785    enumerator-list:
1786      enumerator
1787      enumerator-list , enumerator
1788
1789    enumerator:
1790      enumeration-constant
1791      enumeration-constant = constant-expression
1792 */
1793
1794 static struct c_typespec
1795 c_parser_enum_specifier (c_parser *parser)
1796 {
1797   struct c_typespec ret;
1798   tree attrs;
1799   tree ident = NULL_TREE;
1800   location_t enum_loc;
1801   location_t ident_loc = UNKNOWN_LOCATION;  /* Quiet warning.  */
1802   gcc_assert (c_parser_next_token_is_keyword (parser, RID_ENUM));
1803   enum_loc = c_parser_peek_token (parser)->location;
1804   c_parser_consume_token (parser);
1805   attrs = c_parser_attributes (parser);
1806   enum_loc = c_parser_peek_token (parser)->location;
1807   /* Set the location in case we create a decl now.  */
1808   c_parser_set_source_position_from_token (c_parser_peek_token (parser));
1809   if (c_parser_next_token_is (parser, CPP_NAME))
1810     {
1811       ident = c_parser_peek_token (parser)->value;
1812       ident_loc = c_parser_peek_token (parser)->location;
1813       enum_loc = ident_loc;
1814       c_parser_consume_token (parser);
1815     }
1816   if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
1817     {
1818       /* Parse an enum definition.  */
1819       struct c_enum_contents the_enum;
1820       tree type = start_enum (enum_loc, &the_enum, ident);
1821       tree postfix_attrs;
1822       /* We chain the enumerators in reverse order, then put them in
1823          forward order at the end.  */
1824       tree values = NULL_TREE;
1825       c_parser_consume_token (parser);
1826       while (true)
1827         {
1828           tree enum_id;
1829           tree enum_value;
1830           tree enum_decl;
1831           bool seen_comma;
1832           c_token *token;
1833           location_t comma_loc = UNKNOWN_LOCATION;  /* Quiet warning.  */
1834           location_t value_loc;
1835           if (c_parser_next_token_is_not (parser, CPP_NAME))
1836             {
1837               c_parser_error (parser, "expected identifier");
1838               c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL);
1839               values = error_mark_node;
1840               break;
1841             }
1842           token = c_parser_peek_token (parser);
1843           enum_id = token->value;
1844           /* Set the location in case we create a decl now.  */
1845           c_parser_set_source_position_from_token (token);
1846           value_loc = token->location;
1847           c_parser_consume_token (parser);
1848           if (c_parser_next_token_is (parser, CPP_EQ))
1849             {
1850               c_parser_consume_token (parser);
1851               value_loc = c_parser_peek_token (parser)->location;
1852               enum_value = c_parser_expr_no_commas (parser, NULL).value;
1853             }
1854           else
1855             enum_value = NULL_TREE;
1856           enum_decl = build_enumerator (value_loc,
1857                                         &the_enum, enum_id, enum_value);
1858           TREE_CHAIN (enum_decl) = values;
1859           values = enum_decl;
1860           seen_comma = false;
1861           if (c_parser_next_token_is (parser, CPP_COMMA))
1862             {
1863               comma_loc = c_parser_peek_token (parser)->location;
1864               seen_comma = true;
1865               c_parser_consume_token (parser);
1866             }
1867           if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
1868             {
1869               if (seen_comma && !flag_isoc99)
1870                 pedwarn (comma_loc, OPT_pedantic, "comma at end of enumerator list");
1871               c_parser_consume_token (parser);
1872               break;
1873             }
1874           if (!seen_comma)
1875             {
1876               c_parser_error (parser, "expected %<,%> or %<}%>");
1877               c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL);
1878               values = error_mark_node;
1879               break;
1880             }
1881         }
1882       postfix_attrs = c_parser_attributes (parser);
1883       ret.spec = finish_enum (type, nreverse (values),
1884                               chainon (attrs, postfix_attrs));
1885       ret.kind = ctsk_tagdef;
1886       ret.expr = NULL_TREE;
1887       ret.expr_const_operands = true;
1888       return ret;
1889     }
1890   else if (!ident)
1891     {
1892       c_parser_error (parser, "expected %<{%>");
1893       ret.spec = error_mark_node;
1894       ret.kind = ctsk_tagref;
1895       ret.expr = NULL_TREE;
1896       ret.expr_const_operands = true;
1897       return ret;
1898     }
1899   ret = parser_xref_tag (ident_loc, ENUMERAL_TYPE, ident);
1900   /* In ISO C, enumerated types can be referred to only if already
1901      defined.  */
1902   if (pedantic && !COMPLETE_TYPE_P (ret.spec))
1903     {
1904       gcc_assert (ident);
1905       pedwarn (enum_loc, OPT_pedantic,
1906                "ISO C forbids forward references to %<enum%> types");
1907     }
1908   return ret;
1909 }
1910
1911 /* Parse a struct or union specifier (C90 6.5.2.1, C99 6.7.2.1).
1912
1913    struct-or-union-specifier:
1914      struct-or-union attributes[opt] identifier[opt]
1915        { struct-contents } attributes[opt]
1916      struct-or-union attributes[opt] identifier
1917
1918    struct-contents:
1919      struct-declaration-list
1920
1921    struct-declaration-list:
1922      struct-declaration ;
1923      struct-declaration-list struct-declaration ;
1924
1925    GNU extensions:
1926
1927    struct-contents:
1928      empty
1929      struct-declaration
1930      struct-declaration-list struct-declaration
1931
1932    struct-declaration-list:
1933      struct-declaration-list ;
1934      ;
1935
1936    (Note that in the syntax here, unlike that in ISO C, the semicolons
1937    are included here rather than in struct-declaration, in order to
1938    describe the syntax with extra semicolons and missing semicolon at
1939    end.)
1940
1941    Objective-C:
1942
1943    struct-declaration-list:
1944      @defs ( class-name )
1945
1946    (Note this does not include a trailing semicolon, but can be
1947    followed by further declarations, and gets a pedwarn-if-pedantic
1948    when followed by a semicolon.)  */
1949
1950 static struct c_typespec
1951 c_parser_struct_or_union_specifier (c_parser *parser)
1952 {
1953   struct c_typespec ret;
1954   tree attrs;
1955   tree ident = NULL_TREE;
1956   location_t struct_loc;
1957   location_t ident_loc = UNKNOWN_LOCATION;
1958   enum tree_code code;
1959   switch (c_parser_peek_token (parser)->keyword)
1960     {
1961     case RID_STRUCT:
1962       code = RECORD_TYPE;
1963       break;
1964     case RID_UNION:
1965       code = UNION_TYPE;
1966       break;
1967     default:
1968       gcc_unreachable ();
1969     }
1970   struct_loc = c_parser_peek_token (parser)->location;
1971   c_parser_consume_token (parser);
1972   attrs = c_parser_attributes (parser);
1973
1974   /* Set the location in case we create a decl now.  */
1975   c_parser_set_source_position_from_token (c_parser_peek_token (parser));
1976
1977   if (c_parser_next_token_is (parser, CPP_NAME))
1978     {
1979       ident = c_parser_peek_token (parser)->value;
1980       ident_loc = c_parser_peek_token (parser)->location;
1981       struct_loc = ident_loc;
1982       c_parser_consume_token (parser);
1983     }
1984   if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
1985     {
1986       /* Parse a struct or union definition.  Start the scope of the
1987          tag before parsing components.  */
1988       struct c_struct_parse_info *struct_info;
1989       tree type = start_struct (struct_loc, code, ident, &struct_info);
1990       tree postfix_attrs;
1991       /* We chain the components in reverse order, then put them in
1992          forward order at the end.  Each struct-declaration may
1993          declare multiple components (comma-separated), so we must use
1994          chainon to join them, although when parsing each
1995          struct-declaration we can use TREE_CHAIN directly.
1996
1997          The theory behind all this is that there will be more
1998          semicolon separated fields than comma separated fields, and
1999          so we'll be minimizing the number of node traversals required
2000          by chainon.  */
2001       tree contents = NULL_TREE;
2002       c_parser_consume_token (parser);
2003       /* Handle the Objective-C @defs construct,
2004          e.g. foo(sizeof(struct{ @defs(ClassName) }));.  */
2005       if (c_parser_next_token_is_keyword (parser, RID_AT_DEFS))
2006         {
2007           tree name;
2008           gcc_assert (c_dialect_objc ());
2009           c_parser_consume_token (parser);
2010           if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
2011             goto end_at_defs;
2012           if (c_parser_next_token_is (parser, CPP_NAME)
2013               && c_parser_peek_token (parser)->id_kind == C_ID_CLASSNAME)
2014             {
2015               name = c_parser_peek_token (parser)->value;
2016               c_parser_consume_token (parser);
2017             }
2018           else
2019             {
2020               c_parser_error (parser, "expected class name");
2021               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
2022               goto end_at_defs;
2023             }
2024           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2025                                      "expected %<)%>");
2026           contents = nreverse (objc_get_class_ivars (name));
2027         }
2028     end_at_defs:
2029       /* Parse the struct-declarations and semicolons.  Problems with
2030          semicolons are diagnosed here; empty structures are diagnosed
2031          elsewhere.  */
2032       while (true)
2033         {
2034           tree decls;
2035           /* Parse any stray semicolon.  */
2036           if (c_parser_next_token_is (parser, CPP_SEMICOLON))
2037             {
2038               pedwarn (c_parser_peek_token (parser)->location, OPT_pedantic,
2039                        "extra semicolon in struct or union specified");
2040               c_parser_consume_token (parser);
2041               continue;
2042             }
2043           /* Stop if at the end of the struct or union contents.  */
2044           if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
2045             {
2046               c_parser_consume_token (parser);
2047               break;
2048             }
2049           /* Accept #pragmas at struct scope.  */
2050           if (c_parser_next_token_is (parser, CPP_PRAGMA))
2051             {
2052               c_parser_pragma (parser, pragma_external);
2053               continue;
2054             }
2055           /* Parse some comma-separated declarations, but not the
2056              trailing semicolon if any.  */
2057           decls = c_parser_struct_declaration (parser);
2058           contents = chainon (decls, contents);
2059           /* If no semicolon follows, either we have a parse error or
2060              are at the end of the struct or union and should
2061              pedwarn.  */
2062           if (c_parser_next_token_is (parser, CPP_SEMICOLON))
2063             c_parser_consume_token (parser);
2064           else
2065             {
2066               if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
2067                 pedwarn (c_parser_peek_token (parser)->location, 0,
2068                          "no semicolon at end of struct or union");
2069               else
2070                 {
2071                   c_parser_error (parser, "expected %<;%>");
2072                   c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL);
2073                   break;
2074                 }
2075             }
2076         }
2077       postfix_attrs = c_parser_attributes (parser);
2078       ret.spec = finish_struct (struct_loc, type, nreverse (contents),
2079                                 chainon (attrs, postfix_attrs), struct_info);
2080       ret.kind = ctsk_tagdef;
2081       ret.expr = NULL_TREE;
2082       ret.expr_const_operands = true;
2083       return ret;
2084     }
2085   else if (!ident)
2086     {
2087       c_parser_error (parser, "expected %<{%>");
2088       ret.spec = error_mark_node;
2089       ret.kind = ctsk_tagref;
2090       ret.expr = NULL_TREE;
2091       ret.expr_const_operands = true;
2092       return ret;
2093     }
2094   ret = parser_xref_tag (ident_loc, code, ident);
2095   return ret;
2096 }
2097
2098 /* Parse a struct-declaration (C90 6.5.2.1, C99 6.7.2.1), *without*
2099    the trailing semicolon.
2100
2101    struct-declaration:
2102      specifier-qualifier-list struct-declarator-list
2103      static_assert-declaration-no-semi
2104
2105    specifier-qualifier-list:
2106      type-specifier specifier-qualifier-list[opt]
2107      type-qualifier specifier-qualifier-list[opt]
2108      attributes specifier-qualifier-list[opt]
2109
2110    struct-declarator-list:
2111      struct-declarator
2112      struct-declarator-list , attributes[opt] struct-declarator
2113
2114    struct-declarator:
2115      declarator attributes[opt]
2116      declarator[opt] : constant-expression attributes[opt]
2117
2118    GNU extensions:
2119
2120    struct-declaration:
2121      __extension__ struct-declaration
2122      specifier-qualifier-list
2123
2124    Unlike the ISO C syntax, semicolons are handled elsewhere.  The use
2125    of attributes where shown is a GNU extension.  In GNU C, we accept
2126    any expression without commas in the syntax (assignment
2127    expressions, not just conditional expressions); assignment
2128    expressions will be diagnosed as non-constant.  */
2129
2130 static tree
2131 c_parser_struct_declaration (c_parser *parser)
2132 {
2133   struct c_declspecs *specs;
2134   tree prefix_attrs;
2135   tree all_prefix_attrs;
2136   tree decls;
2137   location_t decl_loc;
2138   if (c_parser_next_token_is_keyword (parser, RID_EXTENSION))
2139     {
2140       int ext;
2141       tree decl;
2142       ext = disable_extension_diagnostics ();
2143       c_parser_consume_token (parser);
2144       decl = c_parser_struct_declaration (parser);
2145       restore_extension_diagnostics (ext);
2146       return decl;
2147     }
2148   if (c_parser_next_token_is_keyword (parser, RID_STATIC_ASSERT))
2149     {
2150       c_parser_static_assert_declaration_no_semi (parser);
2151       return NULL_TREE;
2152     }
2153   specs = build_null_declspecs ();
2154   decl_loc = c_parser_peek_token (parser)->location;
2155   c_parser_declspecs (parser, specs, false, true, true);
2156   if (parser->error)
2157     return NULL_TREE;
2158   if (!specs->declspecs_seen_p)
2159     {
2160       c_parser_error (parser, "expected specifier-qualifier-list");
2161       return NULL_TREE;
2162     }
2163   finish_declspecs (specs);
2164   if (c_parser_next_token_is (parser, CPP_SEMICOLON))
2165     {
2166       tree ret;
2167       if (!specs->type_seen_p)
2168         {
2169           pedwarn (decl_loc, OPT_pedantic,
2170                    "ISO C forbids member declarations with no members");
2171           shadow_tag_warned (specs, pedantic);
2172           ret = NULL_TREE;
2173         }
2174       else
2175         {
2176           /* Support for unnamed structs or unions as members of
2177              structs or unions (which is [a] useful and [b] supports
2178              MS P-SDK).  */
2179           tree attrs = NULL;
2180
2181           ret = grokfield (c_parser_peek_token (parser)->location,
2182                            build_id_declarator (NULL_TREE), specs,
2183                            NULL_TREE, &attrs);
2184           if (ret)
2185             decl_attributes (&ret, attrs, 0);
2186         }
2187       return ret;
2188     }
2189   pending_xref_error ();
2190   prefix_attrs = specs->attrs;
2191   all_prefix_attrs = prefix_attrs;
2192   specs->attrs = NULL_TREE;
2193   decls = NULL_TREE;
2194   while (true)
2195     {
2196       /* Declaring one or more declarators or un-named bit-fields.  */
2197       struct c_declarator *declarator;
2198       bool dummy = false;
2199       if (c_parser_next_token_is (parser, CPP_COLON))
2200         declarator = build_id_declarator (NULL_TREE);
2201       else
2202         declarator = c_parser_declarator (parser, specs->type_seen_p,
2203                                           C_DTR_NORMAL, &dummy);
2204       if (declarator == NULL)
2205         {
2206           c_parser_skip_to_end_of_block_or_statement (parser);
2207           break;
2208         }
2209       if (c_parser_next_token_is (parser, CPP_COLON)
2210           || c_parser_next_token_is (parser, CPP_COMMA)
2211           || c_parser_next_token_is (parser, CPP_SEMICOLON)
2212           || c_parser_next_token_is (parser, CPP_CLOSE_BRACE)
2213           || c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
2214         {
2215           tree postfix_attrs = NULL_TREE;
2216           tree width = NULL_TREE;
2217           tree d;
2218           if (c_parser_next_token_is (parser, CPP_COLON))
2219             {
2220               c_parser_consume_token (parser);
2221               width = c_parser_expr_no_commas (parser, NULL).value;
2222             }
2223           if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
2224             postfix_attrs = c_parser_attributes (parser);
2225           d = grokfield (c_parser_peek_token (parser)->location,
2226                          declarator, specs, width, &all_prefix_attrs);
2227           decl_attributes (&d, chainon (postfix_attrs,
2228                                         all_prefix_attrs), 0);
2229           TREE_CHAIN (d) = decls;
2230           decls = d;
2231           if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
2232             all_prefix_attrs = chainon (c_parser_attributes (parser),
2233                                         prefix_attrs);
2234           else
2235             all_prefix_attrs = prefix_attrs;
2236           if (c_parser_next_token_is (parser, CPP_COMMA))
2237             c_parser_consume_token (parser);
2238           else if (c_parser_next_token_is (parser, CPP_SEMICOLON)
2239                    || c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
2240             {
2241               /* Semicolon consumed in caller.  */
2242               break;
2243             }
2244           else
2245             {
2246               c_parser_error (parser, "expected %<,%>, %<;%> or %<}%>");
2247               break;
2248             }
2249         }
2250       else
2251         {
2252           c_parser_error (parser,
2253                           "expected %<:%>, %<,%>, %<;%>, %<}%> or "
2254                           "%<__attribute__%>");
2255           break;
2256         }
2257     }
2258   return decls;
2259 }
2260
2261 /* Parse a typeof specifier (a GNU extension).
2262
2263    typeof-specifier:
2264      typeof ( expression )
2265      typeof ( type-name )
2266 */
2267
2268 static struct c_typespec
2269 c_parser_typeof_specifier (c_parser *parser)
2270 {
2271   struct c_typespec ret;
2272   ret.kind = ctsk_typeof;
2273   ret.spec = error_mark_node;
2274   ret.expr = NULL_TREE;
2275   ret.expr_const_operands = true;
2276   gcc_assert (c_parser_next_token_is_keyword (parser, RID_TYPEOF));
2277   c_parser_consume_token (parser);
2278   c_inhibit_evaluation_warnings++;
2279   in_typeof++;
2280   if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
2281     {
2282       c_inhibit_evaluation_warnings--;
2283       in_typeof--;
2284       return ret;
2285     }
2286   if (c_parser_next_token_starts_typename (parser))
2287     {
2288       struct c_type_name *type = c_parser_type_name (parser);
2289       c_inhibit_evaluation_warnings--;
2290       in_typeof--;
2291       if (type != NULL)
2292         {
2293           ret.spec = groktypename (type, &ret.expr, &ret.expr_const_operands);
2294           pop_maybe_used (variably_modified_type_p (ret.spec, NULL_TREE));
2295         }
2296     }
2297   else
2298     {
2299       bool was_vm;
2300       location_t here = c_parser_peek_token (parser)->location;
2301       struct c_expr expr = c_parser_expression (parser);
2302       c_inhibit_evaluation_warnings--;
2303       in_typeof--;
2304       if (TREE_CODE (expr.value) == COMPONENT_REF
2305           && DECL_C_BIT_FIELD (TREE_OPERAND (expr.value, 1)))
2306         error_at (here, "%<typeof%> applied to a bit-field");
2307       mark_exp_read (expr.value);
2308       ret.spec = TREE_TYPE (expr.value);
2309       was_vm = variably_modified_type_p (ret.spec, NULL_TREE);
2310       /* This is returned with the type so that when the type is
2311          evaluated, this can be evaluated.  */
2312       if (was_vm)
2313         ret.expr = c_fully_fold (expr.value, false, &ret.expr_const_operands);
2314       pop_maybe_used (was_vm);
2315     }
2316   c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, "expected %<)%>");
2317   return ret;
2318 }
2319
2320 /* Parse a declarator, possibly an abstract declarator (C90 6.5.4,
2321    6.5.5, C99 6.7.5, 6.7.6).  If TYPE_SEEN_P then a typedef name may
2322    be redeclared; otherwise it may not.  KIND indicates which kind of
2323    declarator is wanted.  Returns a valid declarator except in the
2324    case of a syntax error in which case NULL is returned.  *SEEN_ID is
2325    set to true if an identifier being declared is seen; this is used
2326    to diagnose bad forms of abstract array declarators and to
2327    determine whether an identifier list is syntactically permitted.
2328
2329    declarator:
2330      pointer[opt] direct-declarator
2331
2332    direct-declarator:
2333      identifier
2334      ( attributes[opt] declarator )
2335      direct-declarator array-declarator
2336      direct-declarator ( parameter-type-list )
2337      direct-declarator ( identifier-list[opt] )
2338
2339    pointer:
2340      * type-qualifier-list[opt]
2341      * type-qualifier-list[opt] pointer
2342
2343    type-qualifier-list:
2344      type-qualifier
2345      attributes
2346      type-qualifier-list type-qualifier
2347      type-qualifier-list attributes
2348
2349    parameter-type-list:
2350      parameter-list
2351      parameter-list , ...
2352
2353    parameter-list:
2354      parameter-declaration
2355      parameter-list , parameter-declaration
2356
2357    parameter-declaration:
2358      declaration-specifiers declarator attributes[opt]
2359      declaration-specifiers abstract-declarator[opt] attributes[opt]
2360
2361    identifier-list:
2362      identifier
2363      identifier-list , identifier
2364
2365    abstract-declarator:
2366      pointer
2367      pointer[opt] direct-abstract-declarator
2368
2369    direct-abstract-declarator:
2370      ( attributes[opt] abstract-declarator )
2371      direct-abstract-declarator[opt] array-declarator
2372      direct-abstract-declarator[opt] ( parameter-type-list[opt] )
2373
2374    GNU extensions:
2375
2376    direct-declarator:
2377      direct-declarator ( parameter-forward-declarations
2378                          parameter-type-list[opt] )
2379
2380    direct-abstract-declarator:
2381      direct-abstract-declarator[opt] ( parameter-forward-declarations
2382                                        parameter-type-list[opt] )
2383
2384    parameter-forward-declarations:
2385      parameter-list ;
2386      parameter-forward-declarations parameter-list ;
2387
2388    The uses of attributes shown above are GNU extensions.
2389
2390    Some forms of array declarator are not included in C99 in the
2391    syntax for abstract declarators; these are disallowed elsewhere.
2392    This may be a defect (DR#289).
2393
2394    This function also accepts an omitted abstract declarator as being
2395    an abstract declarator, although not part of the formal syntax.  */
2396
2397 static struct c_declarator *
2398 c_parser_declarator (c_parser *parser, bool type_seen_p, c_dtr_syn kind,
2399                      bool *seen_id)
2400 {
2401   /* Parse any initial pointer part.  */
2402   if (c_parser_next_token_is (parser, CPP_MULT))
2403     {
2404       struct c_declspecs *quals_attrs = build_null_declspecs ();
2405       struct c_declarator *inner;
2406       c_parser_consume_token (parser);
2407       c_parser_declspecs (parser, quals_attrs, false, false, true);
2408       inner = c_parser_declarator (parser, type_seen_p, kind, seen_id);
2409       if (inner == NULL)
2410         return NULL;
2411       else
2412         return make_pointer_declarator (quals_attrs, inner);
2413     }
2414   /* Now we have a direct declarator, direct abstract declarator or
2415      nothing (which counts as a direct abstract declarator here).  */
2416   return c_parser_direct_declarator (parser, type_seen_p, kind, seen_id);
2417 }
2418
2419 /* Parse a direct declarator or direct abstract declarator; arguments
2420    as c_parser_declarator.  */
2421
2422 static struct c_declarator *
2423 c_parser_direct_declarator (c_parser *parser, bool type_seen_p, c_dtr_syn kind,
2424                             bool *seen_id)
2425 {
2426   /* The direct declarator must start with an identifier (possibly
2427      omitted) or a parenthesized declarator (possibly abstract).  In
2428      an ordinary declarator, initial parentheses must start a
2429      parenthesized declarator.  In an abstract declarator or parameter
2430      declarator, they could start a parenthesized declarator or a
2431      parameter list.  To tell which, the open parenthesis and any
2432      following attributes must be read.  If a declaration specifier
2433      follows, then it is a parameter list; if the specifier is a
2434      typedef name, there might be an ambiguity about redeclaring it,
2435      which is resolved in the direction of treating it as a typedef
2436      name.  If a close parenthesis follows, it is also an empty
2437      parameter list, as the syntax does not permit empty abstract
2438      declarators.  Otherwise, it is a parenthesized declarator (in
2439      which case the analysis may be repeated inside it, recursively).
2440
2441      ??? There is an ambiguity in a parameter declaration "int
2442      (__attribute__((foo)) x)", where x is not a typedef name: it
2443      could be an abstract declarator for a function, or declare x with
2444      parentheses.  The proper resolution of this ambiguity needs
2445      documenting.  At present we follow an accident of the old
2446      parser's implementation, whereby the first parameter must have
2447      some declaration specifiers other than just attributes.  Thus as
2448      a parameter declaration it is treated as a parenthesized
2449      parameter named x, and as an abstract declarator it is
2450      rejected.
2451
2452      ??? Also following the old parser, attributes inside an empty
2453      parameter list are ignored, making it a list not yielding a
2454      prototype, rather than giving an error or making it have one
2455      parameter with implicit type int.
2456
2457      ??? Also following the old parser, typedef names may be
2458      redeclared in declarators, but not Objective-C class names.  */
2459
2460   if (kind != C_DTR_ABSTRACT
2461       && c_parser_next_token_is (parser, CPP_NAME)
2462       && ((type_seen_p
2463            && c_parser_peek_token (parser)->id_kind == C_ID_TYPENAME)
2464           || c_parser_peek_token (parser)->id_kind == C_ID_ID))
2465     {
2466       struct c_declarator *inner
2467         = build_id_declarator (c_parser_peek_token (parser)->value);
2468       *seen_id = true;
2469       inner->id_loc = c_parser_peek_token (parser)->location;
2470       c_parser_consume_token (parser);
2471       return c_parser_direct_declarator_inner (parser, *seen_id, inner);
2472     }
2473
2474   if (kind != C_DTR_NORMAL
2475       && c_parser_next_token_is (parser, CPP_OPEN_SQUARE))
2476     {
2477       struct c_declarator *inner = build_id_declarator (NULL_TREE);
2478       return c_parser_direct_declarator_inner (parser, *seen_id, inner);
2479     }
2480
2481   /* Either we are at the end of an abstract declarator, or we have
2482      parentheses.  */
2483
2484   if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
2485     {
2486       tree attrs;
2487       struct c_declarator *inner;
2488       c_parser_consume_token (parser);
2489       attrs = c_parser_attributes (parser);
2490       if (kind != C_DTR_NORMAL
2491           && (c_parser_next_token_starts_declspecs (parser)
2492               || c_parser_next_token_is (parser, CPP_CLOSE_PAREN)))
2493         {
2494           struct c_arg_info *args
2495             = c_parser_parms_declarator (parser, kind == C_DTR_NORMAL,
2496                                          attrs);
2497           if (args == NULL)
2498             return NULL;
2499           else
2500             {
2501               inner
2502                 = build_function_declarator (args,
2503                                              build_id_declarator (NULL_TREE));
2504               return c_parser_direct_declarator_inner (parser, *seen_id,
2505                                                        inner);
2506             }
2507         }
2508       /* A parenthesized declarator.  */
2509       inner = c_parser_declarator (parser, type_seen_p, kind, seen_id);
2510       if (inner != NULL && attrs != NULL)
2511         inner = build_attrs_declarator (attrs, inner);
2512       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2513         {
2514           c_parser_consume_token (parser);
2515           if (inner == NULL)
2516             return NULL;
2517           else
2518             return c_parser_direct_declarator_inner (parser, *seen_id, inner);
2519         }
2520       else
2521         {
2522           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2523                                      "expected %<)%>");
2524           return NULL;
2525         }
2526     }
2527   else
2528     {
2529       if (kind == C_DTR_NORMAL)
2530         {
2531           c_parser_error (parser, "expected identifier or %<(%>");
2532           return NULL;
2533         }
2534       else
2535         return build_id_declarator (NULL_TREE);
2536     }
2537 }
2538
2539 /* Parse part of a direct declarator or direct abstract declarator,
2540    given that some (in INNER) has already been parsed; ID_PRESENT is
2541    true if an identifier is present, false for an abstract
2542    declarator.  */
2543
2544 static struct c_declarator *
2545 c_parser_direct_declarator_inner (c_parser *parser, bool id_present,
2546                                   struct c_declarator *inner)
2547 {
2548   /* Parse a sequence of array declarators and parameter lists.  */
2549   if (c_parser_next_token_is (parser, CPP_OPEN_SQUARE))
2550     {
2551       location_t brace_loc = c_parser_peek_token (parser)->location;
2552       struct c_declarator *declarator;
2553       struct c_declspecs *quals_attrs = build_null_declspecs ();
2554       bool static_seen;
2555       bool star_seen;
2556       tree dimen;
2557       c_parser_consume_token (parser);
2558       c_parser_declspecs (parser, quals_attrs, false, false, true);
2559       static_seen = c_parser_next_token_is_keyword (parser, RID_STATIC);
2560       if (static_seen)
2561         c_parser_consume_token (parser);
2562       if (static_seen && !quals_attrs->declspecs_seen_p)
2563         c_parser_declspecs (parser, quals_attrs, false, false, true);
2564       if (!quals_attrs->declspecs_seen_p)
2565         quals_attrs = NULL;
2566       /* If "static" is present, there must be an array dimension.
2567          Otherwise, there may be a dimension, "*", or no
2568          dimension.  */
2569       if (static_seen)
2570         {
2571           star_seen = false;
2572           dimen = c_parser_expr_no_commas (parser, NULL).value;
2573         }
2574       else
2575         {
2576           if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
2577             {
2578               dimen = NULL_TREE;
2579               star_seen = false;
2580             }
2581           else if (c_parser_next_token_is (parser, CPP_MULT))
2582             {
2583               if (c_parser_peek_2nd_token (parser)->type == CPP_CLOSE_SQUARE)
2584                 {
2585                   dimen = NULL_TREE;
2586                   star_seen = true;
2587                   c_parser_consume_token (parser);
2588                 }
2589               else
2590                 {
2591                   star_seen = false;
2592                   dimen = c_parser_expr_no_commas (parser, NULL).value;
2593                 }
2594             }
2595           else
2596             {
2597               star_seen = false;
2598               dimen = c_parser_expr_no_commas (parser, NULL).value;
2599             }
2600         }
2601       if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
2602         c_parser_consume_token (parser);
2603       else
2604         {
2605           c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
2606                                      "expected %<]%>");
2607           return NULL;
2608         }
2609       if (dimen)
2610         mark_exp_read (dimen);
2611       declarator = build_array_declarator (brace_loc, dimen, quals_attrs,
2612                                            static_seen, star_seen);
2613       if (declarator == NULL)
2614         return NULL;
2615       inner = set_array_declarator_inner (declarator, inner);
2616       return c_parser_direct_declarator_inner (parser, id_present, inner);
2617     }
2618   else if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
2619     {
2620       tree attrs;
2621       struct c_arg_info *args;
2622       c_parser_consume_token (parser);
2623       attrs = c_parser_attributes (parser);
2624       args = c_parser_parms_declarator (parser, id_present, attrs);
2625       if (args == NULL)
2626         return NULL;
2627       else
2628         {
2629           inner = build_function_declarator (args, inner);
2630           return c_parser_direct_declarator_inner (parser, id_present, inner);
2631         }
2632     }
2633   return inner;
2634 }
2635
2636 /* Parse a parameter list or identifier list, including the closing
2637    parenthesis but not the opening one.  ATTRS are the attributes at
2638    the start of the list.  ID_LIST_OK is true if an identifier list is
2639    acceptable; such a list must not have attributes at the start.  */
2640
2641 static struct c_arg_info *
2642 c_parser_parms_declarator (c_parser *parser, bool id_list_ok, tree attrs)
2643 {
2644   push_scope ();
2645   declare_parm_level ();
2646   /* If the list starts with an identifier, it is an identifier list.
2647      Otherwise, it is either a prototype list or an empty list.  */
2648   if (id_list_ok
2649       && !attrs
2650       && c_parser_next_token_is (parser, CPP_NAME)
2651       && c_parser_peek_token (parser)->id_kind == C_ID_ID)
2652     {
2653       tree list = NULL_TREE, *nextp = &list;
2654       while (c_parser_next_token_is (parser, CPP_NAME)
2655              && c_parser_peek_token (parser)->id_kind == C_ID_ID)
2656         {
2657           *nextp = build_tree_list (NULL_TREE,
2658                                     c_parser_peek_token (parser)->value);
2659           nextp = & TREE_CHAIN (*nextp);
2660           c_parser_consume_token (parser);
2661           if (c_parser_next_token_is_not (parser, CPP_COMMA))
2662             break;
2663           c_parser_consume_token (parser);
2664           if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2665             {
2666               c_parser_error (parser, "expected identifier");
2667               break;
2668             }
2669         }
2670       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2671         {
2672           struct c_arg_info *ret = XOBNEW (&parser_obstack, struct c_arg_info);
2673           ret->parms = 0;
2674           ret->tags = 0;
2675           ret->types = list;
2676           ret->others = 0;
2677           ret->pending_sizes = 0;
2678           ret->had_vla_unspec = 0;
2679           c_parser_consume_token (parser);
2680           pop_scope ();
2681           return ret;
2682         }
2683       else
2684         {
2685           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2686                                      "expected %<)%>");
2687           pop_scope ();
2688           return NULL;
2689         }
2690     }
2691   else
2692     {
2693       struct c_arg_info *ret = c_parser_parms_list_declarator (parser, attrs);
2694       pop_scope ();
2695       return ret;
2696     }
2697 }
2698
2699 /* Parse a parameter list (possibly empty), including the closing
2700    parenthesis but not the opening one.  ATTRS are the attributes at
2701    the start of the list.  */
2702
2703 static struct c_arg_info *
2704 c_parser_parms_list_declarator (c_parser *parser, tree attrs)
2705 {
2706   bool good_parm = false;
2707   /* ??? Following the old parser, forward parameter declarations may
2708      use abstract declarators, and if no real parameter declarations
2709      follow the forward declarations then this is not diagnosed.  Also
2710      note as above that attributes are ignored as the only contents of
2711      the parentheses, or as the only contents after forward
2712      declarations.  */
2713   if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2714     {
2715       struct c_arg_info *ret = XOBNEW (&parser_obstack, struct c_arg_info);
2716       ret->parms = 0;
2717       ret->tags = 0;
2718       ret->types = 0;
2719       ret->others = 0;
2720       ret->pending_sizes = 0;
2721       ret->had_vla_unspec = 0;
2722       c_parser_consume_token (parser);
2723       return ret;
2724     }
2725   if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
2726     {
2727       struct c_arg_info *ret = XOBNEW (&parser_obstack, struct c_arg_info);
2728       ret->parms = 0;
2729       ret->tags = 0;
2730       ret->others = 0;
2731       ret->pending_sizes = 0;
2732       ret->had_vla_unspec = 0;
2733       /* Suppress -Wold-style-definition for this case.  */
2734       ret->types = error_mark_node;
2735       error_at (c_parser_peek_token (parser)->location,
2736                 "ISO C requires a named argument before %<...%>");
2737       c_parser_consume_token (parser);
2738       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2739         {
2740           c_parser_consume_token (parser);
2741           return ret;
2742         }
2743       else
2744         {
2745           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2746                                      "expected %<)%>");
2747           return NULL;
2748         }
2749     }
2750   /* Nonempty list of parameters, either terminated with semicolon
2751      (forward declarations; recurse) or with close parenthesis (normal
2752      function) or with ", ... )" (variadic function).  */
2753   while (true)
2754     {
2755       /* Parse a parameter.  */
2756       struct c_parm *parm = c_parser_parameter_declaration (parser, attrs);
2757       attrs = NULL_TREE;
2758       if (parm != NULL)
2759         {
2760           good_parm = true;
2761           push_parm_decl (parm);
2762         }
2763       if (c_parser_next_token_is (parser, CPP_SEMICOLON))
2764         {
2765           tree new_attrs;
2766           c_parser_consume_token (parser);
2767           mark_forward_parm_decls ();
2768           new_attrs = c_parser_attributes (parser);
2769           return c_parser_parms_list_declarator (parser, new_attrs);
2770         }
2771       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2772         {
2773           c_parser_consume_token (parser);
2774           if (good_parm)
2775             return get_parm_info (false);
2776           else
2777             {
2778               struct c_arg_info *ret
2779                 = XOBNEW (&parser_obstack, struct c_arg_info);
2780               ret->parms = 0;
2781               ret->tags = 0;
2782               ret->types = 0;
2783               ret->others = 0;
2784               ret->pending_sizes = 0;
2785               ret->had_vla_unspec = 0;
2786               return ret;
2787             }
2788         }
2789       if (!c_parser_require (parser, CPP_COMMA,
2790                              "expected %<;%>, %<,%> or %<)%>"))
2791         {
2792           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
2793           get_pending_sizes ();
2794           return NULL;
2795         }
2796       if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
2797         {
2798           c_parser_consume_token (parser);
2799           if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
2800             {
2801               c_parser_consume_token (parser);
2802               if (good_parm)
2803                 return get_parm_info (true);
2804               else
2805                 {
2806                   struct c_arg_info *ret
2807                     = XOBNEW (&parser_obstack, struct c_arg_info);
2808                   ret->parms = 0;
2809                   ret->tags = 0;
2810                   ret->types = 0;
2811                   ret->others = 0;
2812                   ret->pending_sizes = 0;
2813                   ret->had_vla_unspec = 0;
2814                   return ret;
2815                 }
2816             }
2817           else
2818             {
2819               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
2820                                          "expected %<)%>");
2821               get_pending_sizes ();
2822               return NULL;
2823             }
2824         }
2825     }
2826 }
2827
2828 /* Parse a parameter declaration.  ATTRS are the attributes at the
2829    start of the declaration if it is the first parameter.  */
2830
2831 static struct c_parm *
2832 c_parser_parameter_declaration (c_parser *parser, tree attrs)
2833 {
2834   struct c_declspecs *specs;
2835   struct c_declarator *declarator;
2836   tree prefix_attrs;
2837   tree postfix_attrs = NULL_TREE;
2838   bool dummy = false;
2839   if (!c_parser_next_token_starts_declspecs (parser))
2840     {
2841       /* ??? In some Objective-C cases '...' isn't applicable so there
2842          should be a different message.  */
2843       c_parser_error (parser,
2844                       "expected declaration specifiers or %<...%>");
2845       c_parser_skip_to_end_of_parameter (parser);
2846       return NULL;
2847     }
2848   specs = build_null_declspecs ();
2849   if (attrs)
2850     {
2851       declspecs_add_attrs (specs, attrs);
2852       attrs = NULL_TREE;
2853     }
2854   c_parser_declspecs (parser, specs, true, true, true);
2855   finish_declspecs (specs);
2856   pending_xref_error ();
2857   prefix_attrs = specs->attrs;
2858   specs->attrs = NULL_TREE;
2859   declarator = c_parser_declarator (parser, specs->type_seen_p,
2860                                     C_DTR_PARM, &dummy);
2861   if (declarator == NULL)
2862     {
2863       c_parser_skip_until_found (parser, CPP_COMMA, NULL);
2864       return NULL;
2865     }
2866   if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
2867     postfix_attrs = c_parser_attributes (parser);
2868   return build_c_parm (specs, chainon (postfix_attrs, prefix_attrs),
2869                        declarator);
2870 }
2871
2872 /* Parse a string literal in an asm expression.  It should not be
2873    translated, and wide string literals are an error although
2874    permitted by the syntax.  This is a GNU extension.
2875
2876    asm-string-literal:
2877      string-literal
2878
2879    ??? At present, following the old parser, the caller needs to have
2880    set lex_untranslated_string to 1.  It would be better to follow the
2881    C++ parser rather than using this kludge.  */
2882
2883 static tree
2884 c_parser_asm_string_literal (c_parser *parser)
2885 {
2886   tree str;
2887   if (c_parser_next_token_is (parser, CPP_STRING))
2888     {
2889       str = c_parser_peek_token (parser)->value;
2890       c_parser_consume_token (parser);
2891     }
2892   else if (c_parser_next_token_is (parser, CPP_WSTRING))
2893     {
2894       error_at (c_parser_peek_token (parser)->location,
2895                 "wide string literal in %<asm%>");
2896       str = build_string (1, "");
2897       c_parser_consume_token (parser);
2898     }
2899   else
2900     {
2901       c_parser_error (parser, "expected string literal");
2902       str = NULL_TREE;
2903     }
2904   return str;
2905 }
2906
2907 /* Parse a simple asm expression.  This is used in restricted
2908    contexts, where a full expression with inputs and outputs does not
2909    make sense.  This is a GNU extension.
2910
2911    simple-asm-expr:
2912      asm ( asm-string-literal )
2913 */
2914
2915 static tree
2916 c_parser_simple_asm_expr (c_parser *parser)
2917 {
2918   tree str;
2919   gcc_assert (c_parser_next_token_is_keyword (parser, RID_ASM));
2920   /* ??? Follow the C++ parser rather than using the
2921      lex_untranslated_string kludge.  */
2922   parser->lex_untranslated_string = true;
2923   c_parser_consume_token (parser);
2924   if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
2925     {
2926       parser->lex_untranslated_string = false;
2927       return NULL_TREE;
2928     }
2929   str = c_parser_asm_string_literal (parser);
2930   parser->lex_untranslated_string = false;
2931   if (!c_parser_require (parser, CPP_CLOSE_PAREN, "expected %<)%>"))
2932     {
2933       c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
2934       return NULL_TREE;
2935     }
2936   return str;
2937 }
2938
2939 /* Parse (possibly empty) attributes.  This is a GNU extension.
2940
2941    attributes:
2942      empty
2943      attributes attribute
2944
2945    attribute:
2946      __attribute__ ( ( attribute-list ) )
2947
2948    attribute-list:
2949      attrib
2950      attribute_list , attrib
2951
2952    attrib:
2953      empty
2954      any-word
2955      any-word ( identifier )
2956      any-word ( identifier , nonempty-expr-list )
2957      any-word ( expr-list )
2958
2959    where the "identifier" must not be declared as a type, and
2960    "any-word" may be any identifier (including one declared as a
2961    type), a reserved word storage class specifier, type specifier or
2962    type qualifier.  ??? This still leaves out most reserved keywords
2963    (following the old parser), shouldn't we include them, and why not
2964    allow identifiers declared as types to start the arguments?  */
2965
2966 static tree
2967 c_parser_attributes (c_parser *parser)
2968 {
2969   tree attrs = NULL_TREE;
2970   while (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
2971     {
2972       /* ??? Follow the C++ parser rather than using the
2973          lex_untranslated_string kludge.  */
2974       parser->lex_untranslated_string = true;
2975       c_parser_consume_token (parser);
2976       if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
2977         {
2978           parser->lex_untranslated_string = false;
2979           return attrs;
2980         }
2981       if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
2982         {
2983           parser->lex_untranslated_string = false;
2984           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
2985           return attrs;
2986         }
2987       /* Parse the attribute list.  */
2988       while (c_parser_next_token_is (parser, CPP_COMMA)
2989              || c_parser_next_token_is (parser, CPP_NAME)
2990              || c_parser_next_token_is (parser, CPP_KEYWORD))
2991         {
2992           tree attr, attr_name, attr_args;
2993           VEC(tree,gc) *expr_list;
2994           if (c_parser_next_token_is (parser, CPP_COMMA))
2995             {
2996               c_parser_consume_token (parser);
2997               continue;
2998             }
2999           if (c_parser_next_token_is (parser, CPP_KEYWORD))
3000             {
3001               /* ??? See comment above about what keywords are
3002                  accepted here.  */
3003               bool ok;
3004               switch (c_parser_peek_token (parser)->keyword)
3005                 {
3006                 case RID_STATIC:
3007                 case RID_UNSIGNED:
3008                 case RID_LONG:
3009                 case RID_CONST:
3010                 case RID_EXTERN:
3011                 case RID_REGISTER:
3012                 case RID_TYPEDEF:
3013                 case RID_SHORT:
3014                 case RID_INLINE:
3015                 case RID_VOLATILE:
3016                 case RID_SIGNED:
3017                 case RID_AUTO:
3018                 case RID_RESTRICT:
3019                 case RID_COMPLEX:
3020                 case RID_THREAD:
3021                 case RID_INT:
3022                 case RID_CHAR:
3023                 case RID_FLOAT:
3024                 case RID_DOUBLE:
3025                 case RID_VOID:
3026                 case RID_DFLOAT32:
3027                 case RID_DFLOAT64:
3028                 case RID_DFLOAT128:
3029                 case RID_BOOL:
3030                 case RID_FRACT:
3031                 case RID_ACCUM:
3032                 case RID_SAT:
3033                   ok = true;
3034                   break;
3035                 default:
3036                   ok = false;
3037                   break;
3038                 }
3039               if (!ok)
3040                 break;
3041               /* Accept __attribute__((__const)) as __attribute__((const))
3042                  etc.  */
3043               attr_name
3044                 = ridpointers[(int) c_parser_peek_token (parser)->keyword];
3045             }
3046           else
3047             attr_name = c_parser_peek_token (parser)->value;
3048           c_parser_consume_token (parser);
3049           if (c_parser_next_token_is_not (parser, CPP_OPEN_PAREN))
3050             {
3051               attr = build_tree_list (attr_name, NULL_TREE);
3052               attrs = chainon (attrs, attr);
3053               continue;
3054             }
3055           c_parser_consume_token (parser);
3056           /* Parse the attribute contents.  If they start with an
3057              identifier which is followed by a comma or close
3058              parenthesis, then the arguments start with that
3059              identifier; otherwise they are an expression list.  */
3060           if (c_parser_next_token_is (parser, CPP_NAME)
3061               && c_parser_peek_token (parser)->id_kind == C_ID_ID
3062               && ((c_parser_peek_2nd_token (parser)->type == CPP_COMMA)
3063                   || (c_parser_peek_2nd_token (parser)->type
3064                       == CPP_CLOSE_PAREN)))
3065             {
3066               tree arg1 = c_parser_peek_token (parser)->value;
3067               c_parser_consume_token (parser);
3068               if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
3069                 attr_args = build_tree_list (NULL_TREE, arg1);
3070               else
3071                 {
3072                   tree tree_list;
3073                   c_parser_consume_token (parser);
3074                   expr_list = c_parser_expr_list (parser, false, true, NULL);
3075                   tree_list = build_tree_list_vec (expr_list);
3076                   attr_args = tree_cons (NULL_TREE, arg1, tree_list);
3077                   release_tree_vector (expr_list);
3078                 }
3079             }
3080           else
3081             {
3082               if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
3083                 attr_args = NULL_TREE;
3084               else
3085                 {
3086                   expr_list = c_parser_expr_list (parser, false, true, NULL);
3087                   attr_args = build_tree_list_vec (expr_list);
3088                   release_tree_vector (expr_list);
3089                 }
3090             }
3091           attr = build_tree_list (attr_name, attr_args);
3092           if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
3093             c_parser_consume_token (parser);
3094           else
3095             {
3096               parser->lex_untranslated_string = false;
3097               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
3098                                          "expected %<)%>");
3099               return attrs;
3100             }
3101           attrs = chainon (attrs, attr);
3102         }
3103       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
3104         c_parser_consume_token (parser);
3105       else
3106         {
3107           parser->lex_untranslated_string = false;
3108           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
3109                                      "expected %<)%>");
3110           return attrs;
3111         }
3112       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
3113         c_parser_consume_token (parser);
3114       else
3115         {
3116           parser->lex_untranslated_string = false;
3117           c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
3118                                      "expected %<)%>");
3119           return attrs;
3120         }
3121       parser->lex_untranslated_string = false;
3122     }
3123   return attrs;
3124 }
3125
3126 /* Parse a type name (C90 6.5.5, C99 6.7.6).
3127
3128    type-name:
3129      specifier-qualifier-list abstract-declarator[opt]
3130 */
3131
3132 static struct c_type_name *
3133 c_parser_type_name (c_parser *parser)
3134 {
3135   struct c_declspecs *specs = build_null_declspecs ();
3136   struct c_declarator *declarator;
3137   struct c_type_name *ret;
3138   bool dummy = false;
3139   c_parser_declspecs (parser, specs, false, true, true);
3140   if (!specs->declspecs_seen_p)
3141     {
3142       c_parser_error (parser, "expected specifier-qualifier-list");
3143       return NULL;
3144     }
3145   pending_xref_error ();
3146   finish_declspecs (specs);
3147   declarator = c_parser_declarator (parser, specs->type_seen_p,
3148                                     C_DTR_ABSTRACT, &dummy);
3149   if (declarator == NULL)
3150     return NULL;
3151   ret = XOBNEW (&parser_obstack, struct c_type_name);
3152   ret->specs = specs;
3153   ret->declarator = declarator;
3154   return ret;
3155 }
3156
3157 /* Parse an initializer (C90 6.5.7, C99 6.7.8).
3158
3159    initializer:
3160      assignment-expression
3161      { initializer-list }
3162      { initializer-list , }
3163
3164    initializer-list:
3165      designation[opt] initializer
3166      initializer-list , designation[opt] initializer
3167
3168    designation:
3169      designator-list =
3170
3171    designator-list:
3172      designator
3173      designator-list designator
3174
3175    designator:
3176      array-designator
3177      . identifier
3178
3179    array-designator:
3180      [ constant-expression ]
3181
3182    GNU extensions:
3183
3184    initializer:
3185      { }
3186
3187    designation:
3188      array-designator
3189      identifier :
3190
3191    array-designator:
3192      [ constant-expression ... constant-expression ]
3193
3194    Any expression without commas is accepted in the syntax for the
3195    constant-expressions, with non-constant expressions rejected later.
3196
3197    This function is only used for top-level initializers; for nested
3198    ones, see c_parser_initval.  */
3199
3200 static struct c_expr
3201 c_parser_initializer (c_parser *parser)
3202 {
3203   if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
3204     return c_parser_braced_init (parser, NULL_TREE, false);
3205   else
3206     {
3207       struct c_expr ret;
3208       location_t loc = c_parser_peek_token (parser)->location;
3209       ret = c_parser_expr_no_commas (parser, NULL);
3210       if (TREE_CODE (ret.value) != STRING_CST
3211           && TREE_CODE (ret.value) != COMPOUND_LITERAL_EXPR)
3212         ret = default_function_array_read_conversion (loc, ret);
3213       return ret;
3214     }
3215 }
3216
3217 /* Parse a braced initializer list.  TYPE is the type specified for a
3218    compound literal, and NULL_TREE for other initializers and for
3219    nested braced lists.  NESTED_P is true for nested braced lists,
3220    false for the list of a compound literal or the list that is the
3221    top-level initializer in a declaration.  */
3222
3223 static struct c_expr
3224 c_parser_braced_init (c_parser *parser, tree type, bool nested_p)
3225 {
3226   struct c_expr ret;
3227   struct obstack braced_init_obstack;
3228   location_t brace_loc = c_parser_peek_token (parser)->location;
3229   gcc_obstack_init (&braced_init_obstack);
3230   gcc_assert (c_parser_next_token_is (parser, CPP_OPEN_BRACE));
3231   c_parser_consume_token (parser);
3232   if (nested_p)
3233     push_init_level (0, &braced_init_obstack);
3234   else
3235     really_start_incremental_init (type);
3236   if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
3237     {
3238       pedwarn (brace_loc, OPT_pedantic, "ISO C forbids empty initializer braces");
3239     }
3240   else
3241     {
3242       /* Parse a non-empty initializer list, possibly with a trailing
3243          comma.  */
3244       while (true)
3245         {
3246           c_parser_initelt (parser, &braced_init_obstack);
3247           if (parser->error)
3248             break;
3249           if (c_parser_next_token_is (parser, CPP_COMMA))
3250             c_parser_consume_token (parser);
3251           else
3252             break;
3253           if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
3254             break;
3255         }
3256     }
3257   if (c_parser_next_token_is_not (parser, CPP_CLOSE_BRACE))
3258     {
3259       ret.value = error_mark_node;
3260       ret.original_code = ERROR_MARK;
3261       ret.original_type = NULL;
3262       c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, "expected %<}%>");
3263       pop_init_level (0, &braced_init_obstack);
3264       obstack_free (&braced_init_obstack, NULL);
3265       return ret;
3266     }
3267   c_parser_consume_token (parser);
3268   ret = pop_init_level (0, &braced_init_obstack);
3269   obstack_free (&braced_init_obstack, NULL);
3270   return ret;
3271 }
3272
3273 /* Parse a nested initializer, including designators.  */
3274
3275 static void
3276 c_parser_initelt (c_parser *parser, struct obstack * braced_init_obstack)
3277 {
3278   /* Parse any designator or designator list.  A single array
3279      designator may have the subsequent "=" omitted in GNU C, but a
3280      longer list or a structure member designator may not.  */
3281   if (c_parser_next_token_is (parser, CPP_NAME)
3282       && c_parser_peek_2nd_token (parser)->type == CPP_COLON)
3283     {
3284       /* Old-style structure member designator.  */
3285       set_init_label (c_parser_peek_token (parser)->value,
3286                       braced_init_obstack);
3287       /* Use the colon as the error location.  */
3288       pedwarn (c_parser_peek_2nd_token (parser)->location, OPT_pedantic,
3289                "obsolete use of designated initializer with %<:%>");
3290       c_parser_consume_token (parser);
3291       c_parser_consume_token (parser);
3292     }
3293   else
3294     {
3295       /* des_seen is 0 if there have been no designators, 1 if there
3296          has been a single array designator and 2 otherwise.  */
3297       int des_seen = 0;
3298       /* Location of a designator.  */
3299       location_t des_loc = UNKNOWN_LOCATION;  /* Quiet warning.  */
3300       while (c_parser_next_token_is (parser, CPP_OPEN_SQUARE)
3301              || c_parser_next_token_is (parser, CPP_DOT))
3302         {
3303           int des_prev = des_seen;
3304           if (!des_seen)
3305             des_loc = c_parser_peek_token (parser)->location;
3306           if (des_seen < 2)
3307             des_seen++;
3308           if (c_parser_next_token_is (parser, CPP_DOT))
3309             {
3310               des_seen = 2;
3311               c_parser_consume_token (parser);
3312               if (c_parser_next_token_is (parser, CPP_NAME))
3313                 {
3314                   set_init_label (c_parser_peek_token (parser)->value,
3315                                   braced_init_obstack);
3316                   c_parser_consume_token (parser);
3317                 }
3318               else
3319                 {
3320                   struct c_expr init;
3321                   init.value = error_mark_node;
3322                   init.original_code = ERROR_MARK;
3323                   init.original_type = NULL;
3324                   c_parser_error (parser, "expected identifier");
3325                   c_parser_skip_until_found (parser, CPP_COMMA, NULL);
3326                   process_init_element (init, false, braced_init_obstack);
3327                   return;
3328                 }
3329             }
3330           else
3331             {
3332               tree first, second;
3333               location_t ellipsis_loc = UNKNOWN_LOCATION;  /* Quiet warning.  */
3334               /* ??? Following the old parser, [ objc-receiver
3335                  objc-message-args ] is accepted as an initializer,
3336                  being distinguished from a designator by what follows
3337                  the first assignment expression inside the square
3338                  brackets, but after a first array designator a
3339                  subsequent square bracket is for Objective-C taken to
3340                  start an expression, using the obsolete form of
3341                  designated initializer without '=', rather than
3342                  possibly being a second level of designation: in LALR
3343                  terms, the '[' is shifted rather than reducing
3344                  designator to designator-list.  */
3345               if (des_prev == 1 && c_dialect_objc ())
3346                 {
3347                   des_seen = des_prev;
3348                   break;
3349                 }
3350               if (des_prev == 0 && c_dialect_objc ())
3351                 {
3352                   /* This might be an array designator or an
3353                      Objective-C message expression.  If the former,
3354                      continue parsing here; if the latter, parse the
3355                      remainder of the initializer given the starting
3356                      primary-expression.  ??? It might make sense to
3357                      distinguish when des_prev == 1 as well; see
3358                      previous comment.  */
3359                   tree rec, args;
3360                   struct c_expr mexpr;
3361                   c_parser_consume_token (parser);
3362                   if (c_parser_peek_token (parser)->type == CPP_NAME
3363                       && ((c_parser_peek_token (parser)->id_kind
3364                            == C_ID_TYPENAME)
3365                           || (c_parser_peek_token (parser)->id_kind
3366                               == C_ID_CLASSNAME)))
3367                     {
3368                       /* Type name receiver.  */
3369                       tree id = c_parser_peek_token (parser)->value;
3370                       c_parser_consume_token (parser);
3371                       rec = objc_get_class_reference (id);
3372                       goto parse_message_args;
3373                     }
3374                   first = c_parser_expr_no_commas (parser, NULL).value;
3375                   mark_exp_read (first);
3376                   if (c_parser_next_token_is (parser, CPP_ELLIPSIS)
3377                       || c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
3378                     goto array_desig_after_first;
3379                   /* Expression receiver.  So far only one part
3380                      without commas has been parsed; there might be
3381                      more of the expression.  */
3382                   rec = first;
3383                   while (c_parser_next_token_is (parser, CPP_COMMA))
3384                     {
3385                       struct c_expr next;
3386                       location_t comma_loc, exp_loc;
3387                       comma_loc = c_parser_peek_token (parser)->location;
3388                       c_parser_consume_token (parser);
3389                       exp_loc = c_parser_peek_token (parser)->location;
3390                       next = c_parser_expr_no_commas (parser, NULL);
3391                       next = default_function_array_read_conversion (exp_loc,
3392                                                                      next);
3393                       rec = build_compound_expr (comma_loc, rec, next.value);
3394                     }
3395                 parse_message_args:
3396                   /* Now parse the objc-message-args.  */
3397                   args = c_parser_objc_message_args (parser);
3398                   c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
3399                                              "expected %<]%>");
3400                   mexpr.value
3401                     = objc_build_message_expr (build_tree_list (rec, args));
3402                   mexpr.original_code = ERROR_MARK;
3403                   mexpr.original_type = NULL;
3404                   /* Now parse and process the remainder of the
3405                      initializer, starting with this message
3406                      expression as a primary-expression.  */
3407                   c_parser_initval (parser, &mexpr, braced_init_obstack);
3408                   return;
3409                 }
3410               c_parser_consume_token (parser);
3411               first = c_parser_expr_no_commas (parser, NULL).value;
3412               mark_exp_read (first);
3413             array_desig_after_first:
3414               if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
3415                 {
3416                   ellipsis_loc = c_parser_peek_token (parser)->location;
3417                   c_parser_consume_token (parser);
3418                   second = c_parser_expr_no_commas (parser, NULL).value;
3419                   mark_exp_read (second);
3420                 }
3421               else
3422                 second = NULL_TREE;
3423               if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
3424                 {
3425                   c_parser_consume_token (parser);
3426                   set_init_index (first, second, braced_init_obstack);
3427                   if (second)
3428                     pedwarn (ellipsis_loc, OPT_pedantic,
3429                              "ISO C forbids specifying range of elements to initialize");
3430                 }
3431               else
3432                 c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
3433                                            "expected %<]%>");
3434             }
3435         }
3436       if (des_seen >= 1)
3437         {
3438           if (c_parser_next_token_is (parser, CPP_EQ))
3439             {
3440               if (!flag_isoc99)
3441                 pedwarn (des_loc, OPT_pedantic,
3442                          "ISO C90 forbids specifying subobject to initialize");
3443               c_parser_consume_token (parser);
3444             }
3445           else
3446             {
3447               if (des_seen == 1)
3448                 pedwarn (c_parser_peek_token (parser)->location, OPT_pedantic,
3449                          "obsolete use of designated initializer without %<=%>");
3450               else
3451                 {
3452                   struct c_expr init;
3453                   init.value = error_mark_node;
3454                   init.original_code = ERROR_MARK;
3455                   init.original_type = NULL;
3456                   c_parser_error (parser, "expected %<=%>");
3457                   c_parser_skip_until_found (parser, CPP_COMMA, NULL);
3458                   process_init_element (init, false, braced_init_obstack);
3459                   return;
3460                 }
3461             }
3462         }
3463     }
3464   c_parser_initval (parser, NULL, braced_init_obstack);
3465 }
3466
3467 /* Parse a nested initializer; as c_parser_initializer but parses
3468    initializers within braced lists, after any designators have been
3469    applied.  If AFTER is not NULL then it is an Objective-C message
3470    expression which is the primary-expression starting the
3471    initializer.  */
3472
3473 static void
3474 c_parser_initval (c_parser *parser, struct c_expr *after,
3475                   struct obstack