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 Free Software Foundation, Inc.
5 Parser actions based on the old Bison parser; structure somewhat
6 influenced by and fragments based on the C++ parser.
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify it under
11 the terms of the GNU General Public License as published by the Free
12 Software Foundation; either version 3, or (at your option) any later
15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
26 Make sure all relevant comments, and all relevant code from all
27 actions, brought over from old parser. Verify exact correspondence
30 Add testcases covering every input symbol in every state in old and
33 Include full syntax for GNU C, including erroneous cases accepted
34 with error messages, in syntax productions in comments.
36 Make more diagnostics in the front end generally take an explicit
37 location rather than implicitly using input_location. */
41 #include "coretypes.h"
45 #include "langhooks.h"
61 /* The reserved keyword table. */
65 ENUM_BITFIELD(rid
) rid
: 16;
66 unsigned int disable
: 16;
69 /* Disable mask. Keywords are disabled if (reswords[i].disable &
71 #define D_C89 0x01 /* not in C89 */
72 #define D_EXT 0x02 /* GCC extension */
73 #define D_EXT89 0x04 /* GCC extension incorporated in C99 */
74 #define D_OBJC 0x08 /* Objective C only */
76 static const struct resword reswords
[] =
78 { "_Bool", RID_BOOL
, 0 },
79 { "_Complex", RID_COMPLEX
, 0 },
80 { "_Decimal32", RID_DFLOAT32
, D_EXT
},
81 { "_Decimal64", RID_DFLOAT64
, D_EXT
},
82 { "_Decimal128", RID_DFLOAT128
, D_EXT
},
83 { "_Fract", RID_FRACT
, D_EXT
},
84 { "_Accum", RID_ACCUM
, D_EXT
},
85 { "_Sat", RID_SAT
, D_EXT
},
86 { "__FUNCTION__", RID_FUNCTION_NAME
, 0 },
87 { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME
, 0 },
88 { "__alignof", RID_ALIGNOF
, 0 },
89 { "__alignof__", RID_ALIGNOF
, 0 },
90 { "__asm", RID_ASM
, 0 },
91 { "__asm__", RID_ASM
, 0 },
92 { "__attribute", RID_ATTRIBUTE
, 0 },
93 { "__attribute__", RID_ATTRIBUTE
, 0 },
94 { "__builtin_choose_expr", RID_CHOOSE_EXPR
, 0 },
95 { "__builtin_offsetof", RID_OFFSETOF
, 0 },
96 { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P
, 0 },
97 { "__builtin_va_arg", RID_VA_ARG
, 0 },
98 { "__complex", RID_COMPLEX
, 0 },
99 { "__complex__", RID_COMPLEX
, 0 },
100 { "__const", RID_CONST
, 0 },
101 { "__const__", RID_CONST
, 0 },
102 { "__extension__", RID_EXTENSION
, 0 },
103 { "__func__", RID_C99_FUNCTION_NAME
, 0 },
104 { "__imag", RID_IMAGPART
, 0 },
105 { "__imag__", RID_IMAGPART
, 0 },
106 { "__inline", RID_INLINE
, 0 },
107 { "__inline__", RID_INLINE
, 0 },
108 { "__label__", RID_LABEL
, 0 },
109 { "__real", RID_REALPART
, 0 },
110 { "__real__", RID_REALPART
, 0 },
111 { "__restrict", RID_RESTRICT
, 0 },
112 { "__restrict__", RID_RESTRICT
, 0 },
113 { "__signed", RID_SIGNED
, 0 },
114 { "__signed__", RID_SIGNED
, 0 },
115 { "__thread", RID_THREAD
, 0 },
116 { "__typeof", RID_TYPEOF
, 0 },
117 { "__typeof__", RID_TYPEOF
, 0 },
118 { "__volatile", RID_VOLATILE
, 0 },
119 { "__volatile__", RID_VOLATILE
, 0 },
120 { "asm", RID_ASM
, D_EXT
},
121 { "auto", RID_AUTO
, 0 },
122 { "break", RID_BREAK
, 0 },
123 { "case", RID_CASE
, 0 },
124 { "char", RID_CHAR
, 0 },
125 { "const", RID_CONST
, 0 },
126 { "continue", RID_CONTINUE
, 0 },
127 { "default", RID_DEFAULT
, 0 },
129 { "double", RID_DOUBLE
, 0 },
130 { "else", RID_ELSE
, 0 },
131 { "enum", RID_ENUM
, 0 },
132 { "extern", RID_EXTERN
, 0 },
133 { "float", RID_FLOAT
, 0 },
134 { "for", RID_FOR
, 0 },
135 { "goto", RID_GOTO
, 0 },
137 { "inline", RID_INLINE
, D_EXT89
},
138 { "int", RID_INT
, 0 },
139 { "long", RID_LONG
, 0 },
140 { "register", RID_REGISTER
, 0 },
141 { "restrict", RID_RESTRICT
, D_C89
},
142 { "return", RID_RETURN
, 0 },
143 { "short", RID_SHORT
, 0 },
144 { "signed", RID_SIGNED
, 0 },
145 { "sizeof", RID_SIZEOF
, 0 },
146 { "static", RID_STATIC
, 0 },
147 { "struct", RID_STRUCT
, 0 },
148 { "switch", RID_SWITCH
, 0 },
149 { "typedef", RID_TYPEDEF
, 0 },
150 { "typeof", RID_TYPEOF
, D_EXT
},
151 { "union", RID_UNION
, 0 },
152 { "unsigned", RID_UNSIGNED
, 0 },
153 { "void", RID_VOID
, 0 },
154 { "volatile", RID_VOLATILE
, 0 },
155 { "while", RID_WHILE
, 0 },
156 /* These Objective-C keywords are recognized only immediately after
158 { "class", RID_AT_CLASS
, D_OBJC
},
159 { "compatibility_alias", RID_AT_ALIAS
, D_OBJC
},
160 { "defs", RID_AT_DEFS
, D_OBJC
},
161 { "encode", RID_AT_ENCODE
, D_OBJC
},
162 { "end", RID_AT_END
, D_OBJC
},
163 { "implementation", RID_AT_IMPLEMENTATION
, D_OBJC
},
164 { "interface", RID_AT_INTERFACE
, D_OBJC
},
165 { "private", RID_AT_PRIVATE
, D_OBJC
},
166 { "protected", RID_AT_PROTECTED
, D_OBJC
},
167 { "protocol", RID_AT_PROTOCOL
, D_OBJC
},
168 { "public", RID_AT_PUBLIC
, D_OBJC
},
169 { "selector", RID_AT_SELECTOR
, D_OBJC
},
170 { "throw", RID_AT_THROW
, D_OBJC
},
171 { "try", RID_AT_TRY
, D_OBJC
},
172 { "catch", RID_AT_CATCH
, D_OBJC
},
173 { "finally", RID_AT_FINALLY
, D_OBJC
},
174 { "synchronized", RID_AT_SYNCHRONIZED
, D_OBJC
},
175 /* These are recognized only in protocol-qualifier context
177 { "bycopy", RID_BYCOPY
, D_OBJC
},
178 { "byref", RID_BYREF
, D_OBJC
},
179 { "in", RID_IN
, D_OBJC
},
180 { "inout", RID_INOUT
, D_OBJC
},
181 { "oneway", RID_ONEWAY
, D_OBJC
},
182 { "out", RID_OUT
, D_OBJC
},
184 #define N_reswords (sizeof reswords / sizeof (struct resword))
186 /* Initialization routine for this file. */
191 /* The only initialization required is of the reserved word
195 int mask
= (flag_isoc99
? 0 : D_C89
)
196 | (flag_no_asm
? (flag_isoc99
? D_EXT
: D_EXT
|D_EXT89
) : 0);
198 if (!c_dialect_objc ())
201 ridpointers
= GGC_CNEWVEC (tree
, (int) RID_MAX
);
202 for (i
= 0; i
< N_reswords
; i
++)
204 /* If a keyword is disabled, do not enter it into the table
205 and so create a canonical spelling that isn't a keyword. */
206 if (reswords
[i
].disable
& mask
)
209 id
= get_identifier (reswords
[i
].word
);
210 C_RID_CODE (id
) = reswords
[i
].rid
;
211 C_IS_RESERVED_WORD (id
) = 1;
212 ridpointers
[(int) reswords
[i
].rid
] = id
;
216 /* The C lexer intermediates between the lexer in cpplib and c-lex.c
217 and the C parser. Unlike the C++ lexer, the parser structure
218 stores the lexer information instead of using a separate structure.
219 Identifiers are separated into ordinary identifiers, type names,
220 keywords and some other Objective-C types of identifiers, and some
221 look-ahead is maintained.
223 ??? It might be a good idea to lex the whole file up front (as for
224 C++). It would then be possible to share more of the C and C++
225 lexer code, if desired. */
227 /* The following local token type is used. */
230 #define CPP_KEYWORD ((enum cpp_ttype) (N_TTYPES + 1))
232 /* More information about the type of a CPP_NAME token. */
233 typedef enum c_id_kind
{
234 /* An ordinary identifier. */
236 /* An identifier declared as a typedef name. */
238 /* An identifier declared as an Objective-C class name. */
240 /* Not an identifier. */
244 /* A single C token after string literal concatenation and conversion
245 of preprocessing tokens to tokens. */
246 typedef struct c_token
GTY (())
248 /* The kind of token. */
249 ENUM_BITFIELD (cpp_ttype
) type
: 8;
250 /* If this token is a CPP_NAME, this value indicates whether also
251 declared as some kind of type. Otherwise, it is C_ID_NONE. */
252 ENUM_BITFIELD (c_id_kind
) id_kind
: 8;
253 /* If this token is a keyword, this value indicates which keyword.
254 Otherwise, this value is RID_MAX. */
255 ENUM_BITFIELD (rid
) keyword
: 8;
256 /* If this token is a CPP_PRAGMA, this indicates the pragma that
257 was seen. Otherwise it is PRAGMA_NONE. */
258 ENUM_BITFIELD (pragma_kind
) pragma_kind
: 7;
259 /* True if this token is from a system header. */
260 BOOL_BITFIELD in_system_header
: 1;
261 /* The value associated with this token, if any. */
263 /* The location at which this token was found. */
267 /* A parser structure recording information about the state and
268 context of parsing. Includes lexer information with up to two
269 tokens of look-ahead; more are not needed for C. */
270 typedef struct c_parser
GTY(())
272 /* The look-ahead tokens. */
274 /* How many look-ahead tokens are available (0, 1 or 2). */
276 /* True if a syntax error is being recovered from; false otherwise.
277 c_parser_error sets this flag. It should clear this flag when
278 enough tokens have been consumed to recover from the error. */
279 BOOL_BITFIELD error
: 1;
280 /* True if we're processing a pragma, and shouldn't automatically
281 consume CPP_PRAGMA_EOL. */
282 BOOL_BITFIELD in_pragma
: 1;
283 /* Objective-C specific parser/lexer information. */
284 BOOL_BITFIELD objc_pq_context
: 1;
285 /* The following flag is needed to contextualize Objective-C lexical
286 analysis. In some cases (e.g., 'int NSObject;'), it is
287 undesirable to bind an identifier to an Objective-C class, even
288 if a class with that name exists. */
289 BOOL_BITFIELD objc_need_raw_identifier
: 1;
293 /* The actual parser and external interface. ??? Does this need to be
294 garbage-collected? */
296 static GTY (()) c_parser
*the_parser
;
299 /* Read in and lex a single token, storing it in *TOKEN. */
302 c_lex_one_token (c_parser
*parser
, c_token
*token
)
304 timevar_push (TV_LEX
);
306 token
->type
= c_lex_with_flags (&token
->value
, &token
->location
, NULL
);
307 token
->id_kind
= C_ID_NONE
;
308 token
->keyword
= RID_MAX
;
309 token
->pragma_kind
= PRAGMA_NONE
;
310 token
->in_system_header
= in_system_header
;
318 bool objc_force_identifier
= parser
->objc_need_raw_identifier
;
319 if (c_dialect_objc ())
320 parser
->objc_need_raw_identifier
= false;
322 if (C_IS_RESERVED_WORD (token
->value
))
324 enum rid rid_code
= C_RID_CODE (token
->value
);
326 if (c_dialect_objc ())
328 if (!OBJC_IS_AT_KEYWORD (rid_code
)
329 && (!OBJC_IS_PQ_KEYWORD (rid_code
)
330 || parser
->objc_pq_context
))
332 /* Return the canonical spelling for this keyword. */
333 token
->value
= ridpointers
[(int) rid_code
];
334 token
->type
= CPP_KEYWORD
;
335 token
->keyword
= rid_code
;
341 /* Return the canonical spelling for this keyword. */
342 token
->value
= ridpointers
[(int) rid_code
];
343 token
->type
= CPP_KEYWORD
;
344 token
->keyword
= rid_code
;
349 decl
= lookup_name (token
->value
);
352 if (TREE_CODE (decl
) == TYPE_DECL
)
354 token
->id_kind
= C_ID_TYPENAME
;
358 else if (c_dialect_objc ())
360 tree objc_interface_decl
= objc_is_class_name (token
->value
);
361 /* Objective-C class names are in the same namespace as
362 variables and typedefs, and hence are shadowed by local
364 if (objc_interface_decl
365 && (global_bindings_p ()
366 || (!objc_force_identifier
&& !decl
)))
368 token
->value
= objc_interface_decl
;
369 token
->id_kind
= C_ID_CLASSNAME
;
373 token
->id_kind
= C_ID_ID
;
377 /* This only happens in Objective-C; it must be a keyword. */
378 token
->type
= CPP_KEYWORD
;
379 token
->keyword
= C_RID_CODE (token
->value
);
383 case CPP_CLOSE_PAREN
:
385 /* These tokens may affect the interpretation of any identifiers
386 following, if doing Objective-C. */
387 if (c_dialect_objc ())
388 parser
->objc_need_raw_identifier
= false;
391 /* We smuggled the cpp_token->u.pragma value in an INTEGER_CST. */
392 token
->pragma_kind
= TREE_INT_CST_LOW (token
->value
);
398 timevar_pop (TV_LEX
);
401 /* Return a pointer to the next token from PARSER, reading it in if
404 static inline c_token
*
405 c_parser_peek_token (c_parser
*parser
)
407 if (parser
->tokens_avail
== 0)
409 c_lex_one_token (parser
, &parser
->tokens
[0]);
410 parser
->tokens_avail
= 1;
412 return &parser
->tokens
[0];
415 /* Return true if the next token from PARSER has the indicated
419 c_parser_next_token_is (c_parser
*parser
, enum cpp_ttype type
)
421 return c_parser_peek_token (parser
)->type
== type
;
424 /* Return true if the next token from PARSER does not have the
428 c_parser_next_token_is_not (c_parser
*parser
, enum cpp_ttype type
)
430 return !c_parser_next_token_is (parser
, type
);
433 /* Return true if the next token from PARSER is the indicated
437 c_parser_next_token_is_keyword (c_parser
*parser
, enum rid keyword
)
441 /* Peek at the next token. */
442 token
= c_parser_peek_token (parser
);
443 /* Check to see if it is the indicated keyword. */
444 return token
->keyword
== keyword
;
447 /* Return true if TOKEN can start a type name,
450 c_token_starts_typename (c_token
*token
)
455 switch (token
->id_kind
)
462 gcc_assert (c_dialect_objc ());
468 switch (token
->keyword
)
500 if (c_dialect_objc ())
508 /* Return true if the next token from PARSER can start a type name,
511 c_parser_next_token_starts_typename (c_parser
*parser
)
513 c_token
*token
= c_parser_peek_token (parser
);
514 return c_token_starts_typename (token
);
517 /* Return true if TOKEN can start declaration specifiers, false
520 c_token_starts_declspecs (c_token
*token
)
525 switch (token
->id_kind
)
532 gcc_assert (c_dialect_objc ());
538 switch (token
->keyword
)
577 if (c_dialect_objc ())
585 /* Return true if the next token from PARSER can start declaration
586 specifiers, false otherwise. */
588 c_parser_next_token_starts_declspecs (c_parser
*parser
)
590 c_token
*token
= c_parser_peek_token (parser
);
591 return c_token_starts_declspecs (token
);
594 /* Return a pointer to the next-but-one token from PARSER, reading it
595 in if necessary. The next token is already read in. */
598 c_parser_peek_2nd_token (c_parser
*parser
)
600 if (parser
->tokens_avail
>= 2)
601 return &parser
->tokens
[1];
602 gcc_assert (parser
->tokens_avail
== 1);
603 gcc_assert (parser
->tokens
[0].type
!= CPP_EOF
);
604 gcc_assert (parser
->tokens
[0].type
!= CPP_PRAGMA_EOL
);
605 c_lex_one_token (parser
, &parser
->tokens
[1]);
606 parser
->tokens_avail
= 2;
607 return &parser
->tokens
[1];
610 /* Consume the next token from PARSER. */
613 c_parser_consume_token (c_parser
*parser
)
615 gcc_assert (parser
->tokens_avail
>= 1);
616 gcc_assert (parser
->tokens
[0].type
!= CPP_EOF
);
617 gcc_assert (!parser
->in_pragma
|| parser
->tokens
[0].type
!= CPP_PRAGMA_EOL
);
618 gcc_assert (parser
->error
|| parser
->tokens
[0].type
!= CPP_PRAGMA
);
619 if (parser
->tokens_avail
== 2)
620 parser
->tokens
[0] = parser
->tokens
[1];
621 parser
->tokens_avail
--;
624 /* Expect the current token to be a #pragma. Consume it and remember
625 that we've begun parsing a pragma. */
628 c_parser_consume_pragma (c_parser
*parser
)
630 gcc_assert (!parser
->in_pragma
);
631 gcc_assert (parser
->tokens_avail
>= 1);
632 gcc_assert (parser
->tokens
[0].type
== CPP_PRAGMA
);
633 if (parser
->tokens_avail
== 2)
634 parser
->tokens
[0] = parser
->tokens
[1];
635 parser
->tokens_avail
--;
636 parser
->in_pragma
= true;
639 /* Update the globals input_location and in_system_header from
642 c_parser_set_source_position_from_token (c_token
*token
)
644 if (token
->type
!= CPP_EOF
)
646 input_location
= token
->location
;
647 in_system_header
= token
->in_system_header
;
651 /* Issue a diagnostic of the form
652 FILE:LINE: MESSAGE before TOKEN
653 where TOKEN is the next token in the input stream of PARSER.
654 MESSAGE (specified by the caller) is usually of the form "expected
657 Do not issue a diagnostic if still recovering from an error.
659 ??? This is taken from the C++ parser, but building up messages in
660 this way is not i18n-friendly and some other approach should be
664 c_parser_error (c_parser
*parser
, const char *gmsgid
)
666 c_token
*token
= c_parser_peek_token (parser
);
669 parser
->error
= true;
672 /* This diagnostic makes more sense if it is tagged to the line of
673 the token we just peeked at. */
674 c_parser_set_source_position_from_token (token
);
675 c_parse_error (gmsgid
,
676 /* Because c_parse_error does not understand
677 CPP_KEYWORD, keywords are treated like
679 (token
->type
== CPP_KEYWORD
? CPP_NAME
: token
->type
),
683 /* If the next token is of the indicated TYPE, consume it. Otherwise,
684 issue the error MSGID. If MSGID is NULL then a message has already
685 been produced and no message will be produced this time. Returns
686 true if found, false otherwise. */
689 c_parser_require (c_parser
*parser
,
693 if (c_parser_next_token_is (parser
, type
))
695 c_parser_consume_token (parser
);
700 c_parser_error (parser
, msgid
);
705 /* If the next token is the indicated keyword, consume it. Otherwise,
706 issue the error MSGID. Returns true if found, false otherwise. */
709 c_parser_require_keyword (c_parser
*parser
,
713 if (c_parser_next_token_is_keyword (parser
, keyword
))
715 c_parser_consume_token (parser
);
720 c_parser_error (parser
, msgid
);
725 /* Like c_parser_require, except that tokens will be skipped until the
726 desired token is found. An error message is still produced if the
727 next token is not as expected. If MSGID is NULL then a message has
728 already been produced and no message will be produced this
732 c_parser_skip_until_found (c_parser
*parser
,
736 unsigned nesting_depth
= 0;
738 if (c_parser_require (parser
, type
, msgid
))
741 /* Skip tokens until the desired token is found. */
744 /* Peek at the next token. */
745 c_token
*token
= c_parser_peek_token (parser
);
746 /* If we've reached the token we want, consume it and stop. */
747 if (token
->type
== type
&& !nesting_depth
)
749 c_parser_consume_token (parser
);
753 /* If we've run out of tokens, stop. */
754 if (token
->type
== CPP_EOF
)
756 if (token
->type
== CPP_PRAGMA_EOL
&& parser
->in_pragma
)
758 if (token
->type
== CPP_OPEN_BRACE
759 || token
->type
== CPP_OPEN_PAREN
760 || token
->type
== CPP_OPEN_SQUARE
)
762 else if (token
->type
== CPP_CLOSE_BRACE
763 || token
->type
== CPP_CLOSE_PAREN
764 || token
->type
== CPP_CLOSE_SQUARE
)
766 if (nesting_depth
-- == 0)
769 /* Consume this token. */
770 c_parser_consume_token (parser
);
772 parser
->error
= false;
775 /* Skip tokens until the end of a parameter is found, but do not
776 consume the comma, semicolon or closing delimiter. */
779 c_parser_skip_to_end_of_parameter (c_parser
*parser
)
781 unsigned nesting_depth
= 0;
785 c_token
*token
= c_parser_peek_token (parser
);
786 if ((token
->type
== CPP_COMMA
|| token
->type
== CPP_SEMICOLON
)
789 /* If we've run out of tokens, stop. */
790 if (token
->type
== CPP_EOF
)
792 if (token
->type
== CPP_PRAGMA_EOL
&& parser
->in_pragma
)
794 if (token
->type
== CPP_OPEN_BRACE
795 || token
->type
== CPP_OPEN_PAREN
796 || token
->type
== CPP_OPEN_SQUARE
)
798 else if (token
->type
== CPP_CLOSE_BRACE
799 || token
->type
== CPP_CLOSE_PAREN
800 || token
->type
== CPP_CLOSE_SQUARE
)
802 if (nesting_depth
-- == 0)
805 /* Consume this token. */
806 c_parser_consume_token (parser
);
808 parser
->error
= false;
811 /* Expect to be at the end of the pragma directive and consume an
812 end of line marker. */
815 c_parser_skip_to_pragma_eol (c_parser
*parser
)
817 gcc_assert (parser
->in_pragma
);
818 parser
->in_pragma
= false;
820 if (!c_parser_require (parser
, CPP_PRAGMA_EOL
, "expected end of line"))
823 c_token
*token
= c_parser_peek_token (parser
);
824 if (token
->type
== CPP_EOF
)
826 if (token
->type
== CPP_PRAGMA_EOL
)
828 c_parser_consume_token (parser
);
831 c_parser_consume_token (parser
);
834 parser
->error
= false;
837 /* Skip tokens until we have consumed an entire block, or until we
838 have consumed a non-nested ';'. */
841 c_parser_skip_to_end_of_block_or_statement (c_parser
*parser
)
843 unsigned nesting_depth
= 0;
844 bool save_error
= parser
->error
;
850 /* Peek at the next token. */
851 token
= c_parser_peek_token (parser
);
859 if (parser
->in_pragma
)
864 /* If the next token is a ';', we have reached the
865 end of the statement. */
868 /* Consume the ';'. */
869 c_parser_consume_token (parser
);
874 case CPP_CLOSE_BRACE
:
875 /* If the next token is a non-nested '}', then we have
876 reached the end of the current block. */
877 if (nesting_depth
== 0 || --nesting_depth
== 0)
879 c_parser_consume_token (parser
);
885 /* If it the next token is a '{', then we are entering a new
886 block. Consume the entire block. */
891 /* If we see a pragma, consume the whole thing at once. We
892 have some safeguards against consuming pragmas willy-nilly.
893 Normally, we'd expect to be here with parser->error set,
894 which disables these safeguards. But it's possible to get
895 here for secondary error recovery, after parser->error has
897 c_parser_consume_pragma (parser
);
898 c_parser_skip_to_pragma_eol (parser
);
899 parser
->error
= save_error
;
906 c_parser_consume_token (parser
);
910 parser
->error
= false;
913 /* Save the warning flags which are controlled by __extension__. */
916 disable_extension_diagnostics (void)
919 | (warn_pointer_arith
<< 1)
920 | (warn_traditional
<< 2)
923 warn_pointer_arith
= 0;
924 warn_traditional
= 0;
929 /* Restore the warning flags which are controlled by __extension__.
930 FLAGS is the return value from disable_extension_diagnostics. */
933 restore_extension_diagnostics (int flags
)
935 pedantic
= flags
& 1;
936 warn_pointer_arith
= (flags
>> 1) & 1;
937 warn_traditional
= (flags
>> 2) & 1;
938 flag_iso
= (flags
>> 3) & 1;
941 /* Possibly kinds of declarator to parse. */
942 typedef enum c_dtr_syn
{
943 /* A normal declarator with an identifier. */
945 /* An abstract declarator (maybe empty). */
947 /* A parameter declarator: may be either, but after a type name does
948 not redeclare a typedef name as an identifier if it can
949 alternatively be interpreted as a typedef name; see DR#009,
950 applied in C90 TC1, omitted from C99 and reapplied in C99 TC2
951 following DR#249. For example, given a typedef T, "int T" and
952 "int *T" are valid parameter declarations redeclaring T, while
953 "int (T)" and "int * (T)" and "int (T[])" and "int (T (int))" are
954 abstract declarators rather than involving redundant parentheses;
955 the same applies with attributes inside the parentheses before
960 static void c_parser_external_declaration (c_parser
*);
961 static void c_parser_asm_definition (c_parser
*);
962 static void c_parser_declaration_or_fndef (c_parser
*, bool, bool, bool, bool);
963 static void c_parser_declspecs (c_parser
*, struct c_declspecs
*, bool, bool,
965 static struct c_typespec
c_parser_enum_specifier (c_parser
*);
966 static struct c_typespec
c_parser_struct_or_union_specifier (c_parser
*);
967 static tree
c_parser_struct_declaration (c_parser
*);
968 static struct c_typespec
c_parser_typeof_specifier (c_parser
*);
969 static struct c_declarator
*c_parser_declarator (c_parser
*, bool, c_dtr_syn
,
971 static struct c_declarator
*c_parser_direct_declarator (c_parser
*, bool,
973 static struct c_declarator
*c_parser_direct_declarator_inner (c_parser
*,
975 struct c_declarator
*);
976 static struct c_arg_info
*c_parser_parms_declarator (c_parser
*, bool, tree
);
977 static struct c_arg_info
*c_parser_parms_list_declarator (c_parser
*, tree
);
978 static struct c_parm
*c_parser_parameter_declaration (c_parser
*, tree
);
979 static tree
c_parser_simple_asm_expr (c_parser
*);
980 static tree
c_parser_attributes (c_parser
*);
981 static struct c_type_name
*c_parser_type_name (c_parser
*);
982 static struct c_expr
c_parser_initializer (c_parser
*);
983 static struct c_expr
c_parser_braced_init (c_parser
*, tree
, bool);
984 static void c_parser_initelt (c_parser
*);
985 static void c_parser_initval (c_parser
*, struct c_expr
*);
986 static tree
c_parser_compound_statement (c_parser
*);
987 static void c_parser_compound_statement_nostart (c_parser
*);
988 static void c_parser_label (c_parser
*);
989 static void c_parser_statement (c_parser
*);
990 static void c_parser_statement_after_labels (c_parser
*);
991 static void c_parser_if_statement (c_parser
*);
992 static void c_parser_switch_statement (c_parser
*);
993 static void c_parser_while_statement (c_parser
*);
994 static void c_parser_do_statement (c_parser
*);
995 static void c_parser_for_statement (c_parser
*);
996 static tree
c_parser_asm_statement (c_parser
*);
997 static tree
c_parser_asm_operands (c_parser
*, bool);
998 static tree
c_parser_asm_clobbers (c_parser
*);
999 static struct c_expr
c_parser_expr_no_commas (c_parser
*, struct c_expr
*);
1000 static struct c_expr
c_parser_conditional_expression (c_parser
*,
1002 static struct c_expr
c_parser_binary_expression (c_parser
*, struct c_expr
*);
1003 static struct c_expr
c_parser_cast_expression (c_parser
*, struct c_expr
*);
1004 static struct c_expr
c_parser_unary_expression (c_parser
*);
1005 static struct c_expr
c_parser_sizeof_expression (c_parser
*);
1006 static struct c_expr
c_parser_alignof_expression (c_parser
*);
1007 static struct c_expr
c_parser_postfix_expression (c_parser
*);
1008 static struct c_expr
c_parser_postfix_expression_after_paren_type (c_parser
*,
1009 struct c_type_name
*);
1010 static struct c_expr
c_parser_postfix_expression_after_primary (c_parser
*,
1012 static struct c_expr
c_parser_expression (c_parser
*);
1013 static struct c_expr
c_parser_expression_conv (c_parser
*);
1014 static tree
c_parser_expr_list (c_parser
*, bool);
1015 static void c_parser_omp_construct (c_parser
*);
1016 static void c_parser_omp_threadprivate (c_parser
*);
1017 static void c_parser_omp_barrier (c_parser
*);
1018 static void c_parser_omp_flush (c_parser
*);
1020 enum pragma_context
{ pragma_external
, pragma_stmt
, pragma_compound
};
1021 static bool c_parser_pragma (c_parser
*, enum pragma_context
);
1023 /* These Objective-C parser functions are only ever called when
1024 compiling Objective-C. */
1025 static void c_parser_objc_class_definition (c_parser
*);
1026 static void c_parser_objc_class_instance_variables (c_parser
*);
1027 static void c_parser_objc_class_declaration (c_parser
*);
1028 static void c_parser_objc_alias_declaration (c_parser
*);
1029 static void c_parser_objc_protocol_definition (c_parser
*);
1030 static enum tree_code
c_parser_objc_method_type (c_parser
*);
1031 static void c_parser_objc_method_definition (c_parser
*);
1032 static void c_parser_objc_methodprotolist (c_parser
*);
1033 static void c_parser_objc_methodproto (c_parser
*);
1034 static tree
c_parser_objc_method_decl (c_parser
*);
1035 static tree
c_parser_objc_type_name (c_parser
*);
1036 static tree
c_parser_objc_protocol_refs (c_parser
*);
1037 static void c_parser_objc_try_catch_statement (c_parser
*);
1038 static void c_parser_objc_synchronized_statement (c_parser
*);
1039 static tree
c_parser_objc_selector (c_parser
*);
1040 static tree
c_parser_objc_selector_arg (c_parser
*);
1041 static tree
c_parser_objc_receiver (c_parser
*);
1042 static tree
c_parser_objc_message_args (c_parser
*);
1043 static tree
c_parser_objc_keywordexpr (c_parser
*);
1045 /* Parse a translation unit (C90 6.7, C99 6.9).
1048 external-declarations
1050 external-declarations:
1051 external-declaration
1052 external-declarations external-declaration
1061 c_parser_translation_unit (c_parser
*parser
)
1063 if (c_parser_next_token_is (parser
, CPP_EOF
))
1066 pedwarn ("ISO C forbids an empty source file");
1070 void *obstack_position
= obstack_alloc (&parser_obstack
, 0);
1074 c_parser_external_declaration (parser
);
1075 obstack_free (&parser_obstack
, obstack_position
);
1077 while (c_parser_next_token_is_not (parser
, CPP_EOF
));
1081 /* Parse an external declaration (C90 6.7, C99 6.9).
1083 external-declaration:
1089 external-declaration:
1092 __extension__ external-declaration
1096 external-declaration:
1097 objc-class-definition
1098 objc-class-declaration
1099 objc-alias-declaration
1100 objc-protocol-definition
1101 objc-method-definition
1106 c_parser_external_declaration (c_parser
*parser
)
1109 switch (c_parser_peek_token (parser
)->type
)
1112 switch (c_parser_peek_token (parser
)->keyword
)
1115 ext
= disable_extension_diagnostics ();
1116 c_parser_consume_token (parser
);
1117 c_parser_external_declaration (parser
);
1118 restore_extension_diagnostics (ext
);
1121 c_parser_asm_definition (parser
);
1123 case RID_AT_INTERFACE
:
1124 case RID_AT_IMPLEMENTATION
:
1125 gcc_assert (c_dialect_objc ());
1126 c_parser_objc_class_definition (parser
);
1129 gcc_assert (c_dialect_objc ());
1130 c_parser_objc_class_declaration (parser
);
1133 gcc_assert (c_dialect_objc ());
1134 c_parser_objc_alias_declaration (parser
);
1136 case RID_AT_PROTOCOL
:
1137 gcc_assert (c_dialect_objc ());
1138 c_parser_objc_protocol_definition (parser
);
1141 gcc_assert (c_dialect_objc ());
1142 c_parser_consume_token (parser
);
1143 objc_finish_implementation ();
1151 pedwarn ("ISO C does not allow extra %<;%> outside of a function");
1152 c_parser_consume_token (parser
);
1155 c_parser_pragma (parser
, pragma_external
);
1159 if (c_dialect_objc ())
1161 c_parser_objc_method_definition (parser
);
1164 /* Else fall through, and yield a syntax error trying to parse
1165 as a declaration or function definition. */
1168 /* A declaration or a function definition. We can only tell
1169 which after parsing the declaration specifiers, if any, and
1170 the first declarator. */
1171 c_parser_declaration_or_fndef (parser
, true, true, false, true);
1177 /* Parse a declaration or function definition (C90 6.5, 6.7.1, C99
1178 6.7, 6.9.1). If FNDEF_OK is true, a function definition is
1179 accepted; otherwise (old-style parameter declarations) only other
1180 declarations are accepted. If NESTED is true, we are inside a
1181 function or parsing old-style parameter declarations; any functions
1182 encountered are nested functions and declaration specifiers are
1183 required; otherwise we are at top level and functions are normal
1184 functions and declaration specifiers may be optional. If EMPTY_OK
1185 is true, empty declarations are OK (subject to all other
1186 constraints); otherwise (old-style parameter declarations) they are
1187 diagnosed. If START_ATTR_OK is true, the declaration specifiers
1188 may start with attributes; otherwise they may not.
1191 declaration-specifiers init-declarator-list[opt] ;
1193 function-definition:
1194 declaration-specifiers[opt] declarator declaration-list[opt]
1199 declaration-list declaration
1201 init-declarator-list:
1203 init-declarator-list , init-declarator
1206 declarator simple-asm-expr[opt] attributes[opt]
1207 declarator simple-asm-expr[opt] attributes[opt] = initializer
1211 nested-function-definition:
1212 declaration-specifiers declarator declaration-list[opt]
1215 The simple-asm-expr and attributes are GNU extensions.
1217 This function does not handle __extension__; that is handled in its
1218 callers. ??? Following the old parser, __extension__ may start
1219 external declarations, declarations in functions and declarations
1220 at the start of "for" loops, but not old-style parameter
1223 C99 requires declaration specifiers in a function definition; the
1224 absence is diagnosed through the diagnosis of implicit int. In GNU
1225 C we also allow but diagnose declarations without declaration
1226 specifiers, but only at top level (elsewhere they conflict with
1232 threadprivate-directive */
1235 c_parser_declaration_or_fndef (c_parser
*parser
, bool fndef_ok
, bool empty_ok
,
1236 bool nested
, bool start_attr_ok
)
1238 struct c_declspecs
*specs
;
1240 tree all_prefix_attrs
;
1241 bool diagnosed_no_specs
= false;
1243 specs
= build_null_declspecs ();
1244 c_parser_declspecs (parser
, specs
, true, true, start_attr_ok
);
1247 c_parser_skip_to_end_of_block_or_statement (parser
);
1250 if (nested
&& !specs
->declspecs_seen_p
)
1252 c_parser_error (parser
, "expected declaration specifiers");
1253 c_parser_skip_to_end_of_block_or_statement (parser
);
1256 finish_declspecs (specs
);
1257 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
1263 shadow_tag_warned (specs
, 1);
1264 pedwarn ("empty declaration");
1266 c_parser_consume_token (parser
);
1269 pending_xref_error ();
1270 prefix_attrs
= specs
->attrs
;
1271 all_prefix_attrs
= prefix_attrs
;
1272 specs
->attrs
= NULL_TREE
;
1275 struct c_declarator
*declarator
;
1278 /* Declaring either one or more declarators (in which case we
1279 should diagnose if there were no declaration specifiers) or a
1280 function definition (in which case the diagnostic for
1281 implicit int suffices). */
1282 declarator
= c_parser_declarator (parser
, specs
->type_seen_p
,
1283 C_DTR_NORMAL
, &dummy
);
1284 if (declarator
== NULL
)
1286 c_parser_skip_to_end_of_block_or_statement (parser
);
1289 if (c_parser_next_token_is (parser
, CPP_EQ
)
1290 || c_parser_next_token_is (parser
, CPP_COMMA
)
1291 || c_parser_next_token_is (parser
, CPP_SEMICOLON
)
1292 || c_parser_next_token_is_keyword (parser
, RID_ASM
)
1293 || c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
1295 tree asm_name
= NULL_TREE
;
1296 tree postfix_attrs
= NULL_TREE
;
1297 if (!diagnosed_no_specs
&& !specs
->declspecs_seen_p
)
1299 diagnosed_no_specs
= true;
1300 pedwarn ("data definition has no type or storage class");
1302 /* Having seen a data definition, there cannot now be a
1303 function definition. */
1305 if (c_parser_next_token_is_keyword (parser
, RID_ASM
))
1306 asm_name
= c_parser_simple_asm_expr (parser
);
1307 if (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
1308 postfix_attrs
= c_parser_attributes (parser
);
1309 if (c_parser_next_token_is (parser
, CPP_EQ
))
1313 c_parser_consume_token (parser
);
1314 /* The declaration of the variable is in effect while
1315 its initializer is parsed. */
1316 d
= start_decl (declarator
, specs
, true,
1317 chainon (postfix_attrs
, all_prefix_attrs
));
1319 d
= error_mark_node
;
1320 start_init (d
, asm_name
, global_bindings_p ());
1321 init
= c_parser_initializer (parser
);
1323 if (d
!= error_mark_node
)
1325 maybe_warn_string_init (TREE_TYPE (d
), init
);
1326 finish_decl (d
, init
.value
, asm_name
);
1331 tree d
= start_decl (declarator
, specs
, false,
1332 chainon (postfix_attrs
,
1335 finish_decl (d
, NULL_TREE
, asm_name
);
1337 if (c_parser_next_token_is (parser
, CPP_COMMA
))
1339 c_parser_consume_token (parser
);
1340 if (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
1341 all_prefix_attrs
= chainon (c_parser_attributes (parser
),
1344 all_prefix_attrs
= prefix_attrs
;
1347 else if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
1349 c_parser_consume_token (parser
);
1354 c_parser_error (parser
, "expected %<,%> or %<;%>");
1355 c_parser_skip_to_end_of_block_or_statement (parser
);
1361 c_parser_error (parser
, "expected %<=%>, %<,%>, %<;%>, "
1362 "%<asm%> or %<__attribute__%>");
1363 c_parser_skip_to_end_of_block_or_statement (parser
);
1366 /* Function definition (nested or otherwise). */
1370 pedwarn ("ISO C forbids nested functions");
1371 push_function_context ();
1373 if (!start_function (specs
, declarator
, all_prefix_attrs
))
1375 /* This can appear in many cases looking nothing like a
1376 function definition, so we don't give a more specific
1377 error suggesting there was one. */
1378 c_parser_error (parser
, "expected %<=%>, %<,%>, %<;%>, %<asm%> "
1379 "or %<__attribute__%>");
1381 pop_function_context ();
1384 /* Parse old-style parameter declarations. ??? Attributes are
1385 not allowed to start declaration specifiers here because of a
1386 syntax conflict between a function declaration with attribute
1387 suffix and a function definition with an attribute prefix on
1388 first old-style parameter declaration. Following the old
1389 parser, they are not accepted on subsequent old-style
1390 parameter declarations either. However, there is no
1391 ambiguity after the first declaration, nor indeed on the
1392 first as long as we don't allow postfix attributes after a
1393 declarator with a nonempty identifier list in a definition;
1394 and postfix attributes have never been accepted here in
1395 function definitions either. */
1396 while (c_parser_next_token_is_not (parser
, CPP_EOF
)
1397 && c_parser_next_token_is_not (parser
, CPP_OPEN_BRACE
))
1398 c_parser_declaration_or_fndef (parser
, false, false, true, false);
1399 DECL_SOURCE_LOCATION (current_function_decl
)
1400 = c_parser_peek_token (parser
)->location
;
1401 store_parm_decls ();
1402 fnbody
= c_parser_compound_statement (parser
);
1405 tree decl
= current_function_decl
;
1408 pop_function_context ();
1409 add_stmt (build_stmt (DECL_EXPR
, decl
));
1420 /* Parse an asm-definition (asm() outside a function body). This is a
1428 c_parser_asm_definition (c_parser
*parser
)
1430 tree asm_str
= c_parser_simple_asm_expr (parser
);
1432 cgraph_add_asm_node (asm_str
);
1433 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
1436 /* Parse some declaration specifiers (possibly none) (C90 6.5, C99
1437 6.7), adding them to SPECS (which may already include some).
1438 Storage class specifiers are accepted iff SCSPEC_OK; type
1439 specifiers are accepted iff TYPESPEC_OK; attributes are accepted at
1440 the start iff START_ATTR_OK.
1442 declaration-specifiers:
1443 storage-class-specifier declaration-specifiers[opt]
1444 type-specifier declaration-specifiers[opt]
1445 type-qualifier declaration-specifiers[opt]
1446 function-specifier declaration-specifiers[opt]
1448 Function specifiers (inline) are from C99, and are currently
1449 handled as storage class specifiers, as is __thread.
1451 C90 6.5.1, C99 6.7.1:
1452 storage-class-specifier:
1463 C90 6.5.2, C99 6.7.2:
1476 [_Imaginary removed in C99 TC2]
1477 struct-or-union-specifier
1481 (_Bool and _Complex are new in C99.)
1483 C90 6.5.3, C99 6.7.3:
1490 (restrict is new in C99.)
1494 declaration-specifiers:
1495 attributes declaration-specifiers[opt]
1497 storage-class-specifier:
1509 (_Fract, _Accum, and _Sat are new from ISO/IEC DTR 18037:
1510 http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1169.pdf)
1515 class-name objc-protocol-refs[opt]
1516 typedef-name objc-protocol-refs
1521 c_parser_declspecs (c_parser
*parser
, struct c_declspecs
*specs
,
1522 bool scspec_ok
, bool typespec_ok
, bool start_attr_ok
)
1524 bool attrs_ok
= start_attr_ok
;
1525 bool seen_type
= specs
->type_seen_p
;
1526 while (c_parser_next_token_is (parser
, CPP_NAME
)
1527 || c_parser_next_token_is (parser
, CPP_KEYWORD
)
1528 || (c_dialect_objc () && c_parser_next_token_is (parser
, CPP_LESS
)))
1530 struct c_typespec t
;
1532 if (c_parser_next_token_is (parser
, CPP_NAME
))
1534 tree value
= c_parser_peek_token (parser
)->value
;
1535 c_id_kind kind
= c_parser_peek_token (parser
)->id_kind
;
1536 /* This finishes the specifiers unless a type name is OK, it
1537 is declared as a type name and a type name hasn't yet
1539 if (!typespec_ok
|| seen_type
1540 || (kind
!= C_ID_TYPENAME
&& kind
!= C_ID_CLASSNAME
))
1542 c_parser_consume_token (parser
);
1545 if (kind
== C_ID_TYPENAME
1546 && (!c_dialect_objc ()
1547 || c_parser_next_token_is_not (parser
, CPP_LESS
)))
1549 t
.kind
= ctsk_typedef
;
1550 /* For a typedef name, record the meaning, not the name.
1551 In case of 'foo foo, bar;'. */
1552 t
.spec
= lookup_name (value
);
1556 tree proto
= NULL_TREE
;
1557 gcc_assert (c_dialect_objc ());
1559 if (c_parser_next_token_is (parser
, CPP_LESS
))
1560 proto
= c_parser_objc_protocol_refs (parser
);
1561 t
.spec
= objc_get_protocol_qualified_type (value
, proto
);
1563 declspecs_add_type (specs
, t
);
1566 if (c_parser_next_token_is (parser
, CPP_LESS
))
1568 /* Make "<SomeProtocol>" equivalent to "id <SomeProtocol>" -
1569 nisse@lysator.liu.se. */
1571 gcc_assert (c_dialect_objc ());
1572 if (!typespec_ok
|| seen_type
)
1574 proto
= c_parser_objc_protocol_refs (parser
);
1576 t
.spec
= objc_get_protocol_qualified_type (NULL_TREE
, proto
);
1577 declspecs_add_type (specs
, t
);
1580 gcc_assert (c_parser_next_token_is (parser
, CPP_KEYWORD
));
1581 switch (c_parser_peek_token (parser
)->keyword
)
1593 /* TODO: Distinguish between function specifiers (inline)
1594 and storage class specifiers, either here or in
1595 declspecs_add_scspec. */
1596 declspecs_add_scspec (specs
, c_parser_peek_token (parser
)->value
);
1597 c_parser_consume_token (parser
);
1620 if (c_dialect_objc ())
1621 parser
->objc_need_raw_identifier
= true;
1622 t
.kind
= ctsk_resword
;
1623 t
.spec
= c_parser_peek_token (parser
)->value
;
1624 declspecs_add_type (specs
, t
);
1625 c_parser_consume_token (parser
);
1632 t
= c_parser_enum_specifier (parser
);
1633 declspecs_add_type (specs
, t
);
1641 t
= c_parser_struct_or_union_specifier (parser
);
1642 declspecs_add_type (specs
, t
);
1645 /* ??? The old parser rejected typeof after other type
1646 specifiers, but is a syntax error the best way of
1648 if (!typespec_ok
|| seen_type
)
1652 t
= c_parser_typeof_specifier (parser
);
1653 declspecs_add_type (specs
, t
);
1659 declspecs_add_qual (specs
, c_parser_peek_token (parser
)->value
);
1660 c_parser_consume_token (parser
);
1665 attrs
= c_parser_attributes (parser
);
1666 declspecs_add_attrs (specs
, attrs
);
1675 /* Parse an enum specifier (C90 6.5.2.2, C99 6.7.2.2).
1678 enum attributes[opt] identifier[opt] { enumerator-list } attributes[opt]
1679 enum attributes[opt] identifier[opt] { enumerator-list , } attributes[opt]
1680 enum attributes[opt] identifier
1682 The form with trailing comma is new in C99. The forms with
1683 attributes are GNU extensions. In GNU C, we accept any expression
1684 without commas in the syntax (assignment expressions, not just
1685 conditional expressions); assignment expressions will be diagnosed
1690 enumerator-list , enumerator
1693 enumeration-constant
1694 enumeration-constant = constant-expression
1697 static struct c_typespec
1698 c_parser_enum_specifier (c_parser
*parser
)
1700 struct c_typespec ret
;
1702 tree ident
= NULL_TREE
;
1703 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_ENUM
));
1704 c_parser_consume_token (parser
);
1705 attrs
= c_parser_attributes (parser
);
1706 if (c_parser_next_token_is (parser
, CPP_NAME
))
1708 ident
= c_parser_peek_token (parser
)->value
;
1709 c_parser_consume_token (parser
);
1711 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
1713 /* Parse an enum definition. */
1714 struct c_enum_contents the_enum
;
1715 tree type
= start_enum (&the_enum
, ident
);
1717 /* We chain the enumerators in reverse order, then put them in
1718 forward order at the end. */
1719 tree values
= NULL_TREE
;
1720 c_parser_consume_token (parser
);
1727 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
1729 c_parser_error (parser
, "expected identifier");
1730 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
, NULL
);
1731 values
= error_mark_node
;
1734 enum_id
= c_parser_peek_token (parser
)->value
;
1735 c_parser_consume_token (parser
);
1736 if (c_parser_next_token_is (parser
, CPP_EQ
))
1738 c_parser_consume_token (parser
);
1739 enum_value
= c_parser_expr_no_commas (parser
, NULL
).value
;
1742 enum_value
= NULL_TREE
;
1743 enum_decl
= build_enumerator (&the_enum
, enum_id
, enum_value
);
1744 TREE_CHAIN (enum_decl
) = values
;
1747 if (c_parser_next_token_is (parser
, CPP_COMMA
))
1750 c_parser_consume_token (parser
);
1752 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
1754 if (seen_comma
&& pedantic
&& !flag_isoc99
)
1755 pedwarn ("comma at end of enumerator list");
1756 c_parser_consume_token (parser
);
1761 c_parser_error (parser
, "expected %<,%> or %<}%>");
1762 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
, NULL
);
1763 values
= error_mark_node
;
1767 postfix_attrs
= c_parser_attributes (parser
);
1768 ret
.spec
= finish_enum (type
, nreverse (values
),
1769 chainon (attrs
, postfix_attrs
));
1770 ret
.kind
= ctsk_tagdef
;
1775 c_parser_error (parser
, "expected %<{%>");
1776 ret
.spec
= error_mark_node
;
1777 ret
.kind
= ctsk_tagref
;
1780 ret
= parser_xref_tag (ENUMERAL_TYPE
, ident
);
1781 /* In ISO C, enumerated types can be referred to only if already
1783 if (pedantic
&& !COMPLETE_TYPE_P (ret
.spec
))
1784 pedwarn ("ISO C forbids forward references to %<enum%> types");
1788 /* Parse a struct or union specifier (C90 6.5.2.1, C99 6.7.2.1).
1790 struct-or-union-specifier:
1791 struct-or-union attributes[opt] identifier[opt]
1792 { struct-contents } attributes[opt]
1793 struct-or-union attributes[opt] identifier
1796 struct-declaration-list
1798 struct-declaration-list:
1799 struct-declaration ;
1800 struct-declaration-list struct-declaration ;
1807 struct-declaration-list struct-declaration
1809 struct-declaration-list:
1810 struct-declaration-list ;
1813 (Note that in the syntax here, unlike that in ISO C, the semicolons
1814 are included here rather than in struct-declaration, in order to
1815 describe the syntax with extra semicolons and missing semicolon at
1820 struct-declaration-list:
1821 @defs ( class-name )
1823 (Note this does not include a trailing semicolon, but can be
1824 followed by further declarations, and gets a pedwarn-if-pedantic
1825 when followed by a semicolon.) */
1827 static struct c_typespec
1828 c_parser_struct_or_union_specifier (c_parser
*parser
)
1830 struct c_typespec ret
;
1832 tree ident
= NULL_TREE
;
1833 enum tree_code code
;
1834 switch (c_parser_peek_token (parser
)->keyword
)
1845 c_parser_consume_token (parser
);
1846 attrs
= c_parser_attributes (parser
);
1847 if (c_parser_next_token_is (parser
, CPP_NAME
))
1849 ident
= c_parser_peek_token (parser
)->value
;
1850 c_parser_consume_token (parser
);
1852 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
1854 /* Parse a struct or union definition. Start the scope of the
1855 tag before parsing components. */
1856 tree type
= start_struct (code
, ident
);
1858 /* We chain the components in reverse order, then put them in
1859 forward order at the end. Each struct-declaration may
1860 declare multiple components (comma-separated), so we must use
1861 chainon to join them, although when parsing each
1862 struct-declaration we can use TREE_CHAIN directly.
1864 The theory behind all this is that there will be more
1865 semicolon separated fields than comma separated fields, and
1866 so we'll be minimizing the number of node traversals required
1868 tree contents
= NULL_TREE
;
1869 c_parser_consume_token (parser
);
1870 /* Handle the Objective-C @defs construct,
1871 e.g. foo(sizeof(struct{ @defs(ClassName) }));. */
1872 if (c_parser_next_token_is_keyword (parser
, RID_AT_DEFS
))
1875 gcc_assert (c_dialect_objc ());
1876 c_parser_consume_token (parser
);
1877 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1879 if (c_parser_next_token_is (parser
, CPP_NAME
)
1880 && c_parser_peek_token (parser
)->id_kind
== C_ID_CLASSNAME
)
1882 name
= c_parser_peek_token (parser
)->value
;
1883 c_parser_consume_token (parser
);
1887 c_parser_error (parser
, "expected class name");
1888 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
1891 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
1893 contents
= nreverse (objc_get_class_ivars (name
));
1896 /* Parse the struct-declarations and semicolons. Problems with
1897 semicolons are diagnosed here; empty structures are diagnosed
1902 /* Parse any stray semicolon. */
1903 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
1906 pedwarn ("extra semicolon in struct or union specified");
1907 c_parser_consume_token (parser
);
1910 /* Stop if at the end of the struct or union contents. */
1911 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
1913 c_parser_consume_token (parser
);
1916 /* Accept #pragmas at struct scope. */
1917 if (c_parser_next_token_is (parser
, CPP_PRAGMA
))
1919 c_parser_pragma (parser
, pragma_external
);
1922 /* Parse some comma-separated declarations, but not the
1923 trailing semicolon if any. */
1924 decls
= c_parser_struct_declaration (parser
);
1925 contents
= chainon (decls
, contents
);
1926 /* If no semicolon follows, either we have a parse error or
1927 are at the end of the struct or union and should
1929 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
1930 c_parser_consume_token (parser
);
1933 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
1934 pedwarn ("no semicolon at end of struct or union");
1937 c_parser_error (parser
, "expected %<;%>");
1938 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
, NULL
);
1943 postfix_attrs
= c_parser_attributes (parser
);
1944 ret
.spec
= finish_struct (type
, nreverse (contents
),
1945 chainon (attrs
, postfix_attrs
));
1946 ret
.kind
= ctsk_tagdef
;
1951 c_parser_error (parser
, "expected %<{%>");
1952 ret
.spec
= error_mark_node
;
1953 ret
.kind
= ctsk_tagref
;
1956 ret
= parser_xref_tag (code
, ident
);
1960 /* Parse a struct-declaration (C90 6.5.2.1, C99 6.7.2.1), *without*
1961 the trailing semicolon.
1964 specifier-qualifier-list struct-declarator-list
1966 specifier-qualifier-list:
1967 type-specifier specifier-qualifier-list[opt]
1968 type-qualifier specifier-qualifier-list[opt]
1969 attributes specifier-qualifier-list[opt]
1971 struct-declarator-list:
1973 struct-declarator-list , attributes[opt] struct-declarator
1976 declarator attributes[opt]
1977 declarator[opt] : constant-expression attributes[opt]
1982 __extension__ struct-declaration
1983 specifier-qualifier-list
1985 Unlike the ISO C syntax, semicolons are handled elsewhere. The use
1986 of attributes where shown is a GNU extension. In GNU C, we accept
1987 any expression without commas in the syntax (assignment
1988 expressions, not just conditional expressions); assignment
1989 expressions will be diagnosed as non-constant. */
1992 c_parser_struct_declaration (c_parser
*parser
)
1994 struct c_declspecs
*specs
;
1996 tree all_prefix_attrs
;
1998 if (c_parser_next_token_is_keyword (parser
, RID_EXTENSION
))
2002 ext
= disable_extension_diagnostics ();
2003 c_parser_consume_token (parser
);
2004 decl
= c_parser_struct_declaration (parser
);
2005 restore_extension_diagnostics (ext
);
2008 specs
= build_null_declspecs ();
2009 c_parser_declspecs (parser
, specs
, false, true, true);
2012 if (!specs
->declspecs_seen_p
)
2014 c_parser_error (parser
, "expected specifier-qualifier-list");
2017 finish_declspecs (specs
);
2018 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
2021 if (!specs
->type_seen_p
)
2024 pedwarn ("ISO C forbids member declarations with no members");
2025 shadow_tag_warned (specs
, pedantic
);
2030 /* Support for unnamed structs or unions as members of
2031 structs or unions (which is [a] useful and [b] supports
2033 ret
= grokfield (build_id_declarator (NULL_TREE
), specs
, NULL_TREE
);
2037 pending_xref_error ();
2038 prefix_attrs
= specs
->attrs
;
2039 all_prefix_attrs
= prefix_attrs
;
2040 specs
->attrs
= NULL_TREE
;
2044 /* Declaring one or more declarators or un-named bit-fields. */
2045 struct c_declarator
*declarator
;
2047 if (c_parser_next_token_is (parser
, CPP_COLON
))
2048 declarator
= build_id_declarator (NULL_TREE
);
2050 declarator
= c_parser_declarator (parser
, specs
->type_seen_p
,
2051 C_DTR_NORMAL
, &dummy
);
2052 if (declarator
== NULL
)
2054 c_parser_skip_to_end_of_block_or_statement (parser
);
2057 if (c_parser_next_token_is (parser
, CPP_COLON
)
2058 || c_parser_next_token_is (parser
, CPP_COMMA
)
2059 || c_parser_next_token_is (parser
, CPP_SEMICOLON
)
2060 || c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
)
2061 || c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
2063 tree postfix_attrs
= NULL_TREE
;
2064 tree width
= NULL_TREE
;
2066 if (c_parser_next_token_is (parser
, CPP_COLON
))
2068 c_parser_consume_token (parser
);
2069 width
= c_parser_expr_no_commas (parser
, NULL
).value
;
2071 if (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
2072 postfix_attrs
= c_parser_attributes (parser
);
2073 d
= grokfield (declarator
, specs
, width
);
2074 decl_attributes (&d
, chainon (postfix_attrs
,
2075 all_prefix_attrs
), 0);
2076 TREE_CHAIN (d
) = decls
;
2078 if (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
2079 all_prefix_attrs
= chainon (c_parser_attributes (parser
),
2082 all_prefix_attrs
= prefix_attrs
;
2083 if (c_parser_next_token_is (parser
, CPP_COMMA
))
2084 c_parser_consume_token (parser
);
2085 else if (c_parser_next_token_is (parser
, CPP_SEMICOLON
)
2086 || c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
2088 /* Semicolon consumed in caller. */
2093 c_parser_error (parser
, "expected %<,%>, %<;%> or %<}%>");
2099 c_parser_error (parser
,
2100 "expected %<:%>, %<,%>, %<;%>, %<}%> or "
2101 "%<__attribute__%>");
2108 /* Parse a typeof specifier (a GNU extension).
2111 typeof ( expression )
2112 typeof ( type-name )
2115 static struct c_typespec
2116 c_parser_typeof_specifier (c_parser
*parser
)
2118 struct c_typespec ret
;
2119 ret
.kind
= ctsk_typeof
;
2120 ret
.spec
= error_mark_node
;
2121 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_TYPEOF
));
2122 c_parser_consume_token (parser
);
2125 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
2131 if (c_parser_next_token_starts_typename (parser
))
2133 struct c_type_name
*type
= c_parser_type_name (parser
);
2138 ret
.spec
= groktypename (type
);
2139 pop_maybe_used (variably_modified_type_p (ret
.spec
, NULL_TREE
));
2145 struct c_expr expr
= c_parser_expression (parser
);
2148 if (TREE_CODE (expr
.value
) == COMPONENT_REF
2149 && DECL_C_BIT_FIELD (TREE_OPERAND (expr
.value
, 1)))
2150 error ("%<typeof%> applied to a bit-field");
2151 ret
.spec
= TREE_TYPE (expr
.value
);
2152 was_vm
= variably_modified_type_p (ret
.spec
, NULL_TREE
);
2153 /* This should be returned with the type so that when the type
2154 is evaluated, this can be evaluated. For now, we avoid
2155 evaluation when the context might. */
2156 if (!skip_evaluation
&& was_vm
)
2158 tree e
= expr
.value
;
2160 /* If the expression is not of a type to which we cannot assign a line
2161 number, wrap the thing in a no-op NOP_EXPR. */
2162 if (DECL_P (e
) || CONSTANT_CLASS_P (e
))
2163 e
= build1 (NOP_EXPR
, void_type_node
, e
);
2165 if (CAN_HAVE_LOCATION_P (e
))
2166 SET_EXPR_LOCATION (e
, input_location
);
2170 pop_maybe_used (was_vm
);
2172 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
2176 /* Parse a declarator, possibly an abstract declarator (C90 6.5.4,
2177 6.5.5, C99 6.7.5, 6.7.6). If TYPE_SEEN_P then a typedef name may
2178 be redeclared; otherwise it may not. KIND indicates which kind of
2179 declarator is wanted. Returns a valid declarator except in the
2180 case of a syntax error in which case NULL is returned. *SEEN_ID is
2181 set to true if an identifier being declared is seen; this is used
2182 to diagnose bad forms of abstract array declarators and to
2183 determine whether an identifier list is syntactically permitted.
2186 pointer[opt] direct-declarator
2190 ( attributes[opt] declarator )
2191 direct-declarator array-declarator
2192 direct-declarator ( parameter-type-list )
2193 direct-declarator ( identifier-list[opt] )
2196 * type-qualifier-list[opt]
2197 * type-qualifier-list[opt] pointer
2199 type-qualifier-list:
2202 type-qualifier-list type-qualifier
2203 type-qualifier-list attributes
2205 parameter-type-list:
2207 parameter-list , ...
2210 parameter-declaration
2211 parameter-list , parameter-declaration
2213 parameter-declaration:
2214 declaration-specifiers declarator attributes[opt]
2215 declaration-specifiers abstract-declarator[opt] attributes[opt]
2219 identifier-list , identifier
2221 abstract-declarator:
2223 pointer[opt] direct-abstract-declarator
2225 direct-abstract-declarator:
2226 ( attributes[opt] abstract-declarator )
2227 direct-abstract-declarator[opt] array-declarator
2228 direct-abstract-declarator[opt] ( parameter-type-list[opt] )
2233 direct-declarator ( parameter-forward-declarations
2234 parameter-type-list[opt] )
2236 direct-abstract-declarator:
2237 direct-abstract-declarator[opt] ( parameter-forward-declarations
2238 parameter-type-list[opt] )
2240 parameter-forward-declarations:
2242 parameter-forward-declarations parameter-list ;
2244 The uses of attributes shown above are GNU extensions.
2246 Some forms of array declarator are not included in C99 in the
2247 syntax for abstract declarators; these are disallowed elsewhere.
2248 This may be a defect (DR#289).
2250 This function also accepts an omitted abstract declarator as being
2251 an abstract declarator, although not part of the formal syntax. */
2253 static struct c_declarator
*
2254 c_parser_declarator (c_parser
*parser
, bool type_seen_p
, c_dtr_syn kind
,
2257 /* Parse any initial pointer part. */
2258 if (c_parser_next_token_is (parser
, CPP_MULT
))
2260 struct c_declspecs
*quals_attrs
= build_null_declspecs ();
2261 struct c_declarator
*inner
;
2262 c_parser_consume_token (parser
);
2263 c_parser_declspecs (parser
, quals_attrs
, false, false, true);
2264 inner
= c_parser_declarator (parser
, type_seen_p
, kind
, seen_id
);
2268 return make_pointer_declarator (quals_attrs
, inner
);
2270 /* Now we have a direct declarator, direct abstract declarator or
2271 nothing (which counts as a direct abstract declarator here). */
2272 return c_parser_direct_declarator (parser
, type_seen_p
, kind
, seen_id
);
2275 /* Parse a direct declarator or direct abstract declarator; arguments
2276 as c_parser_declarator. */
2278 static struct c_declarator
*
2279 c_parser_direct_declarator (c_parser
*parser
, bool type_seen_p
, c_dtr_syn kind
,
2282 /* The direct declarator must start with an identifier (possibly
2283 omitted) or a parenthesized declarator (possibly abstract). In
2284 an ordinary declarator, initial parentheses must start a
2285 parenthesized declarator. In an abstract declarator or parameter
2286 declarator, they could start a parenthesized declarator or a
2287 parameter list. To tell which, the open parenthesis and any
2288 following attributes must be read. If a declaration specifier
2289 follows, then it is a parameter list; if the specifier is a
2290 typedef name, there might be an ambiguity about redeclaring it,
2291 which is resolved in the direction of treating it as a typedef
2292 name. If a close parenthesis follows, it is also an empty
2293 parameter list, as the syntax does not permit empty abstract
2294 declarators. Otherwise, it is a parenthesized declarator (in
2295 which case the analysis may be repeated inside it, recursively).
2297 ??? There is an ambiguity in a parameter declaration "int
2298 (__attribute__((foo)) x)", where x is not a typedef name: it
2299 could be an abstract declarator for a function, or declare x with
2300 parentheses. The proper resolution of this ambiguity needs
2301 documenting. At present we follow an accident of the old
2302 parser's implementation, whereby the first parameter must have
2303 some declaration specifiers other than just attributes. Thus as
2304 a parameter declaration it is treated as a parenthesized
2305 parameter named x, and as an abstract declarator it is
2308 ??? Also following the old parser, attributes inside an empty
2309 parameter list are ignored, making it a list not yielding a
2310 prototype, rather than giving an error or making it have one
2311 parameter with implicit type int.
2313 ??? Also following the old parser, typedef names may be
2314 redeclared in declarators, but not Objective-C class names. */
2316 if (kind
!= C_DTR_ABSTRACT
2317 && c_parser_next_token_is (parser
, CPP_NAME
)
2319 && c_parser_peek_token (parser
)->id_kind
== C_ID_TYPENAME
)
2320 || c_parser_peek_token (parser
)->id_kind
== C_ID_ID
))
2322 struct c_declarator
*inner
2323 = build_id_declarator (c_parser_peek_token (parser
)->value
);
2325 inner
->id_loc
= c_parser_peek_token (parser
)->location
;
2326 c_parser_consume_token (parser
);
2327 return c_parser_direct_declarator_inner (parser
, *seen_id
, inner
);
2330 if (kind
!= C_DTR_NORMAL
2331 && c_parser_next_token_is (parser
, CPP_OPEN_SQUARE
))
2333 struct c_declarator
*inner
= build_id_declarator (NULL_TREE
);
2334 return c_parser_direct_declarator_inner (parser
, *seen_id
, inner
);
2337 /* Either we are at the end of an abstract declarator, or we have
2340 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
2343 struct c_declarator
*inner
;
2344 c_parser_consume_token (parser
);
2345 attrs
= c_parser_attributes (parser
);
2346 if (kind
!= C_DTR_NORMAL
2347 && (c_parser_next_token_starts_declspecs (parser
)
2348 || c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
)))
2350 struct c_arg_info
*args
2351 = c_parser_parms_declarator (parser
, kind
== C_DTR_NORMAL
,
2358 = build_function_declarator (args
,
2359 build_id_declarator (NULL_TREE
));
2360 return c_parser_direct_declarator_inner (parser
, *seen_id
,
2364 /* A parenthesized declarator. */
2365 inner
= c_parser_declarator (parser
, type_seen_p
, kind
, seen_id
);
2366 if (inner
!= NULL
&& attrs
!= NULL
)
2367 inner
= build_attrs_declarator (attrs
, inner
);
2368 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2370 c_parser_consume_token (parser
);
2374 return c_parser_direct_declarator_inner (parser
, *seen_id
, inner
);
2378 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
2385 if (kind
== C_DTR_NORMAL
)
2387 c_parser_error (parser
, "expected identifier or %<(%>");
2391 return build_id_declarator (NULL_TREE
);
2395 /* Parse part of a direct declarator or direct abstract declarator,
2396 given that some (in INNER) has already been parsed; ID_PRESENT is
2397 true if an identifier is present, false for an abstract
2400 static struct c_declarator
*
2401 c_parser_direct_declarator_inner (c_parser
*parser
, bool id_present
,
2402 struct c_declarator
*inner
)
2404 /* Parse a sequence of array declarators and parameter lists. */
2405 if (c_parser_next_token_is (parser
, CPP_OPEN_SQUARE
))
2407 struct c_declarator
*declarator
;
2408 struct c_declspecs
*quals_attrs
= build_null_declspecs ();
2412 c_parser_consume_token (parser
);
2413 c_parser_declspecs (parser
, quals_attrs
, false, false, true);
2414 static_seen
= c_parser_next_token_is_keyword (parser
, RID_STATIC
);
2416 c_parser_consume_token (parser
);
2417 if (static_seen
&& !quals_attrs
->declspecs_seen_p
)
2418 c_parser_declspecs (parser
, quals_attrs
, false, false, true);
2419 if (!quals_attrs
->declspecs_seen_p
)
2421 /* If "static" is present, there must be an array dimension.
2422 Otherwise, there may be a dimension, "*", or no
2427 dimen
= c_parser_expr_no_commas (parser
, NULL
).value
;
2431 if (c_parser_next_token_is (parser
, CPP_CLOSE_SQUARE
))
2436 else if (c_parser_next_token_is (parser
, CPP_MULT
))
2438 if (c_parser_peek_2nd_token (parser
)->type
== CPP_CLOSE_SQUARE
)
2442 c_parser_consume_token (parser
);
2447 dimen
= c_parser_expr_no_commas (parser
, NULL
).value
;
2453 dimen
= c_parser_expr_no_commas (parser
, NULL
).value
;
2456 if (c_parser_next_token_is (parser
, CPP_CLOSE_SQUARE
))
2457 c_parser_consume_token (parser
);
2460 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
2464 declarator
= build_array_declarator (dimen
, quals_attrs
, static_seen
,
2466 if (declarator
== NULL
)
2468 inner
= set_array_declarator_inner (declarator
, inner
, !id_present
);
2469 return c_parser_direct_declarator_inner (parser
, id_present
, inner
);
2471 else if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
2474 struct c_arg_info
*args
;
2475 c_parser_consume_token (parser
);
2476 attrs
= c_parser_attributes (parser
);
2477 args
= c_parser_parms_declarator (parser
, id_present
, attrs
);
2482 inner
= build_function_declarator (args
, inner
);
2483 return c_parser_direct_declarator_inner (parser
, id_present
, inner
);
2489 /* Parse a parameter list or identifier list, including the closing
2490 parenthesis but not the opening one. ATTRS are the attributes at
2491 the start of the list. ID_LIST_OK is true if an identifier list is
2492 acceptable; such a list must not have attributes at the start. */
2494 static struct c_arg_info
*
2495 c_parser_parms_declarator (c_parser
*parser
, bool id_list_ok
, tree attrs
)
2498 declare_parm_level ();
2499 /* If the list starts with an identifier, it is an identifier list.
2500 Otherwise, it is either a prototype list or an empty list. */
2503 && c_parser_next_token_is (parser
, CPP_NAME
)
2504 && c_parser_peek_token (parser
)->id_kind
== C_ID_ID
)
2506 tree list
= NULL_TREE
, *nextp
= &list
;
2507 while (c_parser_next_token_is (parser
, CPP_NAME
)
2508 && c_parser_peek_token (parser
)->id_kind
== C_ID_ID
)
2510 *nextp
= build_tree_list (NULL_TREE
,
2511 c_parser_peek_token (parser
)->value
);
2512 nextp
= & TREE_CHAIN (*nextp
);
2513 c_parser_consume_token (parser
);
2514 if (c_parser_next_token_is_not (parser
, CPP_COMMA
))
2516 c_parser_consume_token (parser
);
2517 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2519 c_parser_error (parser
, "expected identifier");
2523 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2525 struct c_arg_info
*ret
= XOBNEW (&parser_obstack
, struct c_arg_info
);
2530 ret
->pending_sizes
= 0;
2531 ret
->had_vla_unspec
= 0;
2532 c_parser_consume_token (parser
);
2538 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
2546 struct c_arg_info
*ret
= c_parser_parms_list_declarator (parser
, attrs
);
2552 /* Parse a parameter list (possibly empty), including the closing
2553 parenthesis but not the opening one. ATTRS are the attributes at
2554 the start of the list. */
2556 static struct c_arg_info
*
2557 c_parser_parms_list_declarator (c_parser
*parser
, tree attrs
)
2559 bool good_parm
= false;
2560 /* ??? Following the old parser, forward parameter declarations may
2561 use abstract declarators, and if no real parameter declarations
2562 follow the forward declarations then this is not diagnosed. Also
2563 note as above that attributes are ignored as the only contents of
2564 the parentheses, or as the only contents after forward
2566 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2568 struct c_arg_info
*ret
= XOBNEW (&parser_obstack
, struct c_arg_info
);
2573 ret
->pending_sizes
= 0;
2574 ret
->had_vla_unspec
= 0;
2575 c_parser_consume_token (parser
);
2578 if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
))
2580 struct c_arg_info
*ret
= XOBNEW (&parser_obstack
, struct c_arg_info
);
2584 ret
->pending_sizes
= 0;
2585 ret
->had_vla_unspec
= 0;
2586 /* Suppress -Wold-style-definition for this case. */
2587 ret
->types
= error_mark_node
;
2588 error ("ISO C requires a named argument before %<...%>");
2589 c_parser_consume_token (parser
);
2590 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2592 c_parser_consume_token (parser
);
2597 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
2602 /* Nonempty list of parameters, either terminated with semicolon
2603 (forward declarations; recurse) or with close parenthesis (normal
2604 function) or with ", ... )" (variadic function). */
2607 /* Parse a parameter. */
2608 struct c_parm
*parm
= c_parser_parameter_declaration (parser
, attrs
);
2613 push_parm_decl (parm
);
2615 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
2618 c_parser_consume_token (parser
);
2619 mark_forward_parm_decls ();
2620 new_attrs
= c_parser_attributes (parser
);
2621 return c_parser_parms_list_declarator (parser
, new_attrs
);
2623 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2625 c_parser_consume_token (parser
);
2627 return get_parm_info (false);
2630 struct c_arg_info
*ret
2631 = XOBNEW (&parser_obstack
, struct c_arg_info
);
2636 ret
->pending_sizes
= 0;
2637 ret
->had_vla_unspec
= 0;
2641 if (!c_parser_require (parser
, CPP_COMMA
,
2642 "expected %<;%>, %<,%> or %<)%>"))
2644 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
2647 if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
))
2649 c_parser_consume_token (parser
);
2650 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2652 c_parser_consume_token (parser
);
2654 return get_parm_info (true);
2657 struct c_arg_info
*ret
2658 = XOBNEW (&parser_obstack
, struct c_arg_info
);
2663 ret
->pending_sizes
= 0;
2664 ret
->had_vla_unspec
= 0;
2670 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
2678 /* Parse a parameter declaration. ATTRS are the attributes at the
2679 start of the declaration if it is the first parameter. */
2681 static struct c_parm
*
2682 c_parser_parameter_declaration (c_parser
*parser
, tree attrs
)
2684 struct c_declspecs
*specs
;
2685 struct c_declarator
*declarator
;
2687 tree postfix_attrs
= NULL_TREE
;
2689 if (!c_parser_next_token_starts_declspecs (parser
))
2691 /* ??? In some Objective-C cases '...' isn't applicable so there
2692 should be a different message. */
2693 c_parser_error (parser
,
2694 "expected declaration specifiers or %<...%>");
2695 c_parser_skip_to_end_of_parameter (parser
);
2698 specs
= build_null_declspecs ();
2701 declspecs_add_attrs (specs
, attrs
);
2704 c_parser_declspecs (parser
, specs
, true, true, true);
2705 finish_declspecs (specs
);
2706 pending_xref_error ();
2707 prefix_attrs
= specs
->attrs
;
2708 specs
->attrs
= NULL_TREE
;
2709 declarator
= c_parser_declarator (parser
, specs
->type_seen_p
,
2710 C_DTR_PARM
, &dummy
);
2711 if (declarator
== NULL
)
2713 c_parser_skip_until_found (parser
, CPP_COMMA
, NULL
);
2716 if (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
2717 postfix_attrs
= c_parser_attributes (parser
);
2718 return build_c_parm (specs
, chainon (postfix_attrs
, prefix_attrs
),
2722 /* Parse a string literal in an asm expression. It should not be
2723 translated, and wide string literals are an error although
2724 permitted by the syntax. This is a GNU extension.
2729 ??? At present, following the old parser, the caller needs to have
2730 set c_lex_string_translate to 0. It would be better to follow the
2731 C++ parser rather than using the c_lex_string_translate kludge. */
2734 c_parser_asm_string_literal (c_parser
*parser
)
2737 if (c_parser_next_token_is (parser
, CPP_STRING
))
2739 str
= c_parser_peek_token (parser
)->value
;
2740 c_parser_consume_token (parser
);
2742 else if (c_parser_next_token_is (parser
, CPP_WSTRING
))
2744 error ("wide string literal in %<asm%>");
2745 str
= build_string (1, "");
2746 c_parser_consume_token (parser
);
2750 c_parser_error (parser
, "expected string literal");
2756 /* Parse a simple asm expression. This is used in restricted
2757 contexts, where a full expression with inputs and outputs does not
2758 make sense. This is a GNU extension.
2761 asm ( asm-string-literal )
2765 c_parser_simple_asm_expr (c_parser
*parser
)
2768 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_ASM
));
2769 /* ??? Follow the C++ parser rather than using the
2770 c_lex_string_translate kludge. */
2771 c_lex_string_translate
= 0;
2772 c_parser_consume_token (parser
);
2773 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
2775 c_lex_string_translate
= 1;
2778 str
= c_parser_asm_string_literal (parser
);
2779 c_lex_string_translate
= 1;
2780 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
2782 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
2788 /* Parse (possibly empty) attributes. This is a GNU extension.
2792 attributes attribute
2795 __attribute__ ( ( attribute-list ) )
2799 attribute_list , attrib
2804 any-word ( identifier )
2805 any-word ( identifier , nonempty-expr-list )
2806 any-word ( expr-list )
2808 where the "identifier" must not be declared as a type, and
2809 "any-word" may be any identifier (including one declared as a
2810 type), a reserved word storage class specifier, type specifier or
2811 type qualifier. ??? This still leaves out most reserved keywords
2812 (following the old parser), shouldn't we include them, and why not
2813 allow identifiers declared as types to start the arguments? */
2816 c_parser_attributes (c_parser
*parser
)
2818 tree attrs
= NULL_TREE
;
2819 while (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
2821 /* ??? Follow the C++ parser rather than using the
2822 c_lex_string_translate kludge. */
2823 c_lex_string_translate
= 0;
2824 c_parser_consume_token (parser
);
2825 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
2827 c_lex_string_translate
= 1;
2830 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
2832 c_lex_string_translate
= 1;
2833 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
2836 /* Parse the attribute list. */
2837 while (c_parser_next_token_is (parser
, CPP_COMMA
)
2838 || c_parser_next_token_is (parser
, CPP_NAME
)
2839 || c_parser_next_token_is (parser
, CPP_KEYWORD
))
2841 tree attr
, attr_name
, attr_args
;
2842 if (c_parser_next_token_is (parser
, CPP_COMMA
))
2844 c_parser_consume_token (parser
);
2847 if (c_parser_next_token_is (parser
, CPP_KEYWORD
))
2849 /* ??? See comment above about what keywords are
2852 switch (c_parser_peek_token (parser
)->keyword
)
2890 attr_name
= c_parser_peek_token (parser
)->value
;
2891 c_parser_consume_token (parser
);
2892 if (c_parser_next_token_is_not (parser
, CPP_OPEN_PAREN
))
2894 attr
= build_tree_list (attr_name
, NULL_TREE
);
2895 attrs
= chainon (attrs
, attr
);
2898 c_parser_consume_token (parser
);
2899 /* Parse the attribute contents. If they start with an
2900 identifier which is followed by a comma or close
2901 parenthesis, then the arguments start with that
2902 identifier; otherwise they are an expression list. */
2903 if (c_parser_next_token_is (parser
, CPP_NAME
)
2904 && c_parser_peek_token (parser
)->id_kind
== C_ID_ID
2905 && ((c_parser_peek_2nd_token (parser
)->type
== CPP_COMMA
)
2906 || (c_parser_peek_2nd_token (parser
)->type
2907 == CPP_CLOSE_PAREN
)))
2909 tree arg1
= c_parser_peek_token (parser
)->value
;
2910 c_parser_consume_token (parser
);
2911 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2912 attr_args
= build_tree_list (NULL_TREE
, arg1
);
2915 c_parser_consume_token (parser
);
2916 attr_args
= tree_cons (NULL_TREE
, arg1
,
2917 c_parser_expr_list (parser
, false));
2922 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2923 attr_args
= NULL_TREE
;
2925 attr_args
= c_parser_expr_list (parser
, false);
2927 attr
= build_tree_list (attr_name
, attr_args
);
2928 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2929 c_parser_consume_token (parser
);
2932 c_lex_string_translate
= 1;
2933 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
2937 attrs
= chainon (attrs
, attr
);
2939 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2940 c_parser_consume_token (parser
);
2943 c_lex_string_translate
= 1;
2944 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
2948 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2949 c_parser_consume_token (parser
);
2952 c_lex_string_translate
= 1;
2953 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
2957 c_lex_string_translate
= 1;
2962 /* Parse a type name (C90 6.5.5, C99 6.7.6).
2965 specifier-qualifier-list abstract-declarator[opt]
2968 static struct c_type_name
*
2969 c_parser_type_name (c_parser
*parser
)
2971 struct c_declspecs
*specs
= build_null_declspecs ();
2972 struct c_declarator
*declarator
;
2973 struct c_type_name
*ret
;
2975 c_parser_declspecs (parser
, specs
, false, true, true);
2976 if (!specs
->declspecs_seen_p
)
2978 c_parser_error (parser
, "expected specifier-qualifier-list");
2981 pending_xref_error ();
2982 finish_declspecs (specs
);
2983 declarator
= c_parser_declarator (parser
, specs
->type_seen_p
,
2984 C_DTR_ABSTRACT
, &dummy
);
2985 if (declarator
== NULL
)
2987 ret
= XOBNEW (&parser_obstack
, struct c_type_name
);
2989 ret
->declarator
= declarator
;
2993 /* Parse an initializer (C90 6.5.7, C99 6.7.8).
2996 assignment-expression
2997 { initializer-list }
2998 { initializer-list , }
3001 designation[opt] initializer
3002 initializer-list , designation[opt] initializer
3009 designator-list designator
3016 [ constant-expression ]
3028 [ constant-expression ... constant-expression ]
3030 Any expression without commas is accepted in the syntax for the
3031 constant-expressions, with non-constant expressions rejected later.
3033 This function is only used for top-level initializers; for nested
3034 ones, see c_parser_initval. */
3036 static struct c_expr
3037 c_parser_initializer (c_parser
*parser
)
3039 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
3040 return c_parser_braced_init (parser
, NULL_TREE
, false);
3044 ret
= c_parser_expr_no_commas (parser
, NULL
);
3045 if (TREE_CODE (ret
.value
) != STRING_CST
3046 && TREE_CODE (ret
.value
) != COMPOUND_LITERAL_EXPR
)
3047 ret
= default_function_array_conversion (ret
);
3052 /* Parse a braced initializer list. TYPE is the type specified for a
3053 compound literal, and NULL_TREE for other initializers and for
3054 nested braced lists. NESTED_P is true for nested braced lists,
3055 false for the list of a compound literal or the list that is the
3056 top-level initializer in a declaration. */
3058 static struct c_expr
3059 c_parser_braced_init (c_parser
*parser
, tree type
, bool nested_p
)
3061 gcc_assert (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
));
3062 c_parser_consume_token (parser
);
3064 push_init_level (0);
3066 really_start_incremental_init (type
);
3067 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
3070 pedwarn ("ISO C forbids empty initializer braces");
3074 /* Parse a non-empty initializer list, possibly with a trailing
3078 c_parser_initelt (parser
);
3081 if (c_parser_next_token_is (parser
, CPP_COMMA
))
3082 c_parser_consume_token (parser
);
3085 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
3089 if (c_parser_next_token_is_not (parser
, CPP_CLOSE_BRACE
))
3092 ret
.value
= error_mark_node
;
3093 ret
.original_code
= ERROR_MARK
;
3094 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
, "expected %<}%>");
3097 c_parser_consume_token (parser
);
3098 return pop_init_level (0);
3101 /* Parse a nested initializer, including designators. */
3104 c_parser_initelt (c_parser
*parser
)
3106 /* Parse any designator or designator list. A single array
3107 designator may have the subsequent "=" omitted in GNU C, but a
3108 longer list or a structure member designator may not. */
3109 if (c_parser_next_token_is (parser
, CPP_NAME
)
3110 && c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
)
3112 /* Old-style structure member designator. */
3113 set_init_label (c_parser_peek_token (parser
)->value
);
3115 pedwarn ("obsolete use of designated initializer with %<:%>");
3116 c_parser_consume_token (parser
);
3117 c_parser_consume_token (parser
);
3121 /* des_seen is 0 if there have been no designators, 1 if there
3122 has been a single array designator and 2 otherwise. */
3124 while (c_parser_next_token_is (parser
, CPP_OPEN_SQUARE
)
3125 || c_parser_next_token_is (parser
, CPP_DOT
))
3127 int des_prev
= des_seen
;
3130 if (c_parser_next_token_is (parser
, CPP_DOT
))
3133 c_parser_consume_token (parser
);
3134 if (c_parser_next_token_is (parser
, CPP_NAME
))
3136 set_init_label (c_parser_peek_token (parser
)->value
);
3137 c_parser_consume_token (parser
);
3142 init
.value
= error_mark_node
;
3143 init
.original_code
= ERROR_MARK
;
3144 c_parser_error (parser
, "expected identifier");
3145 c_parser_skip_until_found (parser
, CPP_COMMA
, NULL
);
3146 process_init_element (init
);
3153 /* ??? Following the old parser, [ objc-receiver
3154 objc-message-args ] is accepted as an initializer,
3155 being distinguished from a designator by what follows
3156 the first assignment expression inside the square
3157 brackets, but after a first array designator a
3158 subsequent square bracket is for Objective-C taken to
3159 start an expression, using the obsolete form of
3160 designated initializer without '=', rather than
3161 possibly being a second level of designation: in LALR
3162 terms, the '[' is shifted rather than reducing
3163 designator to designator-list. */
3164 if (des_prev
== 1 && c_dialect_objc ())
3166 des_seen
= des_prev
;
3169 if (des_prev
== 0 && c_dialect_objc ())
3171 /* This might be an array designator or an
3172 Objective-C message expression. If the former,
3173 continue parsing here; if the latter, parse the
3174 remainder of the initializer given the starting
3175 primary-expression. ??? It might make sense to
3176 distinguish when des_prev == 1 as well; see
3177 previous comment. */
3179 struct c_expr mexpr
;
3180 c_parser_consume_token (parser
);
3181 if (c_parser_peek_token (parser
)->type
== CPP_NAME
3182 && ((c_parser_peek_token (parser
)->id_kind
3184 || (c_parser_peek_token (parser
)->id_kind
3185 == C_ID_CLASSNAME
)))
3187 /* Type name receiver. */
3188 tree id
= c_parser_peek_token (parser
)->value
;
3189 c_parser_consume_token (parser
);
3190 rec
= objc_get_class_reference (id
);
3191 goto parse_message_args
;
3193 first
= c_parser_expr_no_commas (parser
, NULL
).value
;
3194 if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
)
3195 || c_parser_next_token_is (parser
, CPP_CLOSE_SQUARE
))
3196 goto array_desig_after_first
;
3197 /* Expression receiver. So far only one part
3198 without commas has been parsed; there might be
3199 more of the expression. */
3201 while (c_parser_next_token_is (parser
, CPP_COMMA
))
3204 c_parser_consume_token (parser
);
3205 next
= c_parser_expr_no_commas (parser
, NULL
);
3206 next
= default_function_array_conversion (next
);
3207 rec
= build_compound_expr (rec
, next
.value
);
3210 /* Now parse the objc-message-args. */
3211 args
= c_parser_objc_message_args (parser
);
3212 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
3215 = objc_build_message_expr (build_tree_list (rec
, args
));
3216 mexpr
.original_code
= ERROR_MARK
;
3217 /* Now parse and process the remainder of the
3218 initializer, starting with this message
3219 expression as a primary-expression. */
3220 c_parser_initval (parser
, &mexpr
);
3223 c_parser_consume_token (parser
);
3224 first
= c_parser_expr_no_commas (parser
, NULL
).value
;
3225 array_desig_after_first
:
3226 if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
))
3228 c_parser_consume_token (parser
);
3229 second
= c_parser_expr_no_commas (parser
, NULL
).value
;
3233 if (c_parser_next_token_is (parser
, CPP_CLOSE_SQUARE
))
3235 c_parser_consume_token (parser
);
3236 set_init_index (first
, second
);
3237 if (pedantic
&& second
)
3238 pedwarn ("ISO C forbids specifying range of "
3239 "elements to initialize");
3242 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
3248 if (c_parser_next_token_is (parser
, CPP_EQ
))
3250 if (pedantic
&& !flag_isoc99
)
3251 pedwarn ("ISO C90 forbids specifying subobject to initialize");
3252 c_parser_consume_token (parser
);
3259 pedwarn ("obsolete use of designated initializer "
3265 init
.value
= error_mark_node
;
3266 init
.original_code
= ERROR_MARK
;
3267 c_parser_error (parser
, "expected %<=%>");
3268 c_parser_skip_until_found (parser
, CPP_COMMA
, NULL
);
3269 process_init_element (init
);
3275 c_parser_initval (parser
, NULL
);
3278 /* Parse a nested initializer; as c_parser_initializer but parses
3279 initializers within braced lists, after any designators have been
3280 applied. If AFTER is not NULL then it is an Objective-C message
3281 expression which is the primary-expression starting the
3285 c_parser_initval (c_parser
*parser
, struct c_expr
*after
)
3288 gcc_assert (!after
|| c_dialect_objc ());
3289 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
) && !after
)
3290 init
= c_parser_braced_init (parser
, NULL_TREE
, true);
3293 init
= c_parser_expr_no_commas (parser
, after
);
3294 if (init
.value
!= NULL_TREE
3295 && TREE_CODE (init
.value
) != STRING_CST
3296 && TREE_CODE (init
.value
) != COMPOUND_LITERAL_EXPR
)
3297 init
= default_function_array_conversion (init
);
3299 process_init_element (init
);
3302 /* Parse a compound statement (possibly a function body) (C90 6.6.2,
3306 { block-item-list[opt] }
3307 { label-declarations block-item-list }
3311 block-item-list block-item
3323 { label-declarations block-item-list }
3326 __extension__ nested-declaration
3327 nested-function-definition
3331 label-declarations label-declaration
3334 __label__ identifier-list ;
3336 Allowing the mixing of declarations and code is new in C99. The
3337 GNU syntax also permits (not shown above) labels at the end of
3338 compound statements, which yield an error. We don't allow labels
3339 on declarations; this might seem like a natural extension, but
3340 there would be a conflict between attributes on the label and
3341 prefix attributes on the declaration. ??? The syntax follows the
3342 old parser in requiring something after label declarations.
3343 Although they are erroneous if the labels declared aren't defined,
3344 is it useful for the syntax to be this way?
3356 c_parser_compound_statement (c_parser
*parser
)
3359 if (!c_parser_require (parser
, CPP_OPEN_BRACE
, "expected %<{%>"))
3360 return error_mark_node
;
3361 stmt
= c_begin_compound_stmt (true);
3362 c_parser_compound_statement_nostart (parser
);
3363 return c_end_compound_stmt (stmt
, true);
3366 /* Parse a compound statement except for the opening brace. This is
3367 used for parsing both compound statements and statement expressions
3368 (which follow different paths to handling the opening). */
3371 c_parser_compound_statement_nostart (c_parser
*parser
)
3373 bool last_stmt
= false;
3374 bool last_label
= false;
3375 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
3377 c_parser_consume_token (parser
);
3380 if (c_parser_next_token_is_keyword (parser
, RID_LABEL
))
3382 /* Read zero or more forward-declarations for labels that nested
3383 functions can jump to. */
3384 while (c_parser_next_token_is_keyword (parser
, RID_LABEL
))
3386 c_parser_consume_token (parser
);
3387 /* Any identifiers, including those declared as type names,
3392 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
3394 c_parser_error (parser
, "expected identifier");
3398 = declare_label (c_parser_peek_token (parser
)->value
);
3399 C_DECLARED_LABEL_FLAG (label
) = 1;
3400 add_stmt (build_stmt (DECL_EXPR
, label
));
3401 c_parser_consume_token (parser
);
3402 if (c_parser_next_token_is (parser
, CPP_COMMA
))
3403 c_parser_consume_token (parser
);
3407 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
3409 /* ??? Locating this diagnostic on the token after the
3410 declarations end follows the old parser, but it might be
3411 better to locate it where the declarations start instead. */
3413 pedwarn ("ISO C forbids label declarations");
3415 /* We must now have at least one statement, label or declaration. */
3416 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
3418 c_parser_error (parser
, "expected declaration or statement");
3419 c_parser_consume_token (parser
);
3422 while (c_parser_next_token_is_not (parser
, CPP_CLOSE_BRACE
))
3424 location_t loc
= c_parser_peek_token (parser
)->location
;
3425 if (c_parser_next_token_is_keyword (parser
, RID_CASE
)
3426 || c_parser_next_token_is_keyword (parser
, RID_DEFAULT
)
3427 || (c_parser_next_token_is (parser
, CPP_NAME
)
3428 && c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
))
3432 c_parser_label (parser
);
3434 else if (!last_label
3435 && c_parser_next_token_starts_declspecs (parser
))
3438 c_parser_declaration_or_fndef (parser
, true, true, true, true);
3440 && ((pedantic
&& !flag_isoc99
)
3441 || warn_declaration_after_statement
))
3442 pedwarn_c90 ("%HISO C90 forbids mixed declarations and code",
3446 else if (!last_label
3447 && c_parser_next_token_is_keyword (parser
, RID_EXTENSION
))
3449 /* __extension__ can start a declaration, but is also an
3450 unary operator that can start an expression. Consume all
3451 but the last of a possible series of __extension__ to
3453 while (c_parser_peek_2nd_token (parser
)->type
== CPP_KEYWORD
3454 && (c_parser_peek_2nd_token (parser
)->keyword
3456 c_parser_consume_token (parser
);
3457 if (c_token_starts_declspecs (c_parser_peek_2nd_token (parser
)))
3460 ext
= disable_extension_diagnostics ();
3461 c_parser_consume_token (parser
);
3463 c_parser_declaration_or_fndef (parser
, true, true, true, true);
3464 /* Following the old parser, __extension__ does not
3465 disable this diagnostic. */
3466 restore_extension_diagnostics (ext
);
3468 && ((pedantic
&& !flag_isoc99
)
3469 || warn_declaration_after_statement
))
3470 pedwarn_c90 ("%HISO C90 forbids mixed declarations and code",
3477 else if (c_parser_next_token_is (parser
, CPP_PRAGMA
))
3479 /* External pragmas, and some omp pragmas, are not associated
3480 with regular c code, and so are not to be considered statements
3481 syntactically. This ensures that the user doesn't put them
3482 places that would turn into syntax errors if the directive
3484 if (c_parser_pragma (parser
, pragma_compound
))
3485 last_label
= false, last_stmt
= true;
3487 else if (c_parser_next_token_is (parser
, CPP_EOF
))
3489 c_parser_error (parser
, "expected declaration or statement");
3497 c_parser_statement_after_labels (parser
);
3500 parser
->error
= false;
3503 error ("label at end of compound statement");
3504 c_parser_consume_token (parser
);
3507 /* Parse a label (C90 6.6.1, C99 6.8.1).
3510 identifier : attributes[opt]
3511 case constant-expression :
3517 case constant-expression ... constant-expression :
3519 The use of attributes on labels is a GNU extension. The syntax in
3520 GNU C accepts any expressions without commas, non-constant
3521 expressions being rejected later. */
3524 c_parser_label (c_parser
*parser
)
3526 location_t loc1
= c_parser_peek_token (parser
)->location
;
3527 tree label
= NULL_TREE
;
3528 if (c_parser_next_token_is_keyword (parser
, RID_CASE
))
3531 c_parser_consume_token (parser
);
3532 exp1
= c_parser_expr_no_commas (parser
, NULL
).value
;
3533 if (c_parser_next_token_is (parser
, CPP_COLON
))
3535 c_parser_consume_token (parser
);
3536 label
= do_case (exp1
, NULL_TREE
);
3538 else if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
))
3540 c_parser_consume_token (parser
);
3541 exp2
= c_parser_expr_no_commas (parser
, NULL
).value
;
3542 if (c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
3543 label
= do_case (exp1
, exp2
);
3546 c_parser_error (parser
, "expected %<:%> or %<...%>");
3548 else if (c_parser_next_token_is_keyword (parser
, RID_DEFAULT
))
3550 c_parser_consume_token (parser
);
3551 if (c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
3552 label
= do_case (NULL_TREE
, NULL_TREE
);
3556 tree name
= c_parser_peek_token (parser
)->value
;
3560 gcc_assert (c_parser_next_token_is (parser
, CPP_NAME
));
3561 c_parser_consume_token (parser
);
3562 gcc_assert (c_parser_next_token_is (parser
, CPP_COLON
));
3563 loc2
= c_parser_peek_token (parser
)->location
;
3564 c_parser_consume_token (parser
);
3565 attrs
= c_parser_attributes (parser
);
3566 tlab
= define_label (loc2
, name
);
3569 decl_attributes (&tlab
, attrs
, 0);
3570 label
= add_stmt (build_stmt (LABEL_EXPR
, tlab
));
3574 SET_EXPR_LOCATION (label
, loc1
);
3577 /* Parse a statement (C90 6.6, C99 6.8).
3582 expression-statement
3590 expression-statement:
3593 selection-statement:
3597 iteration-statement:
3606 return expression[opt] ;
3619 objc-throw-statement
3620 objc-try-catch-statement
3621 objc-synchronized-statement
3623 objc-throw-statement:
3637 parallel-for-construct
3638 parallel-sections-construct
3645 parallel-directive structured-block
3648 for-directive iteration-statement
3651 sections-directive section-scope
3654 single-directive structured-block
3656 parallel-for-construct:
3657 parallel-for-directive iteration-statement
3659 parallel-sections-construct:
3660 parallel-sections-directive section-scope
3663 master-directive structured-block
3666 critical-directive structured-block
3669 atomic-directive expression-statement
3672 ordered-directive structured-block */
3675 c_parser_statement (c_parser
*parser
)
3677 while (c_parser_next_token_is_keyword (parser
, RID_CASE
)
3678 || c_parser_next_token_is_keyword (parser
, RID_DEFAULT
)
3679 || (c_parser_next_token_is (parser
, CPP_NAME
)
3680 && c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
))
3681 c_parser_label (parser
);
3682 c_parser_statement_after_labels (parser
);
3685 /* Parse a statement, other than a labeled statement. */
3688 c_parser_statement_after_labels (c_parser
*parser
)
3690 location_t loc
= c_parser_peek_token (parser
)->location
;
3691 tree stmt
= NULL_TREE
;
3692 switch (c_parser_peek_token (parser
)->type
)
3694 case CPP_OPEN_BRACE
:
3695 add_stmt (c_parser_compound_statement (parser
));
3698 switch (c_parser_peek_token (parser
)->keyword
)
3701 c_parser_if_statement (parser
);
3704 c_parser_switch_statement (parser
);
3707 c_parser_while_statement (parser
);
3710 c_parser_do_statement (parser
);
3713 c_parser_for_statement (parser
);
3716 c_parser_consume_token (parser
);
3717 if (c_parser_next_token_is (parser
, CPP_NAME
))
3719 stmt
= c_finish_goto_label (c_parser_peek_token (parser
)->value
);
3720 c_parser_consume_token (parser
);
3722 else if (c_parser_next_token_is (parser
, CPP_MULT
))
3724 c_parser_consume_token (parser
);
3725 stmt
= c_finish_goto_ptr (c_parser_expression (parser
).value
);
3728 c_parser_error (parser
, "expected identifier or %<*%>");
3729 goto expect_semicolon
;
3731 c_parser_consume_token (parser
);
3732 stmt
= c_finish_bc_stmt (&c_cont_label
, false);
3733 goto expect_semicolon
;
3735 c_parser_consume_token (parser
);
3736 stmt
= c_finish_bc_stmt (&c_break_label
, true);
3737 goto expect_semicolon
;
3739 c_parser_consume_token (parser
);
3740 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
3742 stmt
= c_finish_return (NULL_TREE
);
3743 c_parser_consume_token (parser
);
3747 stmt
= c_finish_return (c_parser_expression_conv (parser
).value
);
3748 goto expect_semicolon
;
3752 stmt
= c_parser_asm_statement (parser
);
3755 gcc_assert (c_dialect_objc ());
3756 c_parser_consume_token (parser
);
3757 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
3759 stmt
= objc_build_throw_stmt (NULL_TREE
);
3760 c_parser_consume_token (parser
);
3765 = objc_build_throw_stmt (c_parser_expression (parser
).value
);
3766 goto expect_semicolon
;
3770 gcc_assert (c_dialect_objc ());
3771 c_parser_objc_try_catch_statement (parser
);
3773 case RID_AT_SYNCHRONIZED
:
3774 gcc_assert (c_dialect_objc ());
3775 c_parser_objc_synchronized_statement (parser
);
3782 c_parser_consume_token (parser
);
3784 case CPP_CLOSE_PAREN
:
3785 case CPP_CLOSE_SQUARE
:
3786 /* Avoid infinite loop in error recovery:
3787 c_parser_skip_until_found stops at a closing nesting
3788 delimiter without consuming it, but here we need to consume
3789 it to proceed further. */
3790 c_parser_error (parser
, "expected statement");
3791 c_parser_consume_token (parser
);
3794 c_parser_pragma (parser
, pragma_stmt
);
3798 stmt
= c_finish_expr_stmt (c_parser_expression_conv (parser
).value
);
3800 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
3803 /* Two cases cannot and do not have line numbers associated: If stmt
3804 is degenerate, such as "2;", then stmt is an INTEGER_CST, which
3805 cannot hold line numbers. But that's OK because the statement
3806 will either be changed to a MODIFY_EXPR during gimplification of
3807 the statement expr, or discarded. If stmt was compound, but
3808 without new variables, we will have skipped the creation of a
3809 BIND and will have a bare STATEMENT_LIST. But that's OK because
3810 (recursively) all of the component statements should already have
3811 line numbers assigned. ??? Can we discard no-op statements
3813 if (stmt
&& CAN_HAVE_LOCATION_P (stmt
))
3814 SET_EXPR_LOCATION (stmt
, loc
);
3817 /* Parse a parenthesized condition from an if, do or while statement.
3823 c_parser_paren_condition (c_parser
*parser
)
3827 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
3828 return error_mark_node
;
3829 loc
= c_parser_peek_token (parser
)->location
;
3830 cond
= c_objc_common_truthvalue_conversion
3831 (c_parser_expression_conv (parser
).value
);
3832 if (CAN_HAVE_LOCATION_P (cond
))
3833 SET_EXPR_LOCATION (cond
, loc
);
3834 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
3838 /* Parse a statement which is a block in C99. */
3841 c_parser_c99_block_statement (c_parser
*parser
)
3843 tree block
= c_begin_compound_stmt (flag_isoc99
);
3844 c_parser_statement (parser
);
3845 return c_end_compound_stmt (block
, flag_isoc99
);
3848 /* Parse the body of an if statement or the else half thereof. This
3849 is just parsing a statement but (a) it is a block in C99, (b) we
3850 track whether the body is an if statement for the sake of
3851 -Wparentheses warnings, (c) we handle an empty body specially for
3852 the sake of -Wempty-body warnings. */
3855 c_parser_if_body (c_parser
*parser
, bool *if_p
)
3857 tree block
= c_begin_compound_stmt (flag_isoc99
);
3858 while (c_parser_next_token_is_keyword (parser
, RID_CASE
)
3859 || c_parser_next_token_is_keyword (parser
, RID_DEFAULT
)
3860 || (c_parser_next_token_is (parser
, CPP_NAME
)
3861 && c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
))
3862 c_parser_label (parser
);
3863 *if_p
= c_parser_next_token_is_keyword (parser
, RID_IF
);
3864 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
3865 add_stmt (build_empty_stmt ());
3866 c_parser_statement_after_labels (parser
);
3867 return c_end_compound_stmt (block
, flag_isoc99
);
3870 /* Parse an if statement (C90 6.6.4, C99 6.8.4).
3873 if ( expression ) statement
3874 if ( expression ) statement else statement
3878 c_parser_if_statement (c_parser
*parser
)
3883 bool first_if
= false, second_if
= false;
3884 tree first_body
, second_body
;
3885 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_IF
));
3886 c_parser_consume_token (parser
);
3887 block
= c_begin_compound_stmt (flag_isoc99
);
3888 loc
= c_parser_peek_token (parser
)->location
;
3889 cond
= c_parser_paren_condition (parser
);
3890 first_body
= c_parser_if_body (parser
, &first_if
);
3891 if (c_parser_next_token_is_keyword (parser
, RID_ELSE
))
3893 c_parser_consume_token (parser
);
3894 second_body
= c_parser_if_body (parser
, &second_if
);
3897 second_body
= NULL_TREE
;
3898 c_finish_if_stmt (loc
, cond
, first_body
, second_body
, first_if
);
3899 add_stmt (c_end_compound_stmt (block
, flag_isoc99
));
3902 /* Parse a switch statement (C90 6.6.4, C99 6.8.4).
3905 switch (expression) statement
3909 c_parser_switch_statement (c_parser
*parser
)
3911 tree block
, expr
, body
, save_break
;
3912 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_SWITCH
));
3913 c_parser_consume_token (parser
);
3914 block
= c_begin_compound_stmt (flag_isoc99
);
3915 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
3917 expr
= c_parser_expression (parser
).value
;
3918 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
3921 expr
= error_mark_node
;
3922 c_start_case (expr
);
3923 save_break
= c_break_label
;
3924 c_break_label
= NULL_TREE
;
3925 body
= c_parser_c99_block_statement (parser
);
3926 c_finish_case (body
);
3928 add_stmt (build1 (LABEL_EXPR
, void_type_node
, c_break_label
));
3929 c_break_label
= save_break
;
3930 add_stmt (c_end_compound_stmt (block
, flag_isoc99
));
3933 /* Parse a while statement (C90 6.6.5, C99 6.8.5).
3936 while (expression) statement
3940 c_parser_while_statement (c_parser
*parser
)
3942 tree block
, cond
, body
, save_break
, save_cont
;
3944 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_WHILE
));
3945 c_parser_consume_token (parser
);
3946 block
= c_begin_compound_stmt (flag_isoc99
);
3947 loc
= c_parser_peek_token (parser
)->location
;
3948 cond
= c_parser_paren_condition (parser
);
3949 save_break
= c_break_label
;
3950 c_break_label
= NULL_TREE
;
3951 save_cont
= c_cont_label
;
3952 c_cont_label
= NULL_TREE
;
3953 body
= c_parser_c99_block_statement (parser
);
3954 c_finish_loop (loc
, cond
, NULL
, body
, c_break_label
, c_cont_label
, true);
3955 add_stmt (c_end_compound_stmt (block
, flag_isoc99
));
3956 c_break_label
= save_break
;
3957 c_cont_label
= save_cont
;
3960 /* Parse a do statement (C90 6.6.5, C99 6.8.5).
3963 do statement while ( expression ) ;
3967 c_parser_do_statement (c_parser
*parser
)
3969 tree block
, cond
, body
, save_break
, save_cont
, new_break
, new_cont
;
3971 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_DO
));
3972 c_parser_consume_token (parser
);
3973 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
3974 warning (OPT_Wempty_body
,
3975 "suggest braces around empty body in %<do%> statement");
3976 block
= c_begin_compound_stmt (flag_isoc99
);
3977 loc
= c_parser_peek_token (parser
)->location
;
3978 save_break
= c_break_label
;
3979 c_break_label
= NULL_TREE
;
3980 save_cont
= c_cont_label
;
3981 c_cont_label
= NULL_TREE
;
3982 body
= c_parser_c99_block_statement (parser
);
3983 c_parser_require_keyword (parser
, RID_WHILE
, "expected %<while%>");
3984 new_break
= c_break_label
;
3985 c_break_label
= save_break
;
3986 new_cont
= c_cont_label
;
3987 c_cont_label
= save_cont
;
3988 cond
= c_parser_paren_condition (parser
);
3989 if (!c_parser_require (parser
, CPP_SEMICOLON
, "expected %<;%>"))
3990 c_parser_skip_to_end_of_block_or_statement (parser
);
3991 c_finish_loop (loc
, cond
, NULL
, body
, new_break
, new_cont
, false);
3992 add_stmt (c_end_compound_stmt (block
, flag_isoc99
));
3995 /* Parse a for statement (C90 6.6.5, C99 6.8.5).
3998 for ( expression[opt] ; expression[opt] ; expression[opt] ) statement
3999 for ( nested-declaration expression[opt] ; expression[opt] ) statement
4001 The form with a declaration is new in C99.
4003 ??? In accordance with the old parser, the declaration may be a
4004 nested function, which is then rejected in check_for_loop_decls,
4005 but does it make any sense for this to be included in the grammar?
4006 Note in particular that the nested function does not include a
4007 trailing ';', whereas the "declaration" production includes one.
4008 Also, can we reject bad declarations earlier and cheaper than
4009 check_for_loop_decls? */
4012 c_parser_for_statement (c_parser
*parser
)
4014 tree block
, cond
, incr
, save_break
, save_cont
, body
;
4016 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_FOR
));
4017 loc
= c_parser_peek_token (parser
)->location
;
4018 c_parser_consume_token (parser
);
4019 block
= c_begin_compound_stmt (flag_isoc99
);
4020 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
4022 /* Parse the initialization declaration or expression. */
4023 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
4025 c_parser_consume_token (parser
);
4026 c_finish_expr_stmt (NULL_TREE
);
4028 else if (c_parser_next_token_starts_declspecs (parser
))
4030 c_parser_declaration_or_fndef (parser
, true, true, true, true);
4031 check_for_loop_decls ();
4033 else if (c_parser_next_token_is_keyword (parser
, RID_EXTENSION
))
4035 /* __extension__ can start a declaration, but is also an
4036 unary operator that can start an expression. Consume all
4037 but the last of a possible series of __extension__ to
4039 while (c_parser_peek_2nd_token (parser
)->type
== CPP_KEYWORD
4040 && (c_parser_peek_2nd_token (parser
)->keyword
4042 c_parser_consume_token (parser
);
4043 if (c_token_starts_declspecs (c_parser_peek_2nd_token (parser
)))
4046 ext
= disable_extension_diagnostics ();
4047 c_parser_consume_token (parser
);
4048 c_parser_declaration_or_fndef (parser
, true, true, true, true);
4049 restore_extension_diagnostics (ext
);
4050 check_for_loop_decls ();
4058 c_finish_expr_stmt (c_parser_expression (parser
).value
);
4059 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
4061 /* Parse the loop condition. */
4062 loc
= c_parser_peek_token (parser
)->location
;
4063 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
4065 c_parser_consume_token (parser
);
4070 tree ocond
= c_parser_expression_conv (parser
).value
;
4071 cond
= c_objc_common_truthvalue_conversion (ocond
);
4072 if (CAN_HAVE_LOCATION_P (cond
))
4073 SET_EXPR_LOCATION (cond
, loc
);
4074 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
4076 /* Parse the increment expression. */
4077 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
4078 incr
= c_process_expr_stmt (NULL_TREE
);
4080 incr
= c_process_expr_stmt (c_parser_expression (parser
).value
);
4081 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
4085 cond
= error_mark_node
;
4086 incr
= error_mark_node
;
4088 save_break
= c_break_label
;
4089 c_break_label
= NULL_TREE
;
4090 save_cont
= c_cont_label
;
4091 c_cont_label
= NULL_TREE
;
4092 body
= c_parser_c99_block_statement (parser
);
4093 c_finish_loop (loc
, cond
, incr
, body
, c_break_label
, c_cont_label
, true);
4094 add_stmt (c_end_compound_stmt (block
, flag_isoc99
));
4095 c_break_label
= save_break
;
4096 c_cont_label
= save_cont
;
4099 /* Parse an asm statement, a GNU extension. This is a full-blown asm
4100 statement with inputs, outputs, clobbers, and volatile tag
4104 asm type-qualifier[opt] ( asm-argument ) ;
4108 asm-string-literal : asm-operands[opt]
4109 asm-string-literal : asm-operands[opt] : asm-operands[opt]
4110 asm-string-literal : asm-operands[opt] : asm-operands[opt] : asm-clobbers
4112 Qualifiers other than volatile are accepted in the syntax but
4116 c_parser_asm_statement (c_parser
*parser
)
4118 tree quals
, str
, outputs
, inputs
, clobbers
, ret
;
4120 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_ASM
));
4121 c_parser_consume_token (parser
);
4122 if (c_parser_next_token_is_keyword (parser
, RID_VOLATILE
))
4124 quals
= c_parser_peek_token (parser
)->value
;
4125 c_parser_consume_token (parser
);
4127 else if (c_parser_next_token_is_keyword (parser
, RID_CONST
)
4128 || c_parser_next_token_is_keyword (parser
, RID_RESTRICT
))
4130 warning (0, "%E qualifier ignored on asm",
4131 c_parser_peek_token (parser
)->value
);
4133 c_parser_consume_token (parser
);
4137 /* ??? Follow the C++ parser rather than using the
4138 c_lex_string_translate kludge. */
4139 c_lex_string_translate
= 0;
4140 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
4142 c_lex_string_translate
= 1;
4145 str
= c_parser_asm_string_literal (parser
);
4146 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
4149 outputs
= NULL_TREE
;
4151 clobbers
= NULL_TREE
;
4154 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%> or %<)%>"))
4156 c_lex_string_translate
= 1;
4157 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
4161 /* Parse outputs. */
4162 if (c_parser_next_token_is (parser
, CPP_COLON
)
4163 || c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
4164 outputs
= NULL_TREE
;
4166 outputs
= c_parser_asm_operands (parser
, false);
4167 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
4170 clobbers
= NULL_TREE
;
4173 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%> or %<)%>"))
4175 c_lex_string_translate
= 1;
4176 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
4180 if (c_parser_next_token_is (parser
, CPP_COLON
)
4181 || c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
4184 inputs
= c_parser_asm_operands (parser
, true);
4185 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
4187 clobbers
= NULL_TREE
;
4190 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%> or %<)%>"))
4192 c_lex_string_translate
= 1;
4193 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
4196 /* Parse clobbers. */
4197 clobbers
= c_parser_asm_clobbers (parser
);
4199 c_lex_string_translate
= 1;
4200 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
4202 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
4205 if (!c_parser_require (parser
, CPP_SEMICOLON
, "expected %<;%>"))
4206 c_parser_skip_to_end_of_block_or_statement (parser
);
4207 ret
= build_asm_stmt (quals
, build_asm_expr (str
, outputs
, inputs
,
4212 /* Parse asm operands, a GNU extension. If CONVERT_P (for inputs but
4213 not outputs), apply the default conversion of functions and arrays
4218 asm-operands , asm-operand
4221 asm-string-literal ( expression )
4222 [ identifier ] asm-string-literal ( expression )
4226 c_parser_asm_operands (c_parser
*parser
, bool convert_p
)
4228 tree list
= NULL_TREE
;
4233 if (c_parser_next_token_is (parser
, CPP_OPEN_SQUARE
))
4235 c_parser_consume_token (parser
);
4236 if (c_parser_next_token_is (parser
, CPP_NAME
))
4238 tree id
= c_parser_peek_token (parser
)->value
;
4239 c_parser_consume_token (parser
);
4240 name
= build_string (IDENTIFIER_LENGTH (id
),
4241 IDENTIFIER_POINTER (id
));
4245 c_parser_error (parser
, "expected identifier");
4246 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
, NULL
);
4249 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
4254 str
= c_parser_asm_string_literal (parser
);
4255 if (str
== NULL_TREE
)
4257 c_lex_string_translate
= 1;
4258 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
4260 c_lex_string_translate
= 0;
4263 expr
= c_parser_expression (parser
);
4265 expr
= default_function_array_conversion (expr
);
4266 c_lex_string_translate
= 0;
4267 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
4269 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
4272 list
= chainon (list
, build_tree_list (build_tree_list (name
, str
),
4274 if (c_parser_next_token_is (parser
, CPP_COMMA
))
4275 c_parser_consume_token (parser
);
4282 /* Parse asm clobbers, a GNU extension.
4286 asm-clobbers , asm-string-literal
4290 c_parser_asm_clobbers (c_parser
*parser
)
4292 tree list
= NULL_TREE
;
4295 tree str
= c_parser_asm_string_literal (parser
);
4297 list
= tree_cons (NULL_TREE
, str
, list
);
4300 if (c_parser_next_token_is (parser
, CPP_COMMA
))
4301 c_parser_consume_token (parser
);
4308 /* Parse an expression other than a compound expression; that is, an
4309 assignment expression (C90 6.3.16, C99 6.5.16). If AFTER is not
4310 NULL then it is an Objective-C message expression which is the
4311 primary-expression starting the expression as an initializer.
4313 assignment-expression:
4314 conditional-expression
4315 unary-expression assignment-operator assignment-expression
4317 assignment-operator: one of
4318 = *= /= %= += -= <<= >>= &= ^= |=
4320 In GNU C we accept any conditional expression on the LHS and
4321 diagnose the invalid lvalue rather than producing a syntax
4324 static struct c_expr
4325 c_parser_expr_no_commas (c_parser
*parser
, struct c_expr
*after
)
4327 struct c_expr lhs
, rhs
, ret
;
4328 enum tree_code code
;
4329 gcc_assert (!after
|| c_dialect_objc ());
4330 lhs
= c_parser_conditional_expression (parser
, after
);
4331 switch (c_parser_peek_token (parser
)->type
)
4340 code
= TRUNC_DIV_EXPR
;
4343 code
= TRUNC_MOD_EXPR
;
4358 code
= BIT_AND_EXPR
;
4361 code
= BIT_XOR_EXPR
;
4364 code
= BIT_IOR_EXPR
;
4369 c_parser_consume_token (parser
);
4370 rhs
= c_parser_expr_no_commas (parser
, NULL
);
4371 rhs
= default_function_array_conversion (rhs
);
4372 ret
.value
= build_modify_expr (lhs
.value
, code
, rhs
.value
);
4373 if (code
== NOP_EXPR
)
4374 ret
.original_code
= MODIFY_EXPR
;
4377 TREE_NO_WARNING (ret
.value
) = 1;
4378 ret
.original_code
= ERROR_MARK
;
4383 /* Parse a conditional expression (C90 6.3.15, C99 6.5.15). If AFTER
4384 is not NULL then it is an Objective-C message expression which is
4385 the primary-expression starting the expression as an initializer.
4387 conditional-expression:
4388 logical-OR-expression
4389 logical-OR-expression ? expression : conditional-expression
4393 conditional-expression:
4394 logical-OR-expression ? : conditional-expression
4397 static struct c_expr
4398 c_parser_conditional_expression (c_parser
*parser
, struct c_expr
*after
)
4400 struct c_expr cond
, exp1
, exp2
, ret
;
4401 gcc_assert (!after
|| c_dialect_objc ());
4402 cond
= c_parser_binary_expression (parser
, after
);
4403 if (c_parser_next_token_is_not (parser
, CPP_QUERY
))
4405 cond
= default_function_array_conversion (cond
);
4406 c_parser_consume_token (parser
);
4407 if (c_parser_next_token_is (parser
, CPP_COLON
))
4410 pedwarn ("ISO C forbids omitting the middle term of a ?: expression");
4411 /* Make sure first operand is calculated only once. */
4412 exp1
.value
= save_expr (default_conversion (cond
.value
));
4413 cond
.value
= c_objc_common_truthvalue_conversion (exp1
.value
);
4414 skip_evaluation
+= cond
.value
== truthvalue_true_node
;
4419 = c_objc_common_truthvalue_conversion
4420 (default_conversion (cond
.value
));
4421 skip_evaluation
+= cond
.value
== truthvalue_false_node
;
4422 exp1
= c_parser_expression_conv (parser
);
4423 skip_evaluation
+= ((cond
.value
== truthvalue_true_node
)
4424 - (cond
.value
== truthvalue_false_node
));
4426 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
4428 skip_evaluation
-= cond
.value
== truthvalue_true_node
;
4429 ret
.value
= error_mark_node
;
4430 ret
.original_code
= ERROR_MARK
;
4433 exp2
= c_parser_conditional_expression (parser
, NULL
);
4434 exp2
= default_function_array_conversion (exp2
);
4435 skip_evaluation
-= cond
.value
== truthvalue_true_node
;
4436 ret
.value
= build_conditional_expr (cond
.value
, exp1
.value
, exp2
.value
);
4437 ret
.original_code
= ERROR_MARK
;
4441 /* Parse a binary expression; that is, a logical-OR-expression (C90
4442 6.3.5-6.3.14, C99 6.5.5-6.5.14). If AFTER is not NULL then it is
4443 an Objective-C message expression which is the primary-expression
4444 starting the expression as an initializer.
4446 multiplicative-expression:
4448 multiplicative-expression * cast-expression
4449 multiplicative-expression / cast-expression
4450 multiplicative-expression % cast-expression
4452 additive-expression:
4453 multiplicative-expression
4454 additive-expression + multiplicative-expression
4455 additive-expression - multiplicative-expression
4459 shift-expression << additive-expression
4460 shift-expression >> additive-expression
4462 relational-expression:
4464 relational-expression < shift-expression
4465 relational-expression > shift-expression
4466 relational-expression <= shift-expression
4467 relational-expression >= shift-expression
4469 equality-expression:
4470 relational-expression
4471 equality-expression == relational-expression
4472 equality-expression != relational-expression
4476 AND-expression & equality-expression
4478 exclusive-OR-expression:
4480 exclusive-OR-expression ^ AND-expression
4482 inclusive-OR-expression:
4483 exclusive-OR-expression
4484 inclusive-OR-expression | exclusive-OR-expression
4486 logical-AND-expression:
4487 inclusive-OR-expression
4488 logical-AND-expression && inclusive-OR-expression
4490 logical-OR-expression:
4491 logical-AND-expression
4492 logical-OR-expression || logical-AND-expression
4495 static struct c_expr
4496 c_parser_binary_expression (c_parser
*parser
, struct c_expr
*after
)
4498 /* A binary expression is parsed using operator-precedence parsing,
4499 with the operands being cast expressions. All the binary
4500 operators are left-associative. Thus a binary expression is of
4503 E0 op1 E1 op2 E2 ...
4505 which we represent on a stack. On the stack, the precedence
4506 levels are strictly increasing. When a new operator is
4507 encountered of higher precedence than that at the top of the
4508 stack, it is pushed; its LHS is the top expression, and its RHS
4509 is everything parsed until it is popped. When a new operator is
4510 encountered with precedence less than or equal to that at the top
4511 of the stack, triples E[i-1] op[i] E[i] are popped and replaced
4512 by the result of the operation until the operator at the top of
4513 the stack has lower precedence than the new operator or there is
4514 only one element on the stack; then the top expression is the LHS
4515 of the new operator. In the case of logical AND and OR
4516 expressions, we also need to adjust skip_evaluation as
4517 appropriate when the operators are pushed and popped. */
4519 /* The precedence levels, where 0 is a dummy lowest level used for
4520 the bottom of the stack. */
4536 /* The expression at this stack level. */
4538 /* The precedence of the operator on its left, PREC_NONE at the
4539 bottom of the stack. */
4541 /* The operation on its left. */
4547 switch (stack[sp].op) \
4549 case TRUTH_ANDIF_EXPR: \
4550 skip_evaluation -= stack[sp - 1].expr.value == truthvalue_false_node; \
4552 case TRUTH_ORIF_EXPR: \
4553 skip_evaluation -= stack[sp - 1].expr.value == truthvalue_true_node; \
4558 stack[sp - 1].expr \
4559 = default_function_array_conversion (stack[sp - 1].expr); \
4561 = default_function_array_conversion (stack[sp].expr); \
4562 stack[sp - 1].expr = parser_build_binary_op (stack[sp].op, \
4563 stack[sp - 1].expr, \
4567 gcc_assert (!after
|| c_dialect_objc ());
4568 stack
[0].expr
= c_parser_cast_expression (parser
, after
);
4569 stack
[0].prec
= PREC_NONE
;
4574 enum tree_code ocode
;
4577 switch (c_parser_peek_token (parser
)->type
)
4585 ocode
= TRUNC_DIV_EXPR
;
4589 ocode
= TRUNC_MOD_EXPR
;
4601 ocode
= LSHIFT_EXPR
;
4605 ocode
= RSHIFT_EXPR
;
4619 case CPP_GREATER_EQ
:
4632 oprec
= PREC_BITAND
;
4633 ocode
= BIT_AND_EXPR
;
4636 oprec
= PREC_BITXOR
;
4637 ocode
= BIT_XOR_EXPR
;
4641 ocode
= BIT_IOR_EXPR
;
4644 oprec
= PREC_LOGAND
;
4645 ocode
= TRUTH_ANDIF_EXPR
;
4649 ocode
= TRUTH_ORIF_EXPR
;
4652 /* Not a binary operator, so end of the binary
4656 c_parser_consume_token (parser
);
4657 while (oprec
<= stack
[sp
].prec
)
4661 case TRUTH_ANDIF_EXPR
:
4663 = default_function_array_conversion (stack
[sp
].expr
);
4664 stack
[sp
].expr
.value
= c_objc_common_truthvalue_conversion
4665 (default_conversion (stack
[sp
].expr
.value
));
4666 skip_evaluation
+= stack
[sp
].expr
.value
== truthvalue_false_node
;
4668 case TRUTH_ORIF_EXPR
:
4670 = default_function_array_conversion (stack
[sp
].expr
);
4671 stack
[sp
].expr
.value
= c_objc_common_truthvalue_conversion
4672 (default_conversion (stack
[sp
].expr
.value
));
4673 skip_evaluation
+= stack
[sp
].expr
.value
== truthvalue_true_node
;
4679 stack
[sp
].expr
= c_parser_cast_expression (parser
, NULL
);
4680 stack
[sp
].prec
= oprec
;
4681 stack
[sp
].op
= ocode
;
4686 return stack
[0].expr
;
4690 /* Parse a cast expression (C90 6.3.4, C99 6.5.4). If AFTER is not
4691 NULL then it is an Objective-C message expression which is the
4692 primary-expression starting the expression as an initializer.
4696 ( type-name ) unary-expression
4699 static struct c_expr
4700 c_parser_cast_expression (c_parser
*parser
, struct c_expr
*after
)
4702 gcc_assert (!after
|| c_dialect_objc ());
4704 return c_parser_postfix_expression_after_primary (parser
, *after
);
4705 /* If the expression begins with a parenthesized type name, it may
4706 be either a cast or a compound literal; we need to see whether
4707 the next character is '{' to tell the difference. If not, it is
4708 an unary expression. */
4709 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
)
4710 && c_token_starts_typename (c_parser_peek_2nd_token (parser
)))
4712 struct c_type_name
*type_name
;
4715 c_parser_consume_token (parser
);
4716 type_name
= c_parser_type_name (parser
);
4717 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
4718 if (type_name
== NULL
)
4720 ret
.value
= error_mark_node
;
4721 ret
.original_code
= ERROR_MARK
;
4725 /* Save casted types in the function's used types hash table. */
4726 used_types_insert (type_name
->specs
->type
);
4728 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
4729 return c_parser_postfix_expression_after_paren_type (parser
,
4731 expr
= c_parser_cast_expression (parser
, NULL
);
4732 expr
= default_function_array_conversion (expr
);
4733 ret
.value
= c_cast_expr (type_name
, expr
.value
);
4734 ret
.original_code
= ERROR_MARK
;
4738 return c_parser_unary_expression (parser
);
4741 /* Parse an unary expression (C90 6.3.3, C99 6.5.3).
4747 unary-operator cast-expression
4748 sizeof unary-expression
4749 sizeof ( type-name )
4751 unary-operator: one of
4757 __alignof__ unary-expression
4758 __alignof__ ( type-name )
4761 unary-operator: one of
4762 __extension__ __real__ __imag__
4764 In addition, the GNU syntax treats ++ and -- as unary operators, so
4765 they may be applied to cast expressions with errors for non-lvalues
4768 static struct c_expr
4769 c_parser_unary_expression (c_parser
*parser
)
4772 struct c_expr ret
, op
;
4773 switch (c_parser_peek_token (parser
)->type
)
4776 c_parser_consume_token (parser
);
4777 op
= c_parser_cast_expression (parser
, NULL
);
4778 op
= default_function_array_conversion (op
);
4779 return parser_build_unary_op (PREINCREMENT_EXPR
, op
);
4780 case CPP_MINUS_MINUS
:
4781 c_parser_consume_token (parser
);
4782 op
= c_parser_cast_expression (parser
, NULL
);
4783 op
= default_function_array_conversion (op
);
4784 return parser_build_unary_op (PREDECREMENT_EXPR
, op
);
4786 c_parser_consume_token (parser
);
4787 return parser_build_unary_op (ADDR_EXPR
,
4788 c_parser_cast_expression (parser
, NULL
));
4790 c_parser_consume_token (parser
);
4791 op
= c_parser_cast_expression (parser
, NULL
);
4792 op
= default_function_array_conversion (op
);
4793 ret
.value
= build_indirect_ref (op
.value
, "unary *");
4794 ret
.original_code
= ERROR_MARK
;
4797 c_parser_consume_token (parser
);
4798 if (!c_dialect_objc () && !in_system_header
)
4799 warning (OPT_Wtraditional
,
4800 "traditional C rejects the unary plus operator");
4801 op
= c_parser_cast_expression (parser
, NULL
);
4802 op
= default_function_array_conversion (op
);
4803 return parser_build_unary_op (CONVERT_EXPR
, op
);
4805 c_parser_consume_token (parser
);
4806 op
= c_parser_cast_expression (parser
, NULL
);
4807 op
= default_function_array_conversion (op
);
4808 return parser_build_unary_op (NEGATE_EXPR
, op
);
4810 c_parser_consume_token (parser
);
4811 op
= c_parser_cast_expression (parser
, NULL
);
4812 op
= default_function_array_conversion (op
);
4813 return parser_build_unary_op (BIT_NOT_EXPR
, op
);
4815 c_parser_consume_token (parser
);
4816 op
= c_parser_cast_expression (parser
, NULL
);
4817 op
= default_function_array_conversion (op
);
4818 return parser_build_unary_op (TRUTH_NOT_EXPR
, op
);
4820 /* Refer to the address of a label as a pointer. */
4821 c_parser_consume_token (parser
);
4822 if (c_parser_next_token_is (parser
, CPP_NAME
))
4824 ret
.value
= finish_label_address_expr
4825 (c_parser_peek_token (parser
)->value
);
4826 c_parser_consume_token (parser
);
4830 c_parser_error (parser
, "expected identifier");
4831 ret
.value
= error_mark_node
;
4833 ret
.original_code
= ERROR_MARK
;
4836 switch (c_parser_peek_token (parser
)->keyword
)
4839 return c_parser_sizeof_expression (parser
);
4841 return c_parser_alignof_expression (parser
);
4843 c_parser_consume_token (parser
);
4844 ext
= disable_extension_diagnostics ();
4845 ret
= c_parser_cast_expression (parser
, NULL
);
4846 restore_extension_diagnostics (ext
);
4849 c_parser_consume_token (parser
);
4850 op
= c_parser_cast_expression (parser
, NULL
);
4851 op
= default_function_array_conversion (op
);
4852 return parser_build_unary_op (REALPART_EXPR
, op
);
4854 c_parser_consume_token (parser
);
4855 op
= c_parser_cast_expression (parser
, NULL
);
4856 op
= default_function_array_conversion (op
);
4857 return parser_build_unary_op (IMAGPART_EXPR
, op
);
4859 return c_parser_postfix_expression (parser
);
4862 return c_parser_postfix_expression (parser
);
4866 /* Parse a sizeof expression. */
4868 static struct c_expr
4869 c_parser_sizeof_expression (c_parser
*parser
)
4872 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_SIZEOF
));
4873 c_parser_consume_token (parser
);
4876 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
)
4877 && c_token_starts_typename (c_parser_peek_2nd_token (parser
)))
4879 /* Either sizeof ( type-name ) or sizeof unary-expression
4880 starting with a compound literal. */
4881 struct c_type_name
*type_name
;
4882 c_parser_consume_token (parser
);
4883 type_name
= c_parser_type_name (parser
);
4884 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
4885 if (type_name
== NULL
)
4890 ret
.value
= error_mark_node
;
4891 ret
.original_code
= ERROR_MARK
;
4894 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
4896 expr
= c_parser_postfix_expression_after_paren_type (parser
,
4900 /* sizeof ( type-name ). */
4903 if (type_name
->declarator
->kind
== cdk_array
4904 && type_name
->declarator
->u
.array
.vla_unspec_p
)
4907 error ("%<[*]%> not allowed in other than a declaration");
4909 return c_expr_sizeof_type (type_name
);
4913 expr
= c_parser_unary_expression (parser
);
4917 if (TREE_CODE (expr
.value
) == COMPONENT_REF
4918 && DECL_C_BIT_FIELD (TREE_OPERAND (expr
.value
, 1)))
4919 error ("%<sizeof%> applied to a bit-field");
4920 return c_expr_sizeof_expr (expr
);
4924 /* Parse an alignof expression. */
4926 static struct c_expr
4927 c_parser_alignof_expression (c_parser
*parser
)
4930 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_ALIGNOF
));
4931 c_parser_consume_token (parser
);
4934 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
)
4935 && c_token_starts_typename (c_parser_peek_2nd_token (parser
)))
4937 /* Either __alignof__ ( type-name ) or __alignof__
4938 unary-expression starting with a compound literal. */
4939 struct c_type_name
*type_name
;
4941 c_parser_consume_token (parser
);
4942 type_name
= c_parser_type_name (parser
);
4943 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
4944 if (type_name
== NULL
)
4949 ret
.value
= error_mark_node
;
4950 ret
.original_code
= ERROR_MARK
;
4953 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
4955 expr
= c_parser_postfix_expression_after_paren_type (parser
,
4959 /* alignof ( type-name ). */
4962 ret
.value
= c_alignof (groktypename (type_name
));
4963 ret
.original_code
= ERROR_MARK
;
4969 expr
= c_parser_unary_expression (parser
);
4973 ret
.value
= c_alignof_expr (expr
.value
);
4974 ret
.original_code
= ERROR_MARK
;
4979 /* Parse a postfix expression (C90 6.3.1-6.3.2, C99 6.5.1-6.5.2).
4983 postfix-expression [ expression ]
4984 postfix-expression ( argument-expression-list[opt] )
4985 postfix-expression . identifier
4986 postfix-expression -> identifier
4987 postfix-expression ++
4988 postfix-expression --
4989 ( type-name ) { initializer-list }
4990 ( type-name ) { initializer-list , }
4992 argument-expression-list:
4994 argument-expression-list , argument-expression
5006 (treated as a keyword in GNU C)
5009 ( compound-statement )
5010 __builtin_va_arg ( assignment-expression , type-name )
5011 __builtin_offsetof ( type-name , offsetof-member-designator )
5012 __builtin_choose_expr ( assignment-expression ,
5013 assignment-expression ,
5014 assignment-expression )
5015 __builtin_types_compatible_p ( type-name , type-name )
5017 offsetof-member-designator:
5019 offsetof-member-designator . identifier
5020 offsetof-member-designator [ expression ]
5025 [ objc-receiver objc-message-args ]
5026 @selector ( objc-selector-arg )
5027 @protocol ( identifier )
5028 @encode ( type-name )
5032 static struct c_expr
5033 c_parser_postfix_expression (c_parser
*parser
)
5035 struct c_expr expr
, e1
, e2
, e3
;
5036 struct c_type_name
*t1
, *t2
;
5037 switch (c_parser_peek_token (parser
)->type
)
5042 expr
.value
= c_parser_peek_token (parser
)->value
;
5043 expr
.original_code
= ERROR_MARK
;
5044 c_parser_consume_token (parser
);
5048 expr
.value
= c_parser_peek_token (parser
)->value
;
5049 expr
.original_code
= STRING_CST
;
5050 c_parser_consume_token (parser
);
5052 case CPP_OBJC_STRING
:
5053 gcc_assert (c_dialect_objc ());
5055 = objc_build_string_object (c_parser_peek_token (parser
)->value
);
5056 expr
.original_code
= ERROR_MARK
;
5057 c_parser_consume_token (parser
);
5060 if (c_parser_peek_token (parser
)->id_kind
!= C_ID_ID
)
5062 c_parser_error (parser
, "expected expression");
5063 expr
.value
= error_mark_node
;
5064 expr
.original_code
= ERROR_MARK
;
5068 tree id
= c_parser_peek_token (parser
)->value
;
5069 location_t loc
= c_parser_peek_token (parser
)->location
;
5070 c_parser_consume_token (parser
);
5071 expr
.value
= build_external_ref (id
,
5072 (c_parser_peek_token (parser
)->type
5073 == CPP_OPEN_PAREN
), loc
);
5074 expr
.original_code
= ERROR_MARK
;
5077 case CPP_OPEN_PAREN
:
5078 /* A parenthesized expression, statement expression or compound
5080 if (c_parser_peek_2nd_token (parser
)->type
== CPP_OPEN_BRACE
)
5082 /* A statement expression. */
5084 c_parser_consume_token (parser
);
5085 c_parser_consume_token (parser
);
5086 if (cur_stmt_list
== NULL
)
5088 error ("braced-group within expression allowed "
5089 "only inside a function");
5090 parser
->error
= true;
5091 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
, NULL
);
5092 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5093 expr
.value
= error_mark_node
;
5094 expr
.original_code
= ERROR_MARK
;
5097 stmt
= c_begin_stmt_expr ();
5098 c_parser_compound_statement_nostart (parser
);
5099 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5102 pedwarn ("ISO C forbids braced-groups within expressions");
5103 expr
.value
= c_finish_stmt_expr (stmt
);
5104 expr
.original_code
= ERROR_MARK
;
5106 else if (c_token_starts_typename (c_parser_peek_2nd_token (parser
)))
5108 /* A compound literal. ??? Can we actually get here rather
5109 than going directly to
5110 c_parser_postfix_expression_after_paren_type from
5112 struct c_type_name
*type_name
;
5113 c_parser_consume_token (parser
);
5114 type_name
= c_parser_type_name (parser
);
5115 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5117 if (type_name
== NULL
)
5119 expr
.value
= error_mark_node
;
5120 expr
.original_code
= ERROR_MARK
;
5123 expr
= c_parser_postfix_expression_after_paren_type (parser
,
5128 /* A parenthesized expression. */
5129 c_parser_consume_token (parser
);
5130 expr
= c_parser_expression (parser
);
5131 if (TREE_CODE (expr
.value
) == MODIFY_EXPR
)
5132 TREE_NO_WARNING (expr
.value
) = 1;
5133 expr
.original_code
= ERROR_MARK
;
5134 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5139 switch (c_parser_peek_token (parser
)->keyword
)
5141 case RID_FUNCTION_NAME
:
5142 case RID_PRETTY_FUNCTION_NAME
:
5143 case RID_C99_FUNCTION_NAME
:
5144 expr
.value
= fname_decl (c_parser_peek_token (parser
)->keyword
,
5145 c_parser_peek_token (parser
)->value
);
5146 expr
.original_code
= ERROR_MARK
;
5147 c_parser_consume_token (parser
);
5150 c_parser_consume_token (parser
);
5151 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
5153 expr
.value
= error_mark_node
;
5154 expr
.original_code
= ERROR_MARK
;
5157 e1
= c_parser_expr_no_commas (parser
, NULL
);
5158 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
5160 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5161 expr
.value
= error_mark_node
;
5162 expr
.original_code
= ERROR_MARK
;
5165 t1
= c_parser_type_name (parser
);
5166 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5170 expr
.value
= error_mark_node
;
5171 expr
.original_code
= ERROR_MARK
;
5175 expr
.value
= build_va_arg (e1
.value
, groktypename (t1
));
5176 expr
.original_code
= ERROR_MARK
;
5180 c_parser_consume_token (parser
);
5181 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
5183 expr
.value
= error_mark_node
;
5184 expr
.original_code
= ERROR_MARK
;
5187 t1
= c_parser_type_name (parser
);
5190 expr
.value
= error_mark_node
;
5191 expr
.original_code
= ERROR_MARK
;
5194 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
5196 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5197 expr
.value
= error_mark_node
;
5198 expr
.original_code
= ERROR_MARK
;
5202 tree type
= groktypename (t1
);
5204 if (type
== error_mark_node
)
5205 offsetof_ref
= error_mark_node
;
5207 offsetof_ref
= build1 (INDIRECT_REF
, type
, null_pointer_node
);
5208 /* Parse the second argument to __builtin_offsetof. We
5209 must have one identifier, and beyond that we want to
5210 accept sub structure and sub array references. */
5211 if (c_parser_next_token_is (parser
, CPP_NAME
))
5213 offsetof_ref
= build_component_ref
5214 (offsetof_ref
, c_parser_peek_token (parser
)->value
);
5215 c_parser_consume_token (parser
);
5216 while (c_parser_next_token_is (parser
, CPP_DOT
)
5217 || c_parser_next_token_is (parser
,
5220 if (c_parser_next_token_is (parser
, CPP_DOT
))
5222 c_parser_consume_token (parser
);
5223 if (c_parser_next_token_is_not (parser
,
5226 c_parser_error (parser
, "expected identifier");
5229 offsetof_ref
= build_component_ref
5231 c_parser_peek_token (parser
)->value
);
5232 c_parser_consume_token (parser
);
5237 c_parser_consume_token (parser
);
5238 idx
= c_parser_expression (parser
).value
;
5239 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
5241 offsetof_ref
= build_array_ref (offsetof_ref
, idx
);
5246 c_parser_error (parser
, "expected identifier");
5247 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5249 expr
.value
= fold_offsetof (offsetof_ref
, NULL_TREE
);
5250 expr
.original_code
= ERROR_MARK
;
5253 case RID_CHOOSE_EXPR
:
5254 c_parser_consume_token (parser
);
5255 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
5257 expr
.value
= error_mark_node
;
5258 expr
.original_code
= ERROR_MARK
;
5261 e1
= c_parser_expr_no_commas (parser
, NULL
);
5262 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
5264 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5265 expr
.value
= error_mark_node
;
5266 expr
.original_code
= ERROR_MARK
;
5269 e2
= c_parser_expr_no_commas (parser
, NULL
);
5270 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
5272 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5273 expr
.value
= error_mark_node
;
5274 expr
.original_code
= ERROR_MARK
;
5277 e3
= c_parser_expr_no_commas (parser
, NULL
);
5278 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5283 c
= fold (e1
.value
);
5284 if (TREE_CODE (c
) != INTEGER_CST
)
5285 error ("first argument to %<__builtin_choose_expr%> not"
5287 expr
= integer_zerop (c
) ? e3
: e2
;
5290 case RID_TYPES_COMPATIBLE_P
:
5291 c_parser_consume_token (parser
);
5292 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
5294 expr
.value
= error_mark_node
;
5295 expr
.original_code
= ERROR_MARK
;
5298 t1
= c_parser_type_name (parser
);
5301 expr
.value
= error_mark_node
;
5302 expr
.original_code
= ERROR_MARK
;
5305 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
5307 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5308 expr
.value
= error_mark_node
;
5309 expr
.original_code
= ERROR_MARK
;
5312 t2
= c_parser_type_name (parser
);
5315 expr
.value
= error_mark_node
;
5316 expr
.original_code
= ERROR_MARK
;
5319 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5324 e1
= TYPE_MAIN_VARIANT (groktypename (t1
));
5325 e2
= TYPE_MAIN_VARIANT (groktypename (t2
));
5327 expr
.value
= comptypes (e1
, e2
)
5328 ? build_int_cst (NULL_TREE
, 1)
5329 : build_int_cst (NULL_TREE
, 0);
5330 expr
.original_code
= ERROR_MARK
;
5333 case RID_AT_SELECTOR
:
5334 gcc_assert (c_dialect_objc ());
5335 c_parser_consume_token (parser
);
5336 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
5338 expr
.value
= error_mark_node
;
5339 expr
.original_code
= ERROR_MARK
;
5343 tree sel
= c_parser_objc_selector_arg (parser
);
5344 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5346 expr
.value
= objc_build_selector_expr (sel
);
5347 expr
.original_code
= ERROR_MARK
;
5350 case RID_AT_PROTOCOL
:
5351 gcc_assert (c_dialect_objc ());
5352 c_parser_consume_token (parser
);
5353 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
5355 expr
.value
= error_mark_node
;
5356 expr
.original_code
= ERROR_MARK
;
5359 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5361 c_parser_error (parser
, "expected identifier");
5362 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5363 expr
.value
= error_mark_node
;
5364 expr
.original_code
= ERROR_MARK
;
5368 tree id
= c_parser_peek_token (parser
)->value
;
5369 c_parser_consume_token (parser
);
5370 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5372 expr
.value
= objc_build_protocol_expr (id
);
5373 expr
.original_code
= ERROR_MARK
;
5377 /* Extension to support C-structures in the archiver. */
5378 gcc_assert (c_dialect_objc ());
5379 c_parser_consume_token (parser
);
5380 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
5382 expr
.value
= error_mark_node
;
5383 expr
.original_code
= ERROR_MARK
;
5386 t1
= c_parser_type_name (parser
);
5389 expr
.value
= error_mark_node
;
5390 expr
.original_code
= ERROR_MARK
;
5391 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5394 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5397 tree type
= groktypename (t1
);
5398 expr
.value
= objc_build_encode_expr (type
);
5399 expr
.original_code
= ERROR_MARK
;
5403 c_parser_error (parser
, "expected expression");
5404 expr
.value
= error_mark_node
;
5405 expr
.original_code
= ERROR_MARK
;
5409 case CPP_OPEN_SQUARE
:
5410 if (c_dialect_objc ())
5412 tree receiver
, args
;
5413 c_parser_consume_token (parser
);
5414 receiver
= c_parser_objc_receiver (parser
);
5415 args
= c_parser_objc_message_args (parser
);
5416 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
5418 expr
.value
= objc_build_message_expr (build_tree_list (receiver
,
5420 expr
.original_code
= ERROR_MARK
;
5423 /* Else fall through to report error. */
5425 c_parser_error (parser
, "expected expression");
5426 expr
.value
= error_mark_node
;
5427 expr
.original_code
= ERROR_MARK
;
5430 return c_parser_postfix_expression_after_primary (parser
, expr
);
5433 /* Parse a postfix expression after a parenthesized type name: the
5434 brace-enclosed initializer of a compound literal, possibly followed
5435 by some postfix operators. This is separate because it is not
5436 possible to tell until after the type name whether a cast
5437 expression has a cast or a compound literal, or whether the operand
5438 of sizeof is a parenthesized type name or starts with a compound
5441 static struct c_expr
5442 c_parser_postfix_expression_after_paren_type (c_parser
*parser
,
5443 struct c_type_name
*type_name
)
5448 start_init (NULL_TREE
, NULL
, 0);
5449 type
= groktypename (type_name
);
5450 if (type
!= error_mark_node
&& C_TYPE_VARIABLE_SIZE (type
))
5452 error ("compound literal has variable size");
5453 type
= error_mark_node
;
5455 init
= c_parser_braced_init (parser
, type
, false);
5457 maybe_warn_string_init (type
, init
);
5459 if (pedantic
&& !flag_isoc99
)
5460 pedwarn ("ISO C90 forbids compound literals");
5461 expr
.value
= build_compound_literal (type
, init
.value
);
5462 expr
.original_code
= ERROR_MARK
;
5463 return c_parser_postfix_expression_after_primary (parser
, expr
);
5466 /* Parse a postfix expression after the initial primary or compound
5467 literal; that is, parse a series of postfix operators. */
5469 static struct c_expr
5470 c_parser_postfix_expression_after_primary (c_parser
*parser
,
5473 tree ident
, idx
, exprlist
;
5476 switch (c_parser_peek_token (parser
)->type
)
5478 case CPP_OPEN_SQUARE
:
5479 /* Array reference. */
5480 c_parser_consume_token (parser
);
5481 idx
= c_parser_expression (parser
).value
;
5482 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
5484 expr
.value
= build_array_ref (expr
.value
, idx
);
5485 expr
.original_code
= ERROR_MARK
;
5487 case CPP_OPEN_PAREN
:
5488 /* Function call. */
5489 c_parser_consume_token (parser
);
5490 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
5491 exprlist
= NULL_TREE
;
5493 exprlist
= c_parser_expr_list (parser
, true);
5494 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5496 expr
.value
= build_function_call (expr
.value
, exprlist
);
5497 expr
.original_code
= ERROR_MARK
;
5500 /* Structure element reference. */
5501 c_parser_consume_token (parser
);
5502 expr
= default_function_array_conversion (expr
);
5503 if (c_parser_next_token_is (parser
, CPP_NAME
))
5504 ident
= c_parser_peek_token (parser
)->value
;
5507 c_parser_error (parser
, "expected identifier");
5508 expr
.value
= error_mark_node
;
5509 expr
.original_code
= ERROR_MARK
;
5512 c_parser_consume_token (parser
);
5513 expr
.value
= build_component_ref (expr
.value
, ident
);
5514 expr
.original_code
= ERROR_MARK
;
5517 /* Structure element reference. */
5518 c_parser_consume_token (parser
);
5519 expr
= default_function_array_conversion (expr
);
5520 if (c_parser_next_token_is (parser
, CPP_NAME
))
5521 ident
= c_parser_peek_token (parser
)->value
;
5524 c_parser_error (parser
, "expected identifier");
5525 expr
.value
= error_mark_node
;
5526 expr
.original_code
= ERROR_MARK
;
5529 c_parser_consume_token (parser
);
5530 expr
.value
= build_component_ref (build_indirect_ref (expr
.value
,
5532 expr
.original_code
= ERROR_MARK
;
5535 /* Postincrement. */
5536 c_parser_consume_token (parser
);
5537 expr
= default_function_array_conversion (expr
);
5538 expr
.value
= build_unary_op (POSTINCREMENT_EXPR
, expr
.value
, 0);
5539 expr
.original_code
= ERROR_MARK
;
5541 case CPP_MINUS_MINUS
:
5542 /* Postdecrement. */
5543 c_parser_consume_token (parser
);
5544 expr
= default_function_array_conversion (expr
);
5545 expr
.value
= build_unary_op (POSTDECREMENT_EXPR
, expr
.value
, 0);
5546 expr
.original_code
= ERROR_MARK
;
5554 /* Parse an expression (C90 6.3.17, C99 6.5.17).
5557 assignment-expression
5558 expression , assignment-expression
5561 static struct c_expr
5562 c_parser_expression (c_parser
*parser
)
5565 expr
= c_parser_expr_no_commas (parser
, NULL
);
5566 while (c_parser_next_token_is (parser
, CPP_COMMA
))
5569 c_parser_consume_token (parser
);
5570 next
= c_parser_expr_no_commas (parser
, NULL
);
5571 next
= default_function_array_conversion (next
);
5572 expr
.value
= build_compound_expr (expr
.value
, next
.value
);
5573 expr
.original_code
= COMPOUND_EXPR
;
5578 /* Parse an expression and convert functions or arrays to
5581 static struct c_expr
5582 c_parser_expression_conv (c_parser
*parser
)
5585 expr
= c_parser_expression (parser
);
5586 expr
= default_function_array_conversion (expr
);
5590 /* Parse a non-empty list of expressions. If CONVERT_P, convert
5591 functions and arrays to pointers.
5594 assignment-expression
5595 nonempty-expr-list , assignment-expression
5599 c_parser_expr_list (c_parser
*parser
, bool convert_p
)
5603 expr
= c_parser_expr_no_commas (parser
, NULL
);
5605 expr
= default_function_array_conversion (expr
);
5606 ret
= cur
= build_tree_list (NULL_TREE
, expr
.value
);
5607 while (c_parser_next_token_is (parser
, CPP_COMMA
))
5609 c_parser_consume_token (parser
);
5610 expr
= c_parser_expr_no_commas (parser
, NULL
);
5612 expr
= default_function_array_conversion (expr
);
5613 cur
= TREE_CHAIN (cur
) = build_tree_list (NULL_TREE
, expr
.value
);
5619 /* Parse Objective-C-specific constructs. */
5621 /* Parse an objc-class-definition.
5623 objc-class-definition:
5624 @interface identifier objc-superclass[opt] objc-protocol-refs[opt]
5625 objc-class-instance-variables[opt] objc-methodprotolist @end
5626 @implementation identifier objc-superclass[opt]
5627 objc-class-instance-variables[opt]
5628 @interface identifier ( identifier ) objc-protocol-refs[opt]
5629 objc-methodprotolist @end
5630 @implementation identifier ( identifier )
5635 "@interface identifier (" must start "@interface identifier (
5636 identifier ) ...": objc-methodprotolist in the first production may
5637 not start with a parenthesized identifier as a declarator of a data
5638 definition with no declaration specifiers if the objc-superclass,
5639 objc-protocol-refs and objc-class-instance-variables are omitted. */
5642 c_parser_objc_class_definition (c_parser
*parser
)
5647 if (c_parser_next_token_is_keyword (parser
, RID_AT_INTERFACE
))
5649 else if (c_parser_next_token_is_keyword (parser
, RID_AT_IMPLEMENTATION
))
5653 c_parser_consume_token (parser
);
5654 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5656 c_parser_error (parser
, "expected identifier");
5659 id1
= c_parser_peek_token (parser
)->value
;
5660 c_parser_consume_token (parser
);
5661 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
5664 tree proto
= NULL_TREE
;
5665 c_parser_consume_token (parser
);
5666 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5668 c_parser_error (parser
, "expected identifier");
5669 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5672 id2
= c_parser_peek_token (parser
)->value
;
5673 c_parser_consume_token (parser
);
5674 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
5677 objc_start_category_implementation (id1
, id2
);
5680 if (c_parser_next_token_is (parser
, CPP_LESS
))
5681 proto
= c_parser_objc_protocol_refs (parser
);
5682 objc_start_category_interface (id1
, id2
, proto
);
5683 c_parser_objc_methodprotolist (parser
);
5684 c_parser_require_keyword (parser
, RID_AT_END
, "expected %<@end%>");
5685 objc_finish_interface ();
5688 if (c_parser_next_token_is (parser
, CPP_COLON
))
5690 c_parser_consume_token (parser
);
5691 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5693 c_parser_error (parser
, "expected identifier");
5696 superclass
= c_parser_peek_token (parser
)->value
;
5697 c_parser_consume_token (parser
);
5700 superclass
= NULL_TREE
;
5703 tree proto
= NULL_TREE
;
5704 if (c_parser_next_token_is (parser
, CPP_LESS
))
5705 proto
= c_parser_objc_protocol_refs (parser
);
5706 objc_start_class_interface (id1
, superclass
, proto
);
5709 objc_start_class_implementation (id1
, superclass
);
5710 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
5711 c_parser_objc_class_instance_variables (parser
);
5714 objc_continue_interface ();
5715 c_parser_objc_methodprotolist (parser
);
5716 c_parser_require_keyword (parser
, RID_AT_END
, "expected %<@end%>");
5717 objc_finish_interface ();
5721 objc_continue_implementation ();
5726 /* Parse objc-class-instance-variables.
5728 objc-class-instance-variables:
5729 { objc-instance-variable-decl-list[opt] }
5731 objc-instance-variable-decl-list:
5732 objc-visibility-spec
5733 objc-instance-variable-decl ;
5735 objc-instance-variable-decl-list objc-visibility-spec
5736 objc-instance-variable-decl-list objc-instance-variable-decl ;
5737 objc-instance-variable-decl-list ;
5739 objc-visibility-spec:
5744 objc-instance-variable-decl:
5749 c_parser_objc_class_instance_variables (c_parser
*parser
)
5751 gcc_assert (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
));
5752 c_parser_consume_token (parser
);
5753 while (c_parser_next_token_is_not (parser
, CPP_EOF
))
5756 /* Parse any stray semicolon. */
5757 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
5760 pedwarn ("extra semicolon in struct or union specified");
5761 c_parser_consume_token (parser
);
5764 /* Stop if at the end of the instance variables. */
5765 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
5767 c_parser_consume_token (parser
);
5770 /* Parse any objc-visibility-spec. */
5771 if (c_parser_next_token_is_keyword (parser
, RID_AT_PRIVATE
))
5773 c_parser_consume_token (parser
);
5774 objc_set_visibility (2);
5777 else if (c_parser_next_token_is_keyword (parser
, RID_AT_PROTECTED
))
5779 c_parser_consume_token (parser
);
5780 objc_set_visibility (0);
5783 else if (c_parser_next_token_is_keyword (parser
, RID_AT_PUBLIC
))
5785 c_parser_consume_token (parser
);
5786 objc_set_visibility (1);
5789 else if (c_parser_next_token_is (parser
, CPP_PRAGMA
))
5791 c_parser_pragma (parser
, pragma_external
);
5795 /* Parse some comma-separated declarations. */
5796 decls
= c_parser_struct_declaration (parser
);
5798 /* Comma-separated instance variables are chained together in
5799 reverse order; add them one by one. */
5800 tree ivar
= nreverse (decls
);
5801 for (; ivar
; ivar
= TREE_CHAIN (ivar
))
5802 objc_add_instance_variable (copy_node (ivar
));
5804 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
5808 /* Parse an objc-class-declaration.
5810 objc-class-declaration:
5811 @class identifier-list ;
5815 c_parser_objc_class_declaration (c_parser
*parser
)
5817 tree list
= NULL_TREE
;
5818 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_AT_CLASS
));
5819 c_parser_consume_token (parser
);
5820 /* Any identifiers, including those declared as type names, are OK
5825 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5827 c_parser_error (parser
, "expected identifier");
5830 id
= c_parser_peek_token (parser
)->value
;
5831 list
= chainon (list
, build_tree_list (NULL_TREE
, id
));
5832 c_parser_consume_token (parser
);
5833 if (c_parser_next_token_is (parser
, CPP_COMMA
))
5834 c_parser_consume_token (parser
);
5838 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
5839 objc_declare_class (list
);
5842 /* Parse an objc-alias-declaration.
5844 objc-alias-declaration:
5845 @compatibility_alias identifier identifier ;
5849 c_parser_objc_alias_declaration (c_parser
*parser
)
5852 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_AT_ALIAS
));
5853 c_parser_consume_token (parser
);
5854 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5856 c_parser_error (parser
, "expected identifier");
5857 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, NULL
);
5860 id1
= c_parser_peek_token (parser
)->value
;
5861 c_parser_consume_token (parser
);
5862 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5864 c_parser_error (parser
, "expected identifier");
5865 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, NULL
);
5868 id2
= c_parser_peek_token (parser
)->value
;
5869 c_parser_consume_token (parser
);
5870 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
5871 objc_declare_alias (id1
, id2
);
5874 /* Parse an objc-protocol-definition.
5876 objc-protocol-definition:
5877 @protocol identifier objc-protocol-refs[opt] objc-methodprotolist @end
5878 @protocol identifier-list ;
5880 "@protocol identifier ;" should be resolved as "@protocol
5881 identifier-list ;": objc-methodprotolist may not start with a
5882 semicolon in the first alternative if objc-protocol-refs are
5886 c_parser_objc_protocol_definition (c_parser
*parser
)
5888 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_AT_PROTOCOL
));
5889 c_parser_consume_token (parser
);
5890 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5892 c_parser_error (parser
, "expected identifier");
5895 if (c_parser_peek_2nd_token (parser
)->type
== CPP_COMMA
5896 || c_parser_peek_2nd_token (parser
)->type
== CPP_SEMICOLON
)
5898 tree list
= NULL_TREE
;
5899 /* Any identifiers, including those declared as type names, are
5904 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5906 c_parser_error (parser
, "expected identifier");
5909 id
= c_parser_peek_token (parser
)->value
;
5910 list
= chainon (list
, build_tree_list (NULL_TREE
, id
));
5911 c_parser_consume_token (parser
);
5912 if (c_parser_next_token_is (parser
, CPP_COMMA
))
5913 c_parser_consume_token (parser
);
5917 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
5918 objc_declare_protocols (list
);
5922 tree id
= c_parser_peek_token (parser
)->value
;
5923 tree proto
= NULL_TREE
;
5924 c_parser_consume_token (parser
);
5925 if (c_parser_next_token_is (parser
, CPP_LESS
))
5926 proto
= c_parser_objc_protocol_refs (parser
);
5927 parser
->objc_pq_context
= true;
5928 objc_start_protocol (id
, proto
);
5929 c_parser_objc_methodprotolist (parser
);
5930 c_parser_require_keyword (parser
, RID_AT_END
, "expected %<@end%>");
5931 parser
->objc_pq_context
= false;
5932 objc_finish_interface ();
5936 /* Parse an objc-method-type.
5943 static enum tree_code
5944 c_parser_objc_method_type (c_parser
*parser
)
5946 switch (c_parser_peek_token (parser
)->type
)
5949 c_parser_consume_token (parser
);
5952 c_parser_consume_token (parser
);
5959 /* Parse an objc-method-definition.
5961 objc-method-definition:
5962 objc-method-type objc-method-decl ;[opt] compound-statement
5966 c_parser_objc_method_definition (c_parser
*parser
)
5968 enum tree_code type
= c_parser_objc_method_type (parser
);
5970 objc_set_method_type (type
);
5971 parser
->objc_pq_context
= true;
5972 decl
= c_parser_objc_method_decl (parser
);
5973 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
5975 c_parser_consume_token (parser
);
5977 pedwarn ("extra semicolon in method definition specified");
5979 if (!c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
5981 c_parser_error (parser
, "expected %<{%>");
5984 parser
->objc_pq_context
= false;
5985 objc_start_method_definition (decl
);
5986 add_stmt (c_parser_compound_statement (parser
));
5987 objc_finish_method_definition (current_function_decl
);
5990 /* Parse an objc-methodprotolist.
5992 objc-methodprotolist:
5994 objc-methodprotolist objc-methodproto
5995 objc-methodprotolist declaration
5996 objc-methodprotolist ;
5998 The declaration is a data definition, which may be missing
5999 declaration specifiers under the same rules and diagnostics as
6000 other data definitions outside functions, and the stray semicolon
6001 is diagnosed the same way as a stray semicolon outside a
6005 c_parser_objc_methodprotolist (c_parser
*parser
)
6009 /* The list is terminated by @end. */
6010 switch (c_parser_peek_token (parser
)->type
)
6014 pedwarn ("ISO C does not allow extra %<;%> outside of a function");
6015 c_parser_consume_token (parser
);
6019 c_parser_objc_methodproto (parser
);
6022 c_parser_pragma (parser
, pragma_external
);
6027 if (c_parser_next_token_is_keyword (parser
, RID_AT_END
))
6029 c_parser_declaration_or_fndef (parser
, false, true, false, true);
6035 /* Parse an objc-methodproto.
6038 objc-method-type objc-method-decl ;
6042 c_parser_objc_methodproto (c_parser
*parser
)
6044 enum tree_code type
= c_parser_objc_method_type (parser
);
6046 objc_set_method_type (type
);
6047 /* Remember protocol qualifiers in prototypes. */
6048 parser
->objc_pq_context
= true;
6049 decl
= c_parser_objc_method_decl (parser
);
6050 /* Forget protocol qualifiers here. */
6051 parser
->objc_pq_context
= false;
6052 objc_add_method_declaration (decl
);
6053 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
6056 /* Parse an objc-method-decl.
6059 ( objc-type-name ) objc-selector
6061 ( objc-type-name ) objc-keyword-selector objc-optparmlist
6062 objc-keyword-selector objc-optparmlist
6064 objc-keyword-selector:
6066 objc-keyword-selector objc-keyword-decl
6069 objc-selector : ( objc-type-name ) identifier
6070 objc-selector : identifier
6071 : ( objc-type-name ) identifier
6075 objc-optparms objc-optellipsis
6079 objc-opt-parms , parameter-declaration
6087 c_parser_objc_method_decl (c_parser
*parser
)
6089 tree type
= NULL_TREE
;
6091 tree parms
= NULL_TREE
;
6092 bool ellipsis
= false;
6094 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
6096 c_parser_consume_token (parser
);
6097 type
= c_parser_objc_type_name (parser
);
6098 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
6100 sel
= c_parser_objc_selector (parser
);
6101 /* If there is no selector, or a colon follows, we have an
6102 objc-keyword-selector. If there is a selector, and a colon does
6103 not follow, that selector ends the objc-method-decl. */
6104 if (!sel
|| c_parser_next_token_is (parser
, CPP_COLON
))
6107 tree list
= NULL_TREE
;
6110 tree atype
= NULL_TREE
, id
, keyworddecl
;
6111 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
6113 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
6115 c_parser_consume_token (parser
);
6116 atype
= c_parser_objc_type_name (parser
);
6117 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
6120 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
6122 c_parser_error (parser
, "expected identifier");
6123 return error_mark_node
;
6125 id
= c_parser_peek_token (parser
)->value
;
6126 c_parser_consume_token (parser
);
6127 keyworddecl
= objc_build_keyword_decl (tsel
, atype
, id
);
6128 list
= chainon (list
, keyworddecl
);
6129 tsel
= c_parser_objc_selector (parser
);
6130 if (!tsel
&& c_parser_next_token_is_not (parser
, CPP_COLON
))
6133 /* Parse the optional parameter list. Optional Objective-C
6134 method parameters follow the C syntax, and may include '...'
6135 to denote a variable number of arguments. */
6136 parms
= make_node (TREE_LIST
);
6137 while (c_parser_next_token_is (parser
, CPP_COMMA
))
6139 struct c_parm
*parm
;
6140 c_parser_consume_token (parser
);
6141 if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
))
6144 c_parser_consume_token (parser
);
6147 parm
= c_parser_parameter_declaration (parser
, NULL_TREE
);
6150 parms
= chainon (parms
,
6151 build_tree_list (NULL_TREE
, grokparm (parm
)));
6155 return objc_build_method_signature (type
, sel
, parms
, ellipsis
);
6158 /* Parse an objc-type-name.
6161 objc-type-qualifiers[opt] type-name
6162 objc-type-qualifiers[opt]
6164 objc-type-qualifiers:
6166 objc-type-qualifiers objc-type-qualifier
6168 objc-type-qualifier: one of
6169 in out inout bycopy byref oneway
6173 c_parser_objc_type_name (c_parser
*parser
)
6175 tree quals
= NULL_TREE
;
6176 struct c_type_name
*typename
= NULL
;
6177 tree type
= NULL_TREE
;
6180 c_token
*token
= c_parser_peek_token (parser
);
6181 if (token
->type
== CPP_KEYWORD
6182 && (token
->keyword
== RID_IN
6183 || token
->keyword
== RID_OUT
6184 || token
->keyword
== RID_INOUT
6185 || token
->keyword
== RID_BYCOPY
6186 || token
->keyword
== RID_BYREF
6187 || token
->keyword
== RID_ONEWAY
))
6189 quals
= chainon (quals
, build_tree_list (NULL_TREE
, token
->value
));
6190 c_parser_consume_token (parser
);
6195 if (c_parser_next_token_starts_typename (parser
))
6196 typename
= c_parser_type_name (parser
);
6198 type
= groktypename (typename
);
6199 return build_tree_list (quals
, type
);
6202 /* Parse objc-protocol-refs.
6209 c_parser_objc_protocol_refs (c_parser
*parser
)
6211 tree list
= NULL_TREE
;
6212 gcc_assert (c_parser_next_token_is (parser
, CPP_LESS
));
6213 c_parser_consume_token (parser
);
6214 /* Any identifiers, including those declared as type names, are OK
6219 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
6221 c_parser_error (parser
, "expected identifier");
6224 id
= c_parser_peek_token (parser
)->value
;
6225 list
= chainon (list
, build_tree_list (NULL_TREE
, id
));
6226 c_parser_consume_token (parser
);
6227 if (c_parser_next_token_is (parser
, CPP_COMMA
))
6228 c_parser_consume_token (parser
);
6232 c_parser_require (parser
, CPP_GREATER
, "expected %<>%>");
6236 /* Parse an objc-try-catch-statement.
6238 objc-try-catch-statement:
6239 @try compound-statement objc-catch-list[opt]
6240 @try compound-statement objc-catch-list[opt] @finally compound-statement
6243 @catch ( parameter-declaration ) compound-statement
6244 objc-catch-list @catch ( parameter-declaration ) compound-statement
6248 c_parser_objc_try_catch_statement (c_parser
*parser
)
6252 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_AT_TRY
));
6253 c_parser_consume_token (parser
);
6254 loc
= c_parser_peek_token (parser
)->location
;
6255 stmt
= c_parser_compound_statement (parser
);
6256 objc_begin_try_stmt (loc
, stmt
);
6257 while (c_parser_next_token_is_keyword (parser
, RID_AT_CATCH
))
6259 struct c_parm
*parm
;
6260 c_parser_consume_token (parser
);
6261 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
6263 parm
= c_parser_parameter_declaration (parser
, NULL_TREE
);
6266 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
6269 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
6270 objc_begin_catch_clause (grokparm (parm
));
6271 if (c_parser_require (parser
, CPP_OPEN_BRACE
, "expected %<{%>"))
6272 c_parser_compound_statement_nostart (parser
);
6273 objc_finish_catch_clause ();
6275 if (c_parser_next_token_is_keyword (parser
, RID_AT_FINALLY
))
6279 c_parser_consume_token (parser
);
6280 finloc
= c_parser_peek_token (parser
)->location
;
6281 finstmt
= c_parser_compound_statement (parser
);
6282 objc_build_finally_clause (finloc
, finstmt
);
6284 objc_finish_try_stmt ();
6287 /* Parse an objc-synchronized-statement.
6289 objc-synchronized-statement:
6290 @synchronized ( expression ) compound-statement
6294 c_parser_objc_synchronized_statement (c_parser
*parser
)
6298 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_AT_SYNCHRONIZED
));
6299 c_parser_consume_token (parser
);
6300 loc
= c_parser_peek_token (parser
)->location
;
6301 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
6303 expr
= c_parser_expression (parser
).value
;
6304 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
6307 expr
= error_mark_node
;
6308 stmt
= c_parser_compound_statement (parser
);
6309 objc_build_synchronized (loc
, expr
, stmt
);
6312 /* Parse an objc-selector; return NULL_TREE without an error if the
6313 next token is not an objc-selector.
6318 enum struct union if else while do for switch case default
6319 break continue return goto asm sizeof typeof __alignof
6320 unsigned long const short volatile signed restrict _Complex
6321 in out inout bycopy byref oneway int char float double void _Bool
6323 ??? Why this selection of keywords but not, for example, storage
6324 class specifiers? */
6327 c_parser_objc_selector (c_parser
*parser
)
6329 c_token
*token
= c_parser_peek_token (parser
);
6330 tree value
= token
->value
;
6331 if (token
->type
== CPP_NAME
)
6333 c_parser_consume_token (parser
);
6336 if (token
->type
!= CPP_KEYWORD
)
6338 switch (token
->keyword
)
6379 c_parser_consume_token (parser
);
6386 /* Parse an objc-selector-arg.
6390 objc-keywordname-list
6392 objc-keywordname-list:
6394 objc-keywordname-list objc-keywordname
6402 c_parser_objc_selector_arg (c_parser
*parser
)
6404 tree sel
= c_parser_objc_selector (parser
);
6405 tree list
= NULL_TREE
;
6406 if (sel
&& c_parser_next_token_is_not (parser
, CPP_COLON
))
6410 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
6412 list
= chainon (list
, build_tree_list (sel
, NULL_TREE
));
6413 sel
= c_parser_objc_selector (parser
);
6414 if (!sel
&& c_parser_next_token_is_not (parser
, CPP_COLON
))
6420 /* Parse an objc-receiver.
6429 c_parser_objc_receiver (c_parser
*parser
)
6431 if (c_parser_peek_token (parser
)->type
== CPP_NAME
6432 && (c_parser_peek_token (parser
)->id_kind
== C_ID_TYPENAME
6433 || c_parser_peek_token (parser
)->id_kind
== C_ID_CLASSNAME
))
6435 tree id
= c_parser_peek_token (parser
)->value
;
6436 c_parser_consume_token (parser
);
6437 return objc_get_class_reference (id
);
6439 return c_parser_expression (parser
).value
;
6442 /* Parse objc-message-args.
6446 objc-keywordarg-list
6448 objc-keywordarg-list:
6450 objc-keywordarg-list objc-keywordarg
6453 objc-selector : objc-keywordexpr
6458 c_parser_objc_message_args (c_parser
*parser
)
6460 tree sel
= c_parser_objc_selector (parser
);
6461 tree list
= NULL_TREE
;
6462 if (sel
&& c_parser_next_token_is_not (parser
, CPP_COLON
))
6467 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
6469 keywordexpr
= c_parser_objc_keywordexpr (parser
);
6470 list
= chainon (list
, build_tree_list (sel
, keywordexpr
));
6471 sel
= c_parser_objc_selector (parser
);
6472 if (!sel
&& c_parser_next_token_is_not (parser
, CPP_COLON
))
6478 /* Parse an objc-keywordexpr.
6485 c_parser_objc_keywordexpr (c_parser
*parser
)
6487 tree list
= c_parser_expr_list (parser
, true);
6488 if (TREE_CHAIN (list
) == NULL_TREE
)
6490 /* Just return the expression, remove a level of
6492 return TREE_VALUE (list
);
6496 /* We have a comma expression, we will collapse later. */
6502 /* Handle pragmas. Some OpenMP pragmas are associated with, and therefore
6503 should be considered, statements. ALLOW_STMT is true if we're within
6504 the context of a function and such pragmas are to be allowed. Returns
6505 true if we actually parsed such a pragma. */
6508 c_parser_pragma (c_parser
*parser
, enum pragma_context context
)
6512 id
= c_parser_peek_token (parser
)->pragma_kind
;
6513 gcc_assert (id
!= PRAGMA_NONE
);
6517 case PRAGMA_OMP_BARRIER
:
6518 if (context
!= pragma_compound
)
6520 if (context
== pragma_stmt
)
6521 c_parser_error (parser
, "%<#pragma omp barrier%> may only be "
6522 "used in compound statements");
6525 c_parser_omp_barrier (parser
);
6528 case PRAGMA_OMP_FLUSH
:
6529 if (context
!= pragma_compound
)
6531 if (context
== pragma_stmt
)
6532 c_parser_error (parser
, "%<#pragma omp flush%> may only be "
6533 "used in compound statements");
6536 c_parser_omp_flush (parser
);
6539 case PRAGMA_OMP_THREADPRIVATE
:
6540 c_parser_omp_threadprivate (parser
);
6543 case PRAGMA_OMP_SECTION
:
6544 error ("%<#pragma omp section%> may only be used in "
6545 "%<#pragma omp sections%> construct");
6546 c_parser_skip_until_found (parser
, CPP_PRAGMA_EOL
, NULL
);
6549 case PRAGMA_GCC_PCH_PREPROCESS
:
6550 c_parser_error (parser
, "%<#pragma GCC pch_preprocess%> must be first");
6551 c_parser_skip_until_found (parser
, CPP_PRAGMA_EOL
, NULL
);
6555 if (id
< PRAGMA_FIRST_EXTERNAL
)
6557 if (context
== pragma_external
)
6560 c_parser_error (parser
, "expected declaration specifiers");
6561 c_parser_skip_until_found (parser
, CPP_PRAGMA_EOL
, NULL
);
6564 c_parser_omp_construct (parser
);
6570 c_parser_consume_pragma (parser
);
6571 c_invoke_pragma_handler (id
);
6573 /* Skip to EOL, but suppress any error message. Those will have been
6574 generated by the handler routine through calling error, as opposed
6575 to calling c_parser_error. */
6576 parser
->error
= true;
6577 c_parser_skip_to_pragma_eol (parser
);
6582 /* The interface the pragma parsers have to the lexer. */
6585 pragma_lex (tree
*value
)
6587 c_token
*tok
= c_parser_peek_token (the_parser
);
6588 enum cpp_ttype ret
= tok
->type
;
6590 *value
= tok
->value
;
6591 if (ret
== CPP_PRAGMA_EOL
|| ret
== CPP_EOF
)
6595 if (ret
== CPP_KEYWORD
)
6597 c_parser_consume_token (the_parser
);
6604 c_parser_pragma_pch_preprocess (c_parser
*parser
)
6608 c_parser_consume_pragma (parser
);
6609 if (c_parser_next_token_is (parser
, CPP_STRING
))
6611 name
= c_parser_peek_token (parser
)->value
;
6612 c_parser_consume_token (parser
);
6615 c_parser_error (parser
, "expected string literal");
6616 c_parser_skip_to_pragma_eol (parser
);
6619 c_common_pch_pragma (parse_in
, TREE_STRING_POINTER (name
));
6622 /* OpenMP 2.5 parsing routines. */
6624 /* Returns name of the next clause.
6625 If the clause is not recognized PRAGMA_OMP_CLAUSE_NONE is returned and
6626 the token is not consumed. Otherwise appropriate pragma_omp_clause is
6627 returned and the token is consumed. */
6629 static pragma_omp_clause
6630 c_parser_omp_clause_name (c_parser
*parser
)
6632 pragma_omp_clause result
= PRAGMA_OMP_CLAUSE_NONE
;
6634 if (c_parser_next_token_is_keyword (parser
, RID_IF
))
6635 result
= PRAGMA_OMP_CLAUSE_IF
;
6636 else if (c_parser_next_token_is_keyword (parser
, RID_DEFAULT
))
6637 result
= PRAGMA_OMP_CLAUSE_DEFAULT
;
6638 else if (c_parser_next_token_is (parser
, CPP_NAME
))
6640 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
6645 if (!strcmp ("copyin", p
))
6646 result
= PRAGMA_OMP_CLAUSE_COPYIN
;
6647 else if (!strcmp ("copyprivate", p
))
6648 result
= PRAGMA_OMP_CLAUSE_COPYPRIVATE
;
6651 if (!strcmp ("firstprivate", p
))
6652 result
= PRAGMA_OMP_CLAUSE_FIRSTPRIVATE
;
6655 if (!strcmp ("lastprivate", p
))
6656 result
= PRAGMA_OMP_CLAUSE_LASTPRIVATE
;
6659 if (!strcmp ("nowait", p
))
6660 result
= PRAGMA_OMP_CLAUSE_NOWAIT
;
6661 else if (!strcmp ("num_threads", p
))
6662 result
= PRAGMA_OMP_CLAUSE_NUM_THREADS
;
6665 if (!strcmp ("ordered", p
))
6666 result
= PRAGMA_OMP_CLAUSE_ORDERED
;
6669 if (!strcmp ("private", p
))
6670 result
= PRAGMA_OMP_CLAUSE_PRIVATE
;
6673 if (!strcmp ("reduction", p
))
6674 result
= PRAGMA_OMP_CLAUSE_REDUCTION
;
6677 if (!strcmp ("schedule", p
))
6678 result
= PRAGMA_OMP_CLAUSE_SCHEDULE
;
6679 else if (!strcmp ("shared", p
))
6680 result
= PRAGMA_OMP_CLAUSE_SHARED
;
6685 if (result
!= PRAGMA_OMP_CLAUSE_NONE
)
6686 c_parser_consume_token (parser
);
6691 /* Validate that a clause of the given type does not already exist. */
6694 check_no_duplicate_clause (tree clauses
, enum tree_code code
, const char *name
)
6698 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
6699 if (OMP_CLAUSE_CODE (c
) == code
)
6701 error ("too many %qs clauses", name
);
6709 variable-list , identifier
6711 If KIND is nonzero, create the appropriate node and install the decl
6712 in OMP_CLAUSE_DECL and add the node to the head of the list.
6714 If KIND is zero, create a TREE_LIST with the decl in TREE_PURPOSE;
6715 return the list created. */
6718 c_parser_omp_variable_list (c_parser
*parser
, enum omp_clause_code kind
,
6721 if (c_parser_next_token_is_not (parser
, CPP_NAME
)
6722 || c_parser_peek_token (parser
)->id_kind
!= C_ID_ID
)
6723 c_parser_error (parser
, "expected identifier");
6725 while (c_parser_next_token_is (parser
, CPP_NAME
)
6726 && c_parser_peek_token (parser
)->id_kind
== C_ID_ID
)
6728 tree t
= lookup_name (c_parser_peek_token (parser
)->value
);
6731 undeclared_variable (c_parser_peek_token (parser
)->value
,
6732 c_parser_peek_token (parser
)->location
);
6733 else if (t
== error_mark_node
)
6737 tree u
= build_omp_clause (kind
);
6738 OMP_CLAUSE_DECL (u
) = t
;
6739 OMP_CLAUSE_CHAIN (u
) = list
;
6743 list
= tree_cons (t
, NULL_TREE
, list
);
6745 c_parser_consume_token (parser
);
6747 if (c_parser_next_token_is_not (parser
, CPP_COMMA
))
6750 c_parser_consume_token (parser
);
6756 /* Similarly, but expect leading and trailing parenthesis. This is a very
6757 common case for omp clauses. */
6760 c_parser_omp_var_list_parens (c_parser
*parser
, enum tree_code kind
, tree list
)
6762 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
6764 list
= c_parser_omp_variable_list (parser
, kind
, list
);
6765 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
6771 copyin ( variable-list ) */
6774 c_parser_omp_clause_copyin (c_parser
*parser
, tree list
)
6776 return c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_COPYIN
, list
);
6780 copyprivate ( variable-list ) */
6783 c_parser_omp_clause_copyprivate (c_parser
*parser
, tree list
)
6785 return c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_COPYPRIVATE
, list
);
6789 default ( shared | none ) */
6792 c_parser_omp_clause_default (c_parser
*parser
, tree list
)
6794 enum omp_clause_default_kind kind
= OMP_CLAUSE_DEFAULT_UNSPECIFIED
;
6797 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
6799 if (c_parser_next_token_is (parser
, CPP_NAME
))
6801 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
6806 if (strcmp ("none", p
) != 0)
6808 kind
= OMP_CLAUSE_DEFAULT_NONE
;
6812 if (strcmp ("shared", p
) != 0)
6814 kind
= OMP_CLAUSE_DEFAULT_SHARED
;
6821 c_parser_consume_token (parser
);
6826 c_parser_error (parser
, "expected %<none%> or %<shared%>");
6828 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
6830 if (kind
== OMP_CLAUSE_DEFAULT_UNSPECIFIED
)
6833 check_no_duplicate_clause (list
, OMP_CLAUSE_DEFAULT
, "default");
6834 c
= build_omp_clause (OMP_CLAUSE_DEFAULT
);
6835 OMP_CLAUSE_CHAIN (c
) = list
;
6836 OMP_CLAUSE_DEFAULT_KIND (c
) = kind
;
6842 firstprivate ( variable-list ) */
6845 c_parser_omp_clause_firstprivate (c_parser
*parser
, tree list
)
6847 return c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_FIRSTPRIVATE
, list
);
6851 if ( expression ) */
6854 c_parser_omp_clause_if (c_parser
*parser
, tree list
)
6856 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
6858 tree t
= c_parser_paren_condition (parser
);
6861 check_no_duplicate_clause (list
, OMP_CLAUSE_IF
, "if");
6863 c
= build_omp_clause (OMP_CLAUSE_IF
);
6864 OMP_CLAUSE_IF_EXPR (c
) = t
;
6865 OMP_CLAUSE_CHAIN (c
) = list
;
6869 c_parser_error (parser
, "expected %<(%>");
6875 lastprivate ( variable-list ) */
6878 c_parser_omp_clause_lastprivate (c_parser
*parser
, tree list
)
6880 return c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_LASTPRIVATE
, list
);
6887 c_parser_omp_clause_nowait (c_parser
*parser ATTRIBUTE_UNUSED
, tree list
)
6891 check_no_duplicate_clause (list
, OMP_CLAUSE_NOWAIT
, "nowait");
6893 c
= build_omp_clause (OMP_CLAUSE_NOWAIT
);
6894 OMP_CLAUSE_CHAIN (c
) = list
;
6899 num_threads ( expression ) */
6902 c_parser_omp_clause_num_threads (c_parser
*parser
, tree list
)
6904 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
6906 tree c
, t
= c_parser_expression (parser
).value
;
6908 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
6910 if (!INTEGRAL_TYPE_P (TREE_TYPE (t
)))
6912 c_parser_error (parser
, "expected integer expression");
6916 /* Attempt to statically determine when the number isn't positive. */
6917 c
= fold_build2 (LE_EXPR
, boolean_type_node
, t
,
6918 build_int_cst (TREE_TYPE (t
), 0));
6919 if (c
== boolean_true_node
)
6921 warning (0, "%<num_threads%> value must be positive");
6922 t
= integer_one_node
;
6925 check_no_duplicate_clause (list
, OMP_CLAUSE_NUM_THREADS
, "num_threads");
6927 c
= build_omp_clause (OMP_CLAUSE_NUM_THREADS
);
6928 OMP_CLAUSE_NUM_THREADS_EXPR (c
) = t
;
6929 OMP_CLAUSE_CHAIN (c
) = list
;
6940 c_parser_omp_clause_ordered (c_parser
*parser ATTRIBUTE_UNUSED
, tree list
)
6944 check_no_duplicate_clause (list
, OMP_CLAUSE_ORDERED
, "ordered");
6946 c
= build_omp_clause (OMP_CLAUSE_ORDERED
);
6947 OMP_CLAUSE_CHAIN (c
) = list
;
6952 private ( variable-list ) */
6955 c_parser_omp_clause_private (c_parser
*parser
, tree list
)
6957 return c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_PRIVATE
, list
);
6961 reduction ( reduction-operator : variable-list )
6964 One of: + * - & ^ | && || */
6967 c_parser_omp_clause_reduction (c_parser
*parser
, tree list
)
6969 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
6971 enum tree_code code
;
6973 switch (c_parser_peek_token (parser
)->type
)
6985 code
= BIT_AND_EXPR
;
6988 code
= BIT_XOR_EXPR
;
6991 code
= BIT_IOR_EXPR
;
6994 code
= TRUTH_ANDIF_EXPR
;
6997 code
= TRUTH_ORIF_EXPR
;
7000 c_parser_error (parser
,
7001 "expected %<+%>, %<*%>, %<-%>, %<&%>, "
7002 "%<^%>, %<|%>, %<&&%>, or %<||%>");
7003 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, 0);
7006 c_parser_consume_token (parser
);
7007 if (c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
7011 nl
= c_parser_omp_variable_list (parser
, OMP_CLAUSE_REDUCTION
, list
);
7012 for (c
= nl
; c
!= list
; c
= OMP_CLAUSE_CHAIN (c
))
7013 OMP_CLAUSE_REDUCTION_CODE (c
) = code
;
7017 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
7023 schedule ( schedule-kind )
7024 schedule ( schedule-kind , expression )
7027 static | dynamic | guided | runtime
7031 c_parser_omp_clause_schedule (c_parser
*parser
, tree list
)
7035 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
7038 c
= build_omp_clause (OMP_CLAUSE_SCHEDULE
);
7040 if (c_parser_next_token_is (parser
, CPP_NAME
))
7042 tree kind
= c_parser_peek_token (parser
)->value
;
7043 const char *p
= IDENTIFIER_POINTER (kind
);
7048 if (strcmp ("dynamic", p
) != 0)
7050 OMP_CLAUSE_SCHEDULE_KIND (c
) = OMP_CLAUSE_SCHEDULE_DYNAMIC
;
7054 if (strcmp ("guided", p
) != 0)
7056 OMP_CLAUSE_SCHEDULE_KIND (c
) = OMP_CLAUSE_SCHEDULE_GUIDED
;
7060 if (strcmp ("runtime", p
) != 0)
7062 OMP_CLAUSE_SCHEDULE_KIND (c
) = OMP_CLAUSE_SCHEDULE_RUNTIME
;
7069 else if (c_parser_next_token_is_keyword (parser
, RID_STATIC
))
7070 OMP_CLAUSE_SCHEDULE_KIND (c
) = OMP_CLAUSE_SCHEDULE_STATIC
;
7074 c_parser_consume_token (parser
);
7075 if (c_parser_next_token_is (parser
, CPP_COMMA
))
7077 c_parser_consume_token (parser
);
7079 t
= c_parser_expr_no_commas (parser
, NULL
).value
;
7081 if (OMP_CLAUSE_SCHEDULE_KIND (c
) == OMP_CLAUSE_SCHEDULE_RUNTIME
)
7082 error ("schedule %<runtime%> does not take "
7083 "a %<chunk_size%> parameter");
7084 else if (TREE_CODE (TREE_TYPE (t
)) == INTEGER_TYPE
)
7085 OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c
) = t
;
7087 c_parser_error (parser
, "expected integer expression");
7089 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
7092 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
7093 "expected %<,%> or %<)%>");
7095 check_no_duplicate_clause (list
, OMP_CLAUSE_SCHEDULE
, "schedule");
7096 OMP_CLAUSE_CHAIN (c
) = list
;
7100 c_parser_error (parser
, "invalid schedule kind");
7101 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, 0);
7106 shared ( variable-list ) */
7109 c_parser_omp_clause_shared (c_parser
*parser
, tree list
)
7111 return c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_SHARED
, list
);
7114 /* Parse all OpenMP clauses. The set clauses allowed by the directive
7115 is a bitmask in MASK. Return the list of clauses found; the result
7116 of clause default goes in *pdefault. */
7119 c_parser_omp_all_clauses (c_parser
*parser
, unsigned int mask
,
7122 tree clauses
= NULL
;
7124 while (c_parser_next_token_is_not (parser
, CPP_PRAGMA_EOL
))
7126 const pragma_omp_clause c_kind
= c_parser_omp_clause_name (parser
);
7128 tree prev
= clauses
;
7132 case PRAGMA_OMP_CLAUSE_COPYIN
:
7133 clauses
= c_parser_omp_clause_copyin (parser
, clauses
);
7136 case PRAGMA_OMP_CLAUSE_COPYPRIVATE
:
7137 clauses
= c_parser_omp_clause_copyprivate (parser
, clauses
);
7138 c_name
= "copyprivate";
7140 case PRAGMA_OMP_CLAUSE_DEFAULT
:
7141 clauses
= c_parser_omp_clause_default (parser
, clauses
);
7144 case PRAGMA_OMP_CLAUSE_FIRSTPRIVATE
:
7145 clauses
= c_parser_omp_clause_firstprivate (parser
, clauses
);
7146 c_name
= "firstprivate";
7148 case PRAGMA_OMP_CLAUSE_IF
:
7149 clauses
= c_parser_omp_clause_if (parser
, clauses
);
7152 case PRAGMA_OMP_CLAUSE_LASTPRIVATE
:
7153 clauses
= c_parser_omp_clause_lastprivate (parser
, clauses
);
7154 c_name
= "lastprivate";
7156 case PRAGMA_OMP_CLAUSE_NOWAIT
:
7157 clauses
= c_parser_omp_clause_nowait (parser
, clauses
);
7160 case PRAGMA_OMP_CLAUSE_NUM_THREADS
:
7161 clauses
= c_parser_omp_clause_num_threads (parser
, clauses
);
7162 c_name
= "num_threads";
7164 case PRAGMA_OMP_CLAUSE_ORDERED
:
7165 clauses
= c_parser_omp_clause_ordered (parser
, clauses
);
7168 case PRAGMA_OMP_CLAUSE_PRIVATE
:
7169 clauses
= c_parser_omp_clause_private (parser
, clauses
);
7172 case PRAGMA_OMP_CLAUSE_REDUCTION
:
7173 clauses
= c_parser_omp_clause_reduction (parser
, clauses
);
7174 c_name
= "reduction";
7176 case PRAGMA_OMP_CLAUSE_SCHEDULE
:
7177 clauses
= c_parser_omp_clause_schedule (parser
, clauses
);
7178 c_name
= "schedule";
7180 case PRAGMA_OMP_CLAUSE_SHARED
:
7181 clauses
= c_parser_omp_clause_shared (parser
, clauses
);
7185 c_parser_error (parser
, "expected %<#pragma omp%> clause");
7189 if (((mask
>> c_kind
) & 1) == 0 && !parser
->error
)
7191 /* Remove the invalid clause(s) from the list to avoid
7192 confusing the rest of the compiler. */
7194 error ("%qs is not valid for %qs", c_name
, where
);
7199 c_parser_skip_to_pragma_eol (parser
);
7201 return c_finish_omp_clauses (clauses
);
7208 In practice, we're also interested in adding the statement to an
7209 outer node. So it is convenient if we work around the fact that
7210 c_parser_statement calls add_stmt. */
7213 c_parser_omp_structured_block (c_parser
*parser
)
7215 tree stmt
= push_stmt_list ();
7216 c_parser_statement (parser
);
7217 return pop_stmt_list (stmt
);
7221 # pragma omp atomic new-line
7225 x binop= expr | x++ | ++x | x-- | --x
7227 +, *, -, /, &, ^, |, <<, >>
7229 where x is an lvalue expression with scalar type. */
7232 c_parser_omp_atomic (c_parser
*parser
)
7236 enum tree_code code
;
7238 c_parser_skip_to_pragma_eol (parser
);
7240 lhs
= c_parser_unary_expression (parser
).value
;
7241 switch (TREE_CODE (lhs
))
7245 c_parser_skip_to_end_of_block_or_statement (parser
);
7248 case PREINCREMENT_EXPR
:
7249 case POSTINCREMENT_EXPR
:
7250 lhs
= TREE_OPERAND (lhs
, 0);
7252 rhs
= integer_one_node
;
7255 case PREDECREMENT_EXPR
:
7256 case POSTDECREMENT_EXPR
:
7257 lhs
= TREE_OPERAND (lhs
, 0);
7259 rhs
= integer_one_node
;
7263 switch (c_parser_peek_token (parser
)->type
)
7269 code
= TRUNC_DIV_EXPR
;
7284 code
= BIT_AND_EXPR
;
7287 code
= BIT_IOR_EXPR
;
7290 code
= BIT_XOR_EXPR
;
7293 c_parser_error (parser
,
7294 "invalid operator for %<#pragma omp atomic%>");
7298 c_parser_consume_token (parser
);
7299 rhs
= c_parser_expression (parser
).value
;
7302 stmt
= c_finish_omp_atomic (code
, lhs
, rhs
);
7303 if (stmt
!= error_mark_node
)
7305 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
7310 # pragma omp barrier new-line
7314 c_parser_omp_barrier (c_parser
*parser
)
7316 c_parser_consume_pragma (parser
);
7317 c_parser_skip_to_pragma_eol (parser
);
7319 c_finish_omp_barrier ();
7323 # pragma omp critical [(name)] new-line
7328 c_parser_omp_critical (c_parser
*parser
)
7330 tree stmt
, name
= NULL
;
7332 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
7334 c_parser_consume_token (parser
);
7335 if (c_parser_next_token_is (parser
, CPP_NAME
))
7337 name
= c_parser_peek_token (parser
)->value
;
7338 c_parser_consume_token (parser
);
7339 c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
7342 c_parser_error (parser
, "expected identifier");
7344 else if (c_parser_next_token_is_not (parser
, CPP_PRAGMA_EOL
))
7345 c_parser_error (parser
, "expected %<(%> or end of line");
7346 c_parser_skip_to_pragma_eol (parser
);
7348 stmt
= c_parser_omp_structured_block (parser
);
7349 return c_finish_omp_critical (stmt
, name
);
7353 # pragma omp flush flush-vars[opt] new-line
7356 ( variable-list ) */
7359 c_parser_omp_flush (c_parser
*parser
)
7361 c_parser_consume_pragma (parser
);
7362 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
7363 c_parser_omp_var_list_parens (parser
, 0, NULL
);
7364 else if (c_parser_next_token_is_not (parser
, CPP_PRAGMA_EOL
))
7365 c_parser_error (parser
, "expected %<(%> or end of line");
7366 c_parser_skip_to_pragma_eol (parser
);
7368 c_finish_omp_flush ();
7371 /* Parse the restricted form of the for statment allowed by OpenMP.
7372 The real trick here is to determine the loop control variable early
7373 so that we can push a new decl if necessary to make it private. */
7376 c_parser_omp_for_loop (c_parser
*parser
)
7378 tree decl
, cond
, incr
, save_break
, save_cont
, body
, init
;
7381 if (!c_parser_next_token_is_keyword (parser
, RID_FOR
))
7383 c_parser_error (parser
, "for statement expected");
7386 loc
= c_parser_peek_token (parser
)->location
;
7387 c_parser_consume_token (parser
);
7389 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
7392 /* Parse the initialization declaration or expression. */
7393 if (c_parser_next_token_starts_declspecs (parser
))
7395 c_parser_declaration_or_fndef (parser
, true, true, true, true);
7396 decl
= check_for_loop_decls ();
7401 else if (c_parser_next_token_is (parser
, CPP_NAME
)
7402 && c_parser_peek_2nd_token (parser
)->type
== CPP_EQ
)
7404 decl
= c_parser_postfix_expression (parser
).value
;
7406 c_parser_require (parser
, CPP_EQ
, "expected %<=%>");
7408 init
= c_parser_expr_no_commas (parser
, NULL
).value
;
7409 init
= build_modify_expr (decl
, NOP_EXPR
, init
);
7410 init
= c_process_expr_stmt (init
);
7412 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
7417 /* Parse the loop condition. */
7419 if (c_parser_next_token_is_not (parser
, CPP_SEMICOLON
))
7421 cond
= c_parser_expression_conv (parser
).value
;
7422 cond
= c_objc_common_truthvalue_conversion (cond
);
7423 if (CAN_HAVE_LOCATION_P (cond
))
7424 SET_EXPR_LOCATION (cond
, input_location
);
7426 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
7428 /* Parse the increment expression. */
7430 if (c_parser_next_token_is_not (parser
, CPP_CLOSE_PAREN
))
7431 incr
= c_process_expr_stmt (c_parser_expression (parser
).value
);
7432 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
7435 save_break
= c_break_label
;
7436 c_break_label
= size_one_node
;
7437 save_cont
= c_cont_label
;
7438 c_cont_label
= NULL_TREE
;
7439 body
= push_stmt_list ();
7441 add_stmt (c_parser_c99_block_statement (parser
));
7443 add_stmt (build1 (LABEL_EXPR
, void_type_node
, c_cont_label
));
7445 body
= pop_stmt_list (body
);
7446 c_break_label
= save_break
;
7447 c_cont_label
= save_cont
;
7449 /* Only bother calling c_finish_omp_for if we havn't already generated
7450 an error from the initialization parsing. */
7451 if (decl
!= NULL
&& decl
!= error_mark_node
&& init
!= error_mark_node
)
7452 return c_finish_omp_for (loc
, decl
, init
, cond
, incr
, body
, NULL
);
7456 c_parser_error (parser
, "expected iteration declaration or initialization");
7457 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
7458 decl
= init
= cond
= incr
= NULL_TREE
;
7463 #pragma omp for for-clause[optseq] new-line
7467 #define OMP_FOR_CLAUSE_MASK \
7468 ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
7469 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
7470 | (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
7471 | (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \
7472 | (1u << PRAGMA_OMP_CLAUSE_ORDERED) \
7473 | (1u << PRAGMA_OMP_CLAUSE_SCHEDULE) \
7474 | (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
7477 c_parser_omp_for (c_parser
*parser
)
7479 tree block
, clauses
, ret
;
7481 clauses
= c_parser_omp_all_clauses (parser
, OMP_FOR_CLAUSE_MASK
,
7484 block
= c_begin_compound_stmt (true);
7485 ret
= c_parser_omp_for_loop (parser
);
7487 OMP_FOR_CLAUSES (ret
) = clauses
;
7488 block
= c_end_compound_stmt (block
, true);
7495 # pragma omp master new-line
7500 c_parser_omp_master (c_parser
*parser
)
7502 c_parser_skip_to_pragma_eol (parser
);
7503 return c_finish_omp_master (c_parser_omp_structured_block (parser
));
7507 # pragma omp ordered new-line
7512 c_parser_omp_ordered (c_parser
*parser
)
7514 c_parser_skip_to_pragma_eol (parser
);
7515 return c_finish_omp_ordered (c_parser_omp_structured_block (parser
));
7521 { section-sequence }
7524 section-directive[opt] structured-block
7525 section-sequence section-directive structured-block */
7528 c_parser_omp_sections_scope (c_parser
*parser
)
7531 bool error_suppress
= false;
7534 if (!c_parser_require (parser
, CPP_OPEN_BRACE
, "expected %<{%>"))
7536 /* Avoid skipping until the end of the block. */
7537 parser
->error
= false;
7541 stmt
= push_stmt_list ();
7543 loc
= c_parser_peek_token (parser
)->location
;
7544 if (c_parser_peek_token (parser
)->pragma_kind
!= PRAGMA_OMP_SECTION
)
7546 substmt
= push_stmt_list ();
7550 c_parser_statement (parser
);
7552 if (c_parser_peek_token (parser
)->pragma_kind
== PRAGMA_OMP_SECTION
)
7554 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
7556 if (c_parser_next_token_is (parser
, CPP_EOF
))
7560 substmt
= pop_stmt_list (substmt
);
7561 substmt
= build1 (OMP_SECTION
, void_type_node
, substmt
);
7562 SET_EXPR_LOCATION (substmt
, loc
);
7568 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
7570 if (c_parser_next_token_is (parser
, CPP_EOF
))
7573 loc
= c_parser_peek_token (parser
)->location
;
7574 if (c_parser_peek_token (parser
)->pragma_kind
== PRAGMA_OMP_SECTION
)
7576 c_parser_consume_pragma (parser
);
7577 c_parser_skip_to_pragma_eol (parser
);
7578 error_suppress
= false;
7580 else if (!error_suppress
)
7582 error ("expected %<#pragma omp section%> or %<}%>");
7583 error_suppress
= true;
7586 substmt
= c_parser_omp_structured_block (parser
);
7587 substmt
= build1 (OMP_SECTION
, void_type_node
, substmt
);
7588 SET_EXPR_LOCATION (substmt
, loc
);
7591 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
,
7592 "expected %<#pragma omp section%> or %<}%>");
7594 substmt
= pop_stmt_list (stmt
);
7596 stmt
= make_node (OMP_SECTIONS
);
7597 TREE_TYPE (stmt
) = void_type_node
;
7598 OMP_SECTIONS_BODY (stmt
) = substmt
;
7600 return add_stmt (stmt
);
7604 # pragma omp sections sections-clause[optseq] newline
7608 #define OMP_SECTIONS_CLAUSE_MASK \
7609 ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
7610 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
7611 | (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
7612 | (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \
7613 | (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
7616 c_parser_omp_sections (c_parser
*parser
)
7618 tree block
, clauses
, ret
;
7620 clauses
= c_parser_omp_all_clauses (parser
, OMP_SECTIONS_CLAUSE_MASK
,
7621 "#pragma omp sections");
7623 block
= c_begin_compound_stmt (true);
7624 ret
= c_parser_omp_sections_scope (parser
);
7626 OMP_SECTIONS_CLAUSES (ret
) = clauses
;
7627 block
= c_end_compound_stmt (block
, true);
7634 # pragma parallel parallel-clause new-line
7635 # pragma parallel for parallel-for-clause new-line
7636 # pragma parallel sections parallel-sections-clause new-line
7639 #define OMP_PARALLEL_CLAUSE_MASK \
7640 ( (1u << PRAGMA_OMP_CLAUSE_IF) \
7641 | (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
7642 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
7643 | (1u << PRAGMA_OMP_CLAUSE_DEFAULT) \
7644 | (1u << PRAGMA_OMP_CLAUSE_SHARED) \
7645 | (1u << PRAGMA_OMP_CLAUSE_COPYIN) \
7646 | (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \
7647 | (1u << PRAGMA_OMP_CLAUSE_NUM_THREADS))
7650 c_parser_omp_parallel (c_parser
*parser
)
7652 enum pragma_kind p_kind
= PRAGMA_OMP_PARALLEL
;
7653 const char *p_name
= "#pragma omp parallel";
7654 tree stmt
, clauses
, par_clause
, ws_clause
, block
;
7655 unsigned int mask
= OMP_PARALLEL_CLAUSE_MASK
;
7657 if (c_parser_next_token_is_keyword (parser
, RID_FOR
))
7659 c_parser_consume_token (parser
);
7660 p_kind
= PRAGMA_OMP_PARALLEL_FOR
;
7661 p_name
= "#pragma omp parallel for";
7662 mask
|= OMP_FOR_CLAUSE_MASK
;
7663 mask
&= ~(1u << PRAGMA_OMP_CLAUSE_NOWAIT
);
7665 else if (c_parser_next_token_is (parser
, CPP_NAME
))
7667 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
7668 if (strcmp (p
, "sections") == 0)
7670 c_parser_consume_token (parser
);
7671 p_kind
= PRAGMA_OMP_PARALLEL_SECTIONS
;
7672 p_name
= "#pragma omp parallel sections";
7673 mask
|= OMP_SECTIONS_CLAUSE_MASK
;
7674 mask
&= ~(1u << PRAGMA_OMP_CLAUSE_NOWAIT
);
7678 clauses
= c_parser_omp_all_clauses (parser
, mask
, p_name
);
7682 case PRAGMA_OMP_PARALLEL
:
7683 block
= c_begin_omp_parallel ();
7684 c_parser_statement (parser
);
7685 stmt
= c_finish_omp_parallel (clauses
, block
);
7688 case PRAGMA_OMP_PARALLEL_FOR
:
7689 block
= c_begin_omp_parallel ();
7690 c_split_parallel_clauses (clauses
, &par_clause
, &ws_clause
);
7691 stmt
= c_parser_omp_for_loop (parser
);
7693 OMP_FOR_CLAUSES (stmt
) = ws_clause
;
7694 stmt
= c_finish_omp_parallel (par_clause
, block
);
7695 OMP_PARALLEL_COMBINED (stmt
) = 1;
7698 case PRAGMA_OMP_PARALLEL_SECTIONS
:
7699 block
= c_begin_omp_parallel ();
7700 c_split_parallel_clauses (clauses
, &par_clause
, &ws_clause
);
7701 stmt
= c_parser_omp_sections_scope (parser
);
7703 OMP_SECTIONS_CLAUSES (stmt
) = ws_clause
;
7704 stmt
= c_finish_omp_parallel (par_clause
, block
);
7705 OMP_PARALLEL_COMBINED (stmt
) = 1;
7716 # pragma omp single single-clause[optseq] new-line
7720 #define OMP_SINGLE_CLAUSE_MASK \
7721 ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
7722 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
7723 | (1u << PRAGMA_OMP_CLAUSE_COPYPRIVATE) \
7724 | (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
7727 c_parser_omp_single (c_parser
*parser
)
7729 tree stmt
= make_node (OMP_SINGLE
);
7730 TREE_TYPE (stmt
) = void_type_node
;
7732 OMP_SINGLE_CLAUSES (stmt
)
7733 = c_parser_omp_all_clauses (parser
, OMP_SINGLE_CLAUSE_MASK
,
7734 "#pragma omp single");
7735 OMP_SINGLE_BODY (stmt
) = c_parser_omp_structured_block (parser
);
7737 return add_stmt (stmt
);
7741 /* Main entry point to parsing most OpenMP pragmas. */
7744 c_parser_omp_construct (c_parser
*parser
)
7746 enum pragma_kind p_kind
;
7750 loc
= c_parser_peek_token (parser
)->location
;
7751 p_kind
= c_parser_peek_token (parser
)->pragma_kind
;
7752 c_parser_consume_pragma (parser
);
7754 /* For all constructs below except #pragma omp atomic
7755 MUST_NOT_THROW catch handlers are needed when exceptions
7757 if (p_kind
!= PRAGMA_OMP_ATOMIC
)
7758 c_maybe_initialize_eh ();
7762 case PRAGMA_OMP_ATOMIC
:
7763 c_parser_omp_atomic (parser
);
7765 case PRAGMA_OMP_CRITICAL
:
7766 stmt
= c_parser_omp_critical (parser
);
7768 case PRAGMA_OMP_FOR
:
7769 stmt
= c_parser_omp_for (parser
);
7771 case PRAGMA_OMP_MASTER
:
7772 stmt
= c_parser_omp_master (parser
);
7774 case PRAGMA_OMP_ORDERED
:
7775 stmt
= c_parser_omp_ordered (parser
);
7777 case PRAGMA_OMP_PARALLEL
:
7778 stmt
= c_parser_omp_parallel (parser
);
7780 case PRAGMA_OMP_SECTIONS
:
7781 stmt
= c_parser_omp_sections (parser
);
7783 case PRAGMA_OMP_SINGLE
:
7784 stmt
= c_parser_omp_single (parser
);
7791 SET_EXPR_LOCATION (stmt
, loc
);
7796 # pragma omp threadprivate (variable-list) */
7799 c_parser_omp_threadprivate (c_parser
*parser
)
7803 c_parser_consume_pragma (parser
);
7804 vars
= c_parser_omp_var_list_parens (parser
, 0, NULL
);
7806 /* Mark every variable in VARS to be assigned thread local storage. */
7807 for (t
= vars
; t
; t
= TREE_CHAIN (t
))
7809 tree v
= TREE_PURPOSE (t
);
7811 /* If V had already been marked threadprivate, it doesn't matter
7812 whether it had been used prior to this point. */
7813 if (TREE_USED (v
) && !C_DECL_THREADPRIVATE_P (v
))
7814 error ("%qE declared %<threadprivate%> after first use", v
);
7815 else if (! TREE_STATIC (v
) && ! DECL_EXTERNAL (v
))
7816 error ("automatic variable %qE cannot be %<threadprivate%>", v
);
7817 else if (! COMPLETE_TYPE_P (TREE_TYPE (v
)))
7818 error ("%<threadprivate%> %qE has incomplete type", v
);
7821 if (! DECL_THREAD_LOCAL_P (v
))
7823 DECL_TLS_MODEL (v
) = decl_default_tls_model (v
);
7824 /* If rtl has been already set for this var, call
7825 make_decl_rtl once again, so that encode_section_info
7826 has a chance to look at the new decl flags. */
7827 if (DECL_RTL_SET_P (v
))
7830 C_DECL_THREADPRIVATE_P (v
) = 1;
7834 c_parser_skip_to_pragma_eol (parser
);
7838 /* Parse a single source file. */
7843 /* Use local storage to begin. If the first token is a pragma, parse it.
7844 If it is #pragma GCC pch_preprocess, then this will load a PCH file
7845 which will cause garbage collection. */
7848 memset (&tparser
, 0, sizeof tparser
);
7849 the_parser
= &tparser
;
7851 if (c_parser_peek_token (&tparser
)->pragma_kind
== PRAGMA_GCC_PCH_PREPROCESS
)
7852 c_parser_pragma_pch_preprocess (&tparser
);
7854 the_parser
= GGC_NEW (c_parser
);
7855 *the_parser
= tparser
;
7857 c_parser_translation_unit (the_parser
);
7861 #include "gt-c-parser.h"