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 2, 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 COPYING. If not, write to the Free
22 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
27 Make sure all relevant comments, and all relevant code from all
28 actions, brought over from old parser. Verify exact correspondence
31 Add testcases covering every input symbol in every state in old and
34 Include full syntax for GNU C, including erroneous cases accepted
35 with error messages, in syntax productions in comments.
37 Make more diagnostics in the front end generally take an explicit
38 location rather than implicitly using input_location. */
42 #include "coretypes.h"
46 #include "langhooks.h"
62 /* Objective-C specific parser/lexer information. */
64 static int objc_pq_context
= 0;
66 /* The following flag is needed to contextualize Objective-C lexical
67 analysis. In some cases (e.g., 'int NSObject;'), it is undesirable
68 to bind an identifier to an Objective-C class, even if a class with
70 static int objc_need_raw_identifier
= 0;
71 #define OBJC_NEED_RAW_IDENTIFIER(VAL) \
73 if (c_dialect_objc ()) \
74 objc_need_raw_identifier = VAL; \
77 /* The reserved keyword table. */
81 ENUM_BITFIELD(rid
) rid
: 16;
82 unsigned int disable
: 16;
85 /* Disable mask. Keywords are disabled if (reswords[i].disable &
87 #define D_C89 0x01 /* not in C89 */
88 #define D_EXT 0x02 /* GCC extension */
89 #define D_EXT89 0x04 /* GCC extension incorporated in C99 */
90 #define D_OBJC 0x08 /* Objective C only */
92 static const struct resword reswords
[] =
94 { "_Bool", RID_BOOL
, 0 },
95 { "_Complex", RID_COMPLEX
, 0 },
96 { "_Decimal32", RID_DFLOAT32
, D_EXT
},
97 { "_Decimal64", RID_DFLOAT64
, D_EXT
},
98 { "_Decimal128", RID_DFLOAT128
, D_EXT
},
99 { "__FUNCTION__", RID_FUNCTION_NAME
, 0 },
100 { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME
, 0 },
101 { "__alignof", RID_ALIGNOF
, 0 },
102 { "__alignof__", RID_ALIGNOF
, 0 },
103 { "__asm", RID_ASM
, 0 },
104 { "__asm__", RID_ASM
, 0 },
105 { "__attribute", RID_ATTRIBUTE
, 0 },
106 { "__attribute__", RID_ATTRIBUTE
, 0 },
107 { "__builtin_choose_expr", RID_CHOOSE_EXPR
, 0 },
108 { "__builtin_offsetof", RID_OFFSETOF
, 0 },
109 { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P
, 0 },
110 { "__builtin_va_arg", RID_VA_ARG
, 0 },
111 { "__complex", RID_COMPLEX
, 0 },
112 { "__complex__", RID_COMPLEX
, 0 },
113 { "__const", RID_CONST
, 0 },
114 { "__const__", RID_CONST
, 0 },
115 { "__extension__", RID_EXTENSION
, 0 },
116 { "__func__", RID_C99_FUNCTION_NAME
, 0 },
117 { "__imag", RID_IMAGPART
, 0 },
118 { "__imag__", RID_IMAGPART
, 0 },
119 { "__inline", RID_INLINE
, 0 },
120 { "__inline__", RID_INLINE
, 0 },
121 { "__label__", RID_LABEL
, 0 },
122 { "__real", RID_REALPART
, 0 },
123 { "__real__", RID_REALPART
, 0 },
124 { "__restrict", RID_RESTRICT
, 0 },
125 { "__restrict__", RID_RESTRICT
, 0 },
126 { "__signed", RID_SIGNED
, 0 },
127 { "__signed__", RID_SIGNED
, 0 },
128 { "__thread", RID_THREAD
, 0 },
129 { "__typeof", RID_TYPEOF
, 0 },
130 { "__typeof__", RID_TYPEOF
, 0 },
131 { "__volatile", RID_VOLATILE
, 0 },
132 { "__volatile__", RID_VOLATILE
, 0 },
133 { "asm", RID_ASM
, D_EXT
},
134 { "auto", RID_AUTO
, 0 },
135 { "break", RID_BREAK
, 0 },
136 { "case", RID_CASE
, 0 },
137 { "char", RID_CHAR
, 0 },
138 { "const", RID_CONST
, 0 },
139 { "continue", RID_CONTINUE
, 0 },
140 { "default", RID_DEFAULT
, 0 },
142 { "double", RID_DOUBLE
, 0 },
143 { "else", RID_ELSE
, 0 },
144 { "enum", RID_ENUM
, 0 },
145 { "extern", RID_EXTERN
, 0 },
146 { "float", RID_FLOAT
, 0 },
147 { "for", RID_FOR
, 0 },
148 { "goto", RID_GOTO
, 0 },
150 { "inline", RID_INLINE
, D_EXT89
},
151 { "int", RID_INT
, 0 },
152 { "long", RID_LONG
, 0 },
153 { "register", RID_REGISTER
, 0 },
154 { "restrict", RID_RESTRICT
, D_C89
},
155 { "return", RID_RETURN
, 0 },
156 { "short", RID_SHORT
, 0 },
157 { "signed", RID_SIGNED
, 0 },
158 { "sizeof", RID_SIZEOF
, 0 },
159 { "static", RID_STATIC
, 0 },
160 { "struct", RID_STRUCT
, 0 },
161 { "switch", RID_SWITCH
, 0 },
162 { "typedef", RID_TYPEDEF
, 0 },
163 { "typeof", RID_TYPEOF
, D_EXT
},
164 { "union", RID_UNION
, 0 },
165 { "unsigned", RID_UNSIGNED
, 0 },
166 { "void", RID_VOID
, 0 },
167 { "volatile", RID_VOLATILE
, 0 },
168 { "while", RID_WHILE
, 0 },
169 /* These Objective-C keywords are recognized only immediately after
171 { "class", RID_AT_CLASS
, D_OBJC
},
172 { "compatibility_alias", RID_AT_ALIAS
, D_OBJC
},
173 { "defs", RID_AT_DEFS
, D_OBJC
},
174 { "encode", RID_AT_ENCODE
, D_OBJC
},
175 { "end", RID_AT_END
, D_OBJC
},
176 { "implementation", RID_AT_IMPLEMENTATION
, D_OBJC
},
177 { "interface", RID_AT_INTERFACE
, D_OBJC
},
178 { "private", RID_AT_PRIVATE
, D_OBJC
},
179 { "protected", RID_AT_PROTECTED
, D_OBJC
},
180 { "protocol", RID_AT_PROTOCOL
, D_OBJC
},
181 { "public", RID_AT_PUBLIC
, D_OBJC
},
182 { "selector", RID_AT_SELECTOR
, D_OBJC
},
183 { "throw", RID_AT_THROW
, D_OBJC
},
184 { "try", RID_AT_TRY
, D_OBJC
},
185 { "catch", RID_AT_CATCH
, D_OBJC
},
186 { "finally", RID_AT_FINALLY
, D_OBJC
},
187 { "synchronized", RID_AT_SYNCHRONIZED
, D_OBJC
},
188 /* These are recognized only in protocol-qualifier context
190 { "bycopy", RID_BYCOPY
, D_OBJC
},
191 { "byref", RID_BYREF
, D_OBJC
},
192 { "in", RID_IN
, D_OBJC
},
193 { "inout", RID_INOUT
, D_OBJC
},
194 { "oneway", RID_ONEWAY
, D_OBJC
},
195 { "out", RID_OUT
, D_OBJC
},
197 #define N_reswords (sizeof reswords / sizeof (struct resword))
199 /* Initialization routine for this file. */
204 /* The only initialization required is of the reserved word
208 int mask
= (flag_isoc99
? 0 : D_C89
)
209 | (flag_no_asm
? (flag_isoc99
? D_EXT
: D_EXT
|D_EXT89
) : 0);
211 if (!c_dialect_objc ())
214 ridpointers
= GGC_CNEWVEC (tree
, (int) RID_MAX
);
215 for (i
= 0; i
< N_reswords
; i
++)
217 /* If a keyword is disabled, do not enter it into the table
218 and so create a canonical spelling that isn't a keyword. */
219 if (reswords
[i
].disable
& mask
)
222 id
= get_identifier (reswords
[i
].word
);
223 C_RID_CODE (id
) = reswords
[i
].rid
;
224 C_IS_RESERVED_WORD (id
) = 1;
225 ridpointers
[(int) reswords
[i
].rid
] = id
;
229 /* The C lexer intermediates between the lexer in cpplib and c-lex.c
230 and the C parser. Unlike the C++ lexer, the parser structure
231 stores the lexer information instead of using a separate structure.
232 Identifiers are separated into ordinary identifiers, type names,
233 keywords and some other Objective-C types of identifiers, and some
234 look-ahead is maintained.
236 ??? It might be a good idea to lex the whole file up front (as for
237 C++). It would then be possible to share more of the C and C++
238 lexer code, if desired. */
240 /* The following local token type is used. */
243 #define CPP_KEYWORD ((enum cpp_ttype) (N_TTYPES + 1))
245 /* More information about the type of a CPP_NAME token. */
246 typedef enum c_id_kind
{
247 /* An ordinary identifier. */
249 /* An identifier declared as a typedef name. */
251 /* An identifier declared as an Objective-C class name. */
253 /* Not an identifier. */
257 /* A single C token after string literal concatenation and conversion
258 of preprocessing tokens to tokens. */
259 typedef struct c_token
GTY (())
261 /* The kind of token. */
262 ENUM_BITFIELD (cpp_ttype
) type
: 8;
263 /* If this token is a CPP_NAME, this value indicates whether also
264 declared as some kind of type. Otherwise, it is C_ID_NONE. */
265 ENUM_BITFIELD (c_id_kind
) id_kind
: 8;
266 /* If this token is a keyword, this value indicates which keyword.
267 Otherwise, this value is RID_MAX. */
268 ENUM_BITFIELD (rid
) keyword
: 8;
269 /* If this token is a CPP_PRAGMA, this indicates the pragma that
270 was seen. Otherwise it is PRAGMA_NONE. */
271 ENUM_BITFIELD (pragma_kind
) pragma_kind
: 7;
272 /* True if this token is from a system header. */
273 BOOL_BITFIELD in_system_header
: 1;
274 /* The value associated with this token, if any. */
276 /* The location at which this token was found. */
280 /* A parser structure recording information about the state and
281 context of parsing. Includes lexer information with up to two
282 tokens of look-ahead; more are not needed for C. */
283 typedef struct c_parser
GTY(())
285 /* The look-ahead tokens. */
287 /* How many look-ahead tokens are available (0, 1 or 2). */
289 /* True if a syntax error is being recovered from; false otherwise.
290 c_parser_error sets this flag. It should clear this flag when
291 enough tokens have been consumed to recover from the error. */
292 BOOL_BITFIELD error
: 1;
293 /* True if we're processing a pragma, and shouldn't automatically
294 consume CPP_PRAGMA_EOL. */
295 BOOL_BITFIELD in_pragma
: 1;
299 /* The actual parser and external interface. ??? Does this need to be
300 garbage-collected? */
302 static GTY (()) c_parser
*the_parser
;
305 /* Read in and lex a single token, storing it in *TOKEN. */
308 c_lex_one_token (c_token
*token
)
310 timevar_push (TV_LEX
);
312 token
->type
= c_lex_with_flags (&token
->value
, &token
->location
, NULL
);
313 token
->id_kind
= C_ID_NONE
;
314 token
->keyword
= RID_MAX
;
315 token
->pragma_kind
= PRAGMA_NONE
;
316 token
->in_system_header
= in_system_header
;
324 int objc_force_identifier
= objc_need_raw_identifier
;
325 OBJC_NEED_RAW_IDENTIFIER (0);
327 if (C_IS_RESERVED_WORD (token
->value
))
329 enum rid rid_code
= C_RID_CODE (token
->value
);
331 if (c_dialect_objc ())
333 if (!OBJC_IS_AT_KEYWORD (rid_code
)
334 && (!OBJC_IS_PQ_KEYWORD (rid_code
) || objc_pq_context
))
336 /* Return the canonical spelling for this keyword. */
337 token
->value
= ridpointers
[(int) rid_code
];
338 token
->type
= CPP_KEYWORD
;
339 token
->keyword
= rid_code
;
345 /* Return the canonical spelling for this keyword. */
346 token
->value
= ridpointers
[(int) rid_code
];
347 token
->type
= CPP_KEYWORD
;
348 token
->keyword
= rid_code
;
353 decl
= lookup_name (token
->value
);
356 if (TREE_CODE (decl
) == TYPE_DECL
)
358 token
->id_kind
= C_ID_TYPENAME
;
362 else if (c_dialect_objc ())
364 tree objc_interface_decl
= objc_is_class_name (token
->value
);
365 /* Objective-C class names are in the same namespace as
366 variables and typedefs, and hence are shadowed by local
368 if (objc_interface_decl
369 && (global_bindings_p ()
370 || (!objc_force_identifier
&& !decl
)))
372 token
->value
= objc_interface_decl
;
373 token
->id_kind
= C_ID_CLASSNAME
;
377 token
->id_kind
= C_ID_ID
;
381 /* This only happens in Objective-C; it must be a keyword. */
382 token
->type
= CPP_KEYWORD
;
383 token
->keyword
= C_RID_CODE (token
->value
);
387 case CPP_CLOSE_PAREN
:
389 /* These tokens may affect the interpretation of any identifiers
390 following, if doing Objective-C. */
391 OBJC_NEED_RAW_IDENTIFIER (0);
394 /* We smuggled the cpp_token->u.pragma value in an INTEGER_CST. */
395 token
->pragma_kind
= TREE_INT_CST_LOW (token
->value
);
401 timevar_pop (TV_LEX
);
404 /* Return a pointer to the next token from PARSER, reading it in if
407 static inline c_token
*
408 c_parser_peek_token (c_parser
*parser
)
410 if (parser
->tokens_avail
== 0)
412 c_lex_one_token (&parser
->tokens
[0]);
413 parser
->tokens_avail
= 1;
415 return &parser
->tokens
[0];
418 /* Return true if the next token from PARSER has the indicated
422 c_parser_next_token_is (c_parser
*parser
, enum cpp_ttype type
)
424 return c_parser_peek_token (parser
)->type
== type
;
427 /* Return true if the next token from PARSER does not have the
431 c_parser_next_token_is_not (c_parser
*parser
, enum cpp_ttype type
)
433 return !c_parser_next_token_is (parser
, type
);
436 /* Return true if the next token from PARSER is the indicated
440 c_parser_next_token_is_keyword (c_parser
*parser
, enum rid keyword
)
444 /* Peek at the next token. */
445 token
= c_parser_peek_token (parser
);
446 /* Check to see if it is the indicated keyword. */
447 return token
->keyword
== keyword
;
450 /* Return true if TOKEN can start a type name,
453 c_token_starts_typename (c_token
*token
)
458 switch (token
->id_kind
)
465 gcc_assert (c_dialect_objc ());
471 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
)
574 if (c_dialect_objc ())
582 /* Return true if the next token from PARSER can start declaration
583 specifiers, false otherwise. */
585 c_parser_next_token_starts_declspecs (c_parser
*parser
)
587 c_token
*token
= c_parser_peek_token (parser
);
588 return c_token_starts_declspecs (token
);
591 /* Return a pointer to the next-but-one token from PARSER, reading it
592 in if necessary. The next token is already read in. */
595 c_parser_peek_2nd_token (c_parser
*parser
)
597 if (parser
->tokens_avail
>= 2)
598 return &parser
->tokens
[1];
599 gcc_assert (parser
->tokens_avail
== 1);
600 gcc_assert (parser
->tokens
[0].type
!= CPP_EOF
);
601 gcc_assert (parser
->tokens
[0].type
!= CPP_PRAGMA_EOL
);
602 c_lex_one_token (&parser
->tokens
[1]);
603 parser
->tokens_avail
= 2;
604 return &parser
->tokens
[1];
607 /* Consume the next token from PARSER. */
610 c_parser_consume_token (c_parser
*parser
)
612 gcc_assert (parser
->tokens_avail
>= 1);
613 gcc_assert (parser
->tokens
[0].type
!= CPP_EOF
);
614 gcc_assert (!parser
->in_pragma
|| parser
->tokens
[0].type
!= CPP_PRAGMA_EOL
);
615 gcc_assert (parser
->error
|| parser
->tokens
[0].type
!= CPP_PRAGMA
);
616 if (parser
->tokens_avail
== 2)
617 parser
->tokens
[0] = parser
->tokens
[1];
618 parser
->tokens_avail
--;
621 /* Expect the current token to be a #pragma. Consume it and remember
622 that we've begun parsing a pragma. */
625 c_parser_consume_pragma (c_parser
*parser
)
627 gcc_assert (!parser
->in_pragma
);
628 gcc_assert (parser
->tokens_avail
>= 1);
629 gcc_assert (parser
->tokens
[0].type
== CPP_PRAGMA
);
630 if (parser
->tokens_avail
== 2)
631 parser
->tokens
[0] = parser
->tokens
[1];
632 parser
->tokens_avail
--;
633 parser
->in_pragma
= true;
636 /* Update the globals input_location and in_system_header from
639 c_parser_set_source_position_from_token (c_token
*token
)
641 if (token
->type
!= CPP_EOF
)
643 input_location
= token
->location
;
644 in_system_header
= token
->in_system_header
;
648 /* Issue a diagnostic of the form
649 FILE:LINE: MESSAGE before TOKEN
650 where TOKEN is the next token in the input stream of PARSER.
651 MESSAGE (specified by the caller) is usually of the form "expected
654 Do not issue a diagnostic if still recovering from an error.
656 ??? This is taken from the C++ parser, but building up messages in
657 this way is not i18n-friendly and some other approach should be
661 c_parser_error (c_parser
*parser
, const char *gmsgid
)
663 c_token
*token
= c_parser_peek_token (parser
);
666 parser
->error
= true;
669 /* This diagnostic makes more sense if it is tagged to the line of
670 the token we just peeked at. */
671 c_parser_set_source_position_from_token (token
);
672 c_parse_error (gmsgid
,
673 /* Because c_parse_error does not understand
674 CPP_KEYWORD, keywords are treated like
676 (token
->type
== CPP_KEYWORD
? CPP_NAME
: token
->type
),
680 /* If the next token is of the indicated TYPE, consume it. Otherwise,
681 issue the error MSGID. If MSGID is NULL then a message has already
682 been produced and no message will be produced this time. Returns
683 true if found, false otherwise. */
686 c_parser_require (c_parser
*parser
,
690 if (c_parser_next_token_is (parser
, type
))
692 c_parser_consume_token (parser
);
697 c_parser_error (parser
, msgid
);
702 /* If the next token is the indicated keyword, consume it. Otherwise,
703 issue the error MSGID. Returns true if found, false otherwise. */
706 c_parser_require_keyword (c_parser
*parser
,
710 if (c_parser_next_token_is_keyword (parser
, keyword
))
712 c_parser_consume_token (parser
);
717 c_parser_error (parser
, msgid
);
722 /* Like c_parser_require, except that tokens will be skipped until the
723 desired token is found. An error message is still produced if the
724 next token is not as expected. If MSGID is NULL then a message has
725 already been produced and no message will be produced this
729 c_parser_skip_until_found (c_parser
*parser
,
733 unsigned nesting_depth
= 0;
735 if (c_parser_require (parser
, type
, msgid
))
738 /* Skip tokens until the desired token is found. */
741 /* Peek at the next token. */
742 c_token
*token
= c_parser_peek_token (parser
);
743 /* If we've reached the token we want, consume it and stop. */
744 if (token
->type
== type
&& !nesting_depth
)
746 c_parser_consume_token (parser
);
750 /* If we've run out of tokens, stop. */
751 if (token
->type
== CPP_EOF
)
753 if (token
->type
== CPP_PRAGMA_EOL
&& parser
->in_pragma
)
755 if (token
->type
== CPP_OPEN_BRACE
756 || token
->type
== CPP_OPEN_PAREN
757 || token
->type
== CPP_OPEN_SQUARE
)
759 else if (token
->type
== CPP_CLOSE_BRACE
760 || token
->type
== CPP_CLOSE_PAREN
761 || token
->type
== CPP_CLOSE_SQUARE
)
763 if (nesting_depth
-- == 0)
766 /* Consume this token. */
767 c_parser_consume_token (parser
);
769 parser
->error
= false;
772 /* Skip tokens until the end of a parameter is found, but do not
773 consume the comma, semicolon or closing delimiter. */
776 c_parser_skip_to_end_of_parameter (c_parser
*parser
)
778 unsigned nesting_depth
= 0;
782 c_token
*token
= c_parser_peek_token (parser
);
783 if ((token
->type
== CPP_COMMA
|| token
->type
== CPP_SEMICOLON
)
786 /* If we've run out of tokens, stop. */
787 if (token
->type
== CPP_EOF
)
789 if (token
->type
== CPP_PRAGMA_EOL
&& parser
->in_pragma
)
791 if (token
->type
== CPP_OPEN_BRACE
792 || token
->type
== CPP_OPEN_PAREN
793 || token
->type
== CPP_OPEN_SQUARE
)
795 else if (token
->type
== CPP_CLOSE_BRACE
796 || token
->type
== CPP_CLOSE_PAREN
797 || token
->type
== CPP_CLOSE_SQUARE
)
799 if (nesting_depth
-- == 0)
802 /* Consume this token. */
803 c_parser_consume_token (parser
);
805 parser
->error
= false;
808 /* Expect to be at the end of the pragma directive and consume an
809 end of line marker. */
812 c_parser_skip_to_pragma_eol (c_parser
*parser
)
814 gcc_assert (parser
->in_pragma
);
815 parser
->in_pragma
= false;
817 if (!c_parser_require (parser
, CPP_PRAGMA_EOL
, "expected end of line"))
820 c_token
*token
= c_parser_peek_token (parser
);
821 if (token
->type
== CPP_EOF
)
823 if (token
->type
== CPP_PRAGMA_EOL
)
825 c_parser_consume_token (parser
);
828 c_parser_consume_token (parser
);
831 parser
->error
= false;
834 /* Skip tokens until we have consumed an entire block, or until we
835 have consumed a non-nested ';'. */
838 c_parser_skip_to_end_of_block_or_statement (c_parser
*parser
)
840 unsigned nesting_depth
= 0;
841 bool save_error
= parser
->error
;
847 /* Peek at the next token. */
848 token
= c_parser_peek_token (parser
);
856 if (parser
->in_pragma
)
861 /* If the next token is a ';', we have reached the
862 end of the statement. */
865 /* Consume the ';'. */
866 c_parser_consume_token (parser
);
871 case CPP_CLOSE_BRACE
:
872 /* If the next token is a non-nested '}', then we have
873 reached the end of the current block. */
874 if (nesting_depth
== 0 || --nesting_depth
== 0)
876 c_parser_consume_token (parser
);
882 /* If it the next token is a '{', then we are entering a new
883 block. Consume the entire block. */
888 /* If we see a pragma, consume the whole thing at once. We
889 have some safeguards against consuming pragmas willy-nilly.
890 Normally, we'd expect to be here with parser->error set,
891 which disables these safeguards. But it's possible to get
892 here for secondary error recovery, after parser->error has
894 c_parser_consume_pragma (parser
);
895 c_parser_skip_to_pragma_eol (parser
);
896 parser
->error
= save_error
;
903 c_parser_consume_token (parser
);
907 parser
->error
= false;
910 /* Save the warning flags which are controlled by __extension__. */
913 disable_extension_diagnostics (void)
916 | (warn_pointer_arith
<< 1)
917 | (warn_traditional
<< 2)
920 warn_pointer_arith
= 0;
921 warn_traditional
= 0;
926 /* Restore the warning flags which are controlled by __extension__.
927 FLAGS is the return value from disable_extension_diagnostics. */
930 restore_extension_diagnostics (int flags
)
932 pedantic
= flags
& 1;
933 warn_pointer_arith
= (flags
>> 1) & 1;
934 warn_traditional
= (flags
>> 2) & 1;
935 flag_iso
= (flags
>> 3) & 1;
938 /* Possibly kinds of declarator to parse. */
939 typedef enum c_dtr_syn
{
940 /* A normal declarator with an identifier. */
942 /* An abstract declarator (maybe empty). */
944 /* A parameter declarator: may be either, but after a type name does
945 not redeclare a typedef name as an identifier if it can
946 alternatively be interpreted as a typedef name; see DR#009,
947 applied in C90 TC1, omitted from C99 and reapplied in C99 TC2
948 following DR#249. For example, given a typedef T, "int T" and
949 "int *T" are valid parameter declarations redeclaring T, while
950 "int (T)" and "int * (T)" and "int (T[])" and "int (T (int))" are
951 abstract declarators rather than involving redundant parentheses;
952 the same applies with attributes inside the parentheses before
957 static void c_parser_external_declaration (c_parser
*);
958 static void c_parser_asm_definition (c_parser
*);
959 static void c_parser_declaration_or_fndef (c_parser
*, bool, bool, bool, bool);
960 static void c_parser_declspecs (c_parser
*, struct c_declspecs
*, bool, bool,
962 static struct c_typespec
c_parser_enum_specifier (c_parser
*);
963 static struct c_typespec
c_parser_struct_or_union_specifier (c_parser
*);
964 static tree
c_parser_struct_declaration (c_parser
*);
965 static struct c_typespec
c_parser_typeof_specifier (c_parser
*);
966 static struct c_declarator
*c_parser_declarator (c_parser
*, bool, c_dtr_syn
,
968 static struct c_declarator
*c_parser_direct_declarator (c_parser
*, bool,
970 static struct c_declarator
*c_parser_direct_declarator_inner (c_parser
*,
972 struct c_declarator
*);
973 static struct c_arg_info
*c_parser_parms_declarator (c_parser
*, bool, tree
);
974 static struct c_arg_info
*c_parser_parms_list_declarator (c_parser
*, tree
);
975 static struct c_parm
*c_parser_parameter_declaration (c_parser
*, tree
);
976 static tree
c_parser_simple_asm_expr (c_parser
*);
977 static tree
c_parser_attributes (c_parser
*);
978 static struct c_type_name
*c_parser_type_name (c_parser
*);
979 static struct c_expr
c_parser_initializer (c_parser
*);
980 static struct c_expr
c_parser_braced_init (c_parser
*, tree
, bool);
981 static void c_parser_initelt (c_parser
*);
982 static void c_parser_initval (c_parser
*, struct c_expr
*);
983 static tree
c_parser_compound_statement (c_parser
*);
984 static void c_parser_compound_statement_nostart (c_parser
*);
985 static void c_parser_label (c_parser
*);
986 static void c_parser_statement (c_parser
*);
987 static void c_parser_statement_after_labels (c_parser
*);
988 static void c_parser_if_statement (c_parser
*);
989 static void c_parser_switch_statement (c_parser
*);
990 static void c_parser_while_statement (c_parser
*);
991 static void c_parser_do_statement (c_parser
*);
992 static void c_parser_for_statement (c_parser
*);
993 static tree
c_parser_asm_statement (c_parser
*);
994 static tree
c_parser_asm_operands (c_parser
*, bool);
995 static tree
c_parser_asm_clobbers (c_parser
*);
996 static struct c_expr
c_parser_expr_no_commas (c_parser
*, struct c_expr
*);
997 static struct c_expr
c_parser_conditional_expression (c_parser
*,
999 static struct c_expr
c_parser_binary_expression (c_parser
*, struct c_expr
*);
1000 static struct c_expr
c_parser_cast_expression (c_parser
*, struct c_expr
*);
1001 static struct c_expr
c_parser_unary_expression (c_parser
*);
1002 static struct c_expr
c_parser_sizeof_expression (c_parser
*);
1003 static struct c_expr
c_parser_alignof_expression (c_parser
*);
1004 static struct c_expr
c_parser_postfix_expression (c_parser
*);
1005 static struct c_expr
c_parser_postfix_expression_after_paren_type (c_parser
*,
1006 struct c_type_name
*);
1007 static struct c_expr
c_parser_postfix_expression_after_primary (c_parser
*,
1009 static struct c_expr
c_parser_expression (c_parser
*);
1010 static struct c_expr
c_parser_expression_conv (c_parser
*);
1011 static tree
c_parser_expr_list (c_parser
*, bool);
1012 static void c_parser_omp_construct (c_parser
*);
1013 static void c_parser_omp_threadprivate (c_parser
*);
1014 static void c_parser_omp_barrier (c_parser
*);
1015 static void c_parser_omp_flush (c_parser
*);
1017 enum pragma_context
{ pragma_external
, pragma_stmt
, pragma_compound
};
1018 static bool c_parser_pragma (c_parser
*, enum pragma_context
);
1020 /* These Objective-C parser functions are only ever called when
1021 compiling Objective-C. */
1022 static void c_parser_objc_class_definition (c_parser
*);
1023 static void c_parser_objc_class_instance_variables (c_parser
*);
1024 static void c_parser_objc_class_declaration (c_parser
*);
1025 static void c_parser_objc_alias_declaration (c_parser
*);
1026 static void c_parser_objc_protocol_definition (c_parser
*);
1027 static enum tree_code
c_parser_objc_method_type (c_parser
*);
1028 static void c_parser_objc_method_definition (c_parser
*);
1029 static void c_parser_objc_methodprotolist (c_parser
*);
1030 static void c_parser_objc_methodproto (c_parser
*);
1031 static tree
c_parser_objc_method_decl (c_parser
*);
1032 static tree
c_parser_objc_type_name (c_parser
*);
1033 static tree
c_parser_objc_protocol_refs (c_parser
*);
1034 static void c_parser_objc_try_catch_statement (c_parser
*);
1035 static void c_parser_objc_synchronized_statement (c_parser
*);
1036 static tree
c_parser_objc_selector (c_parser
*);
1037 static tree
c_parser_objc_selector_arg (c_parser
*);
1038 static tree
c_parser_objc_receiver (c_parser
*);
1039 static tree
c_parser_objc_message_args (c_parser
*);
1040 static tree
c_parser_objc_keywordexpr (c_parser
*);
1042 /* Parse a translation unit (C90 6.7, C99 6.9).
1045 external-declarations
1047 external-declarations:
1048 external-declaration
1049 external-declarations external-declaration
1058 c_parser_translation_unit (c_parser
*parser
)
1060 if (c_parser_next_token_is (parser
, CPP_EOF
))
1063 pedwarn ("ISO C forbids an empty source file");
1067 void *obstack_position
= obstack_alloc (&parser_obstack
, 0);
1071 c_parser_external_declaration (parser
);
1072 obstack_free (&parser_obstack
, obstack_position
);
1074 while (c_parser_next_token_is_not (parser
, CPP_EOF
));
1078 /* Parse an external declaration (C90 6.7, C99 6.9).
1080 external-declaration:
1086 external-declaration:
1089 __extension__ external-declaration
1093 external-declaration:
1094 objc-class-definition
1095 objc-class-declaration
1096 objc-alias-declaration
1097 objc-protocol-definition
1098 objc-method-definition
1103 c_parser_external_declaration (c_parser
*parser
)
1106 switch (c_parser_peek_token (parser
)->type
)
1109 switch (c_parser_peek_token (parser
)->keyword
)
1112 ext
= disable_extension_diagnostics ();
1113 c_parser_consume_token (parser
);
1114 c_parser_external_declaration (parser
);
1115 restore_extension_diagnostics (ext
);
1118 c_parser_asm_definition (parser
);
1120 case RID_AT_INTERFACE
:
1121 case RID_AT_IMPLEMENTATION
:
1122 gcc_assert (c_dialect_objc ());
1123 c_parser_objc_class_definition (parser
);
1126 gcc_assert (c_dialect_objc ());
1127 c_parser_objc_class_declaration (parser
);
1130 gcc_assert (c_dialect_objc ());
1131 c_parser_objc_alias_declaration (parser
);
1133 case RID_AT_PROTOCOL
:
1134 gcc_assert (c_dialect_objc ());
1135 c_parser_objc_protocol_definition (parser
);
1138 gcc_assert (c_dialect_objc ());
1139 c_parser_consume_token (parser
);
1140 objc_finish_implementation ();
1148 pedwarn ("ISO C does not allow extra %<;%> outside of a function");
1149 c_parser_consume_token (parser
);
1152 c_parser_pragma (parser
, pragma_external
);
1156 if (c_dialect_objc ())
1158 c_parser_objc_method_definition (parser
);
1161 /* Else fall through, and yield a syntax error trying to parse
1162 as a declaration or function definition. */
1165 /* A declaration or a function definition. We can only tell
1166 which after parsing the declaration specifiers, if any, and
1167 the first declarator. */
1168 c_parser_declaration_or_fndef (parser
, true, true, false, true);
1174 /* Parse a declaration or function definition (C90 6.5, 6.7.1, C99
1175 6.7, 6.9.1). If FNDEF_OK is true, a function definition is
1176 accepted; otherwise (old-style parameter declarations) only other
1177 declarations are accepted. If NESTED is true, we are inside a
1178 function or parsing old-style parameter declarations; any functions
1179 encountered are nested functions and declaration specifiers are
1180 required; otherwise we are at top level and functions are normal
1181 functions and declaration specifiers may be optional. If EMPTY_OK
1182 is true, empty declarations are OK (subject to all other
1183 constraints); otherwise (old-style parameter declarations) they are
1184 diagnosed. If START_ATTR_OK is true, the declaration specifiers
1185 may start with attributes; otherwise they may not.
1188 declaration-specifiers init-declarator-list[opt] ;
1190 function-definition:
1191 declaration-specifiers[opt] declarator declaration-list[opt]
1196 declaration-list declaration
1198 init-declarator-list:
1200 init-declarator-list , init-declarator
1203 declarator simple-asm-expr[opt] attributes[opt]
1204 declarator simple-asm-expr[opt] attributes[opt] = initializer
1208 nested-function-definition:
1209 declaration-specifiers declarator declaration-list[opt]
1212 The simple-asm-expr and attributes are GNU extensions.
1214 This function does not handle __extension__; that is handled in its
1215 callers. ??? Following the old parser, __extension__ may start
1216 external declarations, declarations in functions and declarations
1217 at the start of "for" loops, but not old-style parameter
1220 C99 requires declaration specifiers in a function definition; the
1221 absence is diagnosed through the diagnosis of implicit int. In GNU
1222 C we also allow but diagnose declarations without declaration
1223 specifiers, but only at top level (elsewhere they conflict with
1229 threadprivate-directive */
1232 c_parser_declaration_or_fndef (c_parser
*parser
, bool fndef_ok
, bool empty_ok
,
1233 bool nested
, bool start_attr_ok
)
1235 struct c_declspecs
*specs
;
1237 tree all_prefix_attrs
;
1238 bool diagnosed_no_specs
= false;
1240 specs
= build_null_declspecs ();
1241 c_parser_declspecs (parser
, specs
, true, true, start_attr_ok
);
1244 c_parser_skip_to_end_of_block_or_statement (parser
);
1247 if (nested
&& !specs
->declspecs_seen_p
)
1249 c_parser_error (parser
, "expected declaration specifiers");
1250 c_parser_skip_to_end_of_block_or_statement (parser
);
1253 finish_declspecs (specs
);
1254 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
1260 shadow_tag_warned (specs
, 1);
1261 pedwarn ("empty declaration");
1263 c_parser_consume_token (parser
);
1266 pending_xref_error ();
1267 prefix_attrs
= specs
->attrs
;
1268 all_prefix_attrs
= prefix_attrs
;
1269 specs
->attrs
= NULL_TREE
;
1272 struct c_declarator
*declarator
;
1275 /* Declaring either one or more declarators (in which case we
1276 should diagnose if there were no declaration specifiers) or a
1277 function definition (in which case the diagnostic for
1278 implicit int suffices). */
1279 declarator
= c_parser_declarator (parser
, specs
->type_seen_p
,
1280 C_DTR_NORMAL
, &dummy
);
1281 if (declarator
== NULL
)
1283 c_parser_skip_to_end_of_block_or_statement (parser
);
1286 if (c_parser_next_token_is (parser
, CPP_EQ
)
1287 || c_parser_next_token_is (parser
, CPP_COMMA
)
1288 || c_parser_next_token_is (parser
, CPP_SEMICOLON
)
1289 || c_parser_next_token_is_keyword (parser
, RID_ASM
)
1290 || c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
1292 tree asm_name
= NULL_TREE
;
1293 tree postfix_attrs
= NULL_TREE
;
1294 if (!diagnosed_no_specs
&& !specs
->declspecs_seen_p
)
1296 diagnosed_no_specs
= true;
1297 pedwarn ("data definition has no type or storage class");
1299 /* Having seen a data definition, there cannot now be a
1300 function definition. */
1302 if (c_parser_next_token_is_keyword (parser
, RID_ASM
))
1303 asm_name
= c_parser_simple_asm_expr (parser
);
1304 if (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
1305 postfix_attrs
= c_parser_attributes (parser
);
1306 if (c_parser_next_token_is (parser
, CPP_EQ
))
1310 c_parser_consume_token (parser
);
1311 /* The declaration of the variable is in effect while
1312 its initializer is parsed. */
1313 d
= start_decl (declarator
, specs
, true,
1314 chainon (postfix_attrs
, all_prefix_attrs
));
1316 d
= error_mark_node
;
1317 start_init (d
, asm_name
, global_bindings_p ());
1318 init
= c_parser_initializer (parser
);
1320 if (d
!= error_mark_node
)
1322 maybe_warn_string_init (TREE_TYPE (d
), init
);
1323 finish_decl (d
, init
.value
, asm_name
);
1328 tree d
= start_decl (declarator
, specs
, false,
1329 chainon (postfix_attrs
,
1332 finish_decl (d
, NULL_TREE
, asm_name
);
1334 if (c_parser_next_token_is (parser
, CPP_COMMA
))
1336 c_parser_consume_token (parser
);
1337 if (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
1338 all_prefix_attrs
= chainon (c_parser_attributes (parser
),
1341 all_prefix_attrs
= prefix_attrs
;
1344 else if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
1346 c_parser_consume_token (parser
);
1351 c_parser_error (parser
, "expected %<,%> or %<;%>");
1352 c_parser_skip_to_end_of_block_or_statement (parser
);
1358 c_parser_error (parser
, "expected %<=%>, %<,%>, %<;%>, "
1359 "%<asm%> or %<__attribute__%>");
1360 c_parser_skip_to_end_of_block_or_statement (parser
);
1363 /* Function definition (nested or otherwise). */
1367 pedwarn ("ISO C forbids nested functions");
1368 push_function_context ();
1370 if (!start_function (specs
, declarator
, all_prefix_attrs
))
1372 /* This can appear in many cases looking nothing like a
1373 function definition, so we don't give a more specific
1374 error suggesting there was one. */
1375 c_parser_error (parser
, "expected %<=%>, %<,%>, %<;%>, %<asm%> "
1376 "or %<__attribute__%>");
1378 pop_function_context ();
1381 /* Parse old-style parameter declarations. ??? Attributes are
1382 not allowed to start declaration specifiers here because of a
1383 syntax conflict between a function declaration with attribute
1384 suffix and a function definition with an attribute prefix on
1385 first old-style parameter declaration. Following the old
1386 parser, they are not accepted on subsequent old-style
1387 parameter declarations either. However, there is no
1388 ambiguity after the first declaration, nor indeed on the
1389 first as long as we don't allow postfix attributes after a
1390 declarator with a nonempty identifier list in a definition;
1391 and postfix attributes have never been accepted here in
1392 function definitions either. */
1393 while (c_parser_next_token_is_not (parser
, CPP_EOF
)
1394 && c_parser_next_token_is_not (parser
, CPP_OPEN_BRACE
))
1395 c_parser_declaration_or_fndef (parser
, false, false, true, false);
1396 DECL_SOURCE_LOCATION (current_function_decl
)
1397 = c_parser_peek_token (parser
)->location
;
1398 store_parm_decls ();
1399 fnbody
= c_parser_compound_statement (parser
);
1402 tree decl
= current_function_decl
;
1405 pop_function_context ();
1406 add_stmt (build_stmt (DECL_EXPR
, decl
));
1417 /* Parse an asm-definition (asm() outside a function body). This is a
1425 c_parser_asm_definition (c_parser
*parser
)
1427 tree asm_str
= c_parser_simple_asm_expr (parser
);
1429 cgraph_add_asm_node (asm_str
);
1430 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
1433 /* Parse some declaration specifiers (possibly none) (C90 6.5, C99
1434 6.7), adding them to SPECS (which may already include some).
1435 Storage class specifiers are accepted iff SCSPEC_OK; type
1436 specifiers are accepted iff TYPESPEC_OK; attributes are accepted at
1437 the start iff START_ATTR_OK.
1439 declaration-specifiers:
1440 storage-class-specifier declaration-specifiers[opt]
1441 type-specifier declaration-specifiers[opt]
1442 type-qualifier declaration-specifiers[opt]
1443 function-specifier declaration-specifiers[opt]
1445 Function specifiers (inline) are from C99, and are currently
1446 handled as storage class specifiers, as is __thread.
1448 C90 6.5.1, C99 6.7.1:
1449 storage-class-specifier:
1460 C90 6.5.2, C99 6.7.2:
1473 [_Imaginary removed in C99 TC2]
1474 struct-or-union-specifier
1478 (_Bool and _Complex are new in C99.)
1480 C90 6.5.3, C99 6.7.3:
1487 (restrict is new in C99.)
1491 declaration-specifiers:
1492 attributes declaration-specifiers[opt]
1494 storage-class-specifier:
1506 class-name objc-protocol-refs[opt]
1507 typedef-name objc-protocol-refs
1512 c_parser_declspecs (c_parser
*parser
, struct c_declspecs
*specs
,
1513 bool scspec_ok
, bool typespec_ok
, bool start_attr_ok
)
1515 bool attrs_ok
= start_attr_ok
;
1516 bool seen_type
= specs
->type_seen_p
;
1517 while (c_parser_next_token_is (parser
, CPP_NAME
)
1518 || c_parser_next_token_is (parser
, CPP_KEYWORD
)
1519 || (c_dialect_objc () && c_parser_next_token_is (parser
, CPP_LESS
)))
1521 struct c_typespec t
;
1523 if (c_parser_next_token_is (parser
, CPP_NAME
))
1525 tree value
= c_parser_peek_token (parser
)->value
;
1526 c_id_kind kind
= c_parser_peek_token (parser
)->id_kind
;
1527 /* This finishes the specifiers unless a type name is OK, it
1528 is declared as a type name and a type name hasn't yet
1530 if (!typespec_ok
|| seen_type
1531 || (kind
!= C_ID_TYPENAME
&& kind
!= C_ID_CLASSNAME
))
1533 c_parser_consume_token (parser
);
1536 if (kind
== C_ID_TYPENAME
1537 && (!c_dialect_objc ()
1538 || c_parser_next_token_is_not (parser
, CPP_LESS
)))
1540 t
.kind
= ctsk_typedef
;
1541 /* For a typedef name, record the meaning, not the name.
1542 In case of 'foo foo, bar;'. */
1543 t
.spec
= lookup_name (value
);
1547 tree proto
= NULL_TREE
;
1548 gcc_assert (c_dialect_objc ());
1550 if (c_parser_next_token_is (parser
, CPP_LESS
))
1551 proto
= c_parser_objc_protocol_refs (parser
);
1552 t
.spec
= objc_get_protocol_qualified_type (value
, proto
);
1554 declspecs_add_type (specs
, t
);
1557 if (c_parser_next_token_is (parser
, CPP_LESS
))
1559 /* Make "<SomeProtocol>" equivalent to "id <SomeProtocol>" -
1560 nisse@lysator.liu.se. */
1562 gcc_assert (c_dialect_objc ());
1563 if (!typespec_ok
|| seen_type
)
1565 proto
= c_parser_objc_protocol_refs (parser
);
1567 t
.spec
= objc_get_protocol_qualified_type (NULL_TREE
, proto
);
1568 declspecs_add_type (specs
, t
);
1571 gcc_assert (c_parser_next_token_is (parser
, CPP_KEYWORD
));
1572 switch (c_parser_peek_token (parser
)->keyword
)
1584 /* TODO: Distinguish between function specifiers (inline)
1585 and storage class specifiers, either here or in
1586 declspecs_add_scspec. */
1587 declspecs_add_scspec (specs
, c_parser_peek_token (parser
)->value
);
1588 c_parser_consume_token (parser
);
1608 OBJC_NEED_RAW_IDENTIFIER (1);
1609 t
.kind
= ctsk_resword
;
1610 t
.spec
= c_parser_peek_token (parser
)->value
;
1611 declspecs_add_type (specs
, t
);
1612 c_parser_consume_token (parser
);
1619 t
= c_parser_enum_specifier (parser
);
1620 declspecs_add_type (specs
, t
);
1628 t
= c_parser_struct_or_union_specifier (parser
);
1629 declspecs_add_type (specs
, t
);
1632 /* ??? The old parser rejected typeof after other type
1633 specifiers, but is a syntax error the best way of
1635 if (!typespec_ok
|| seen_type
)
1639 t
= c_parser_typeof_specifier (parser
);
1640 declspecs_add_type (specs
, t
);
1646 declspecs_add_qual (specs
, c_parser_peek_token (parser
)->value
);
1647 c_parser_consume_token (parser
);
1652 attrs
= c_parser_attributes (parser
);
1653 declspecs_add_attrs (specs
, attrs
);
1662 /* Parse an enum specifier (C90 6.5.2.2, C99 6.7.2.2).
1665 enum attributes[opt] identifier[opt] { enumerator-list } attributes[opt]
1666 enum attributes[opt] identifier[opt] { enumerator-list , } attributes[opt]
1667 enum attributes[opt] identifier
1669 The form with trailing comma is new in C99. The forms with
1670 attributes are GNU extensions. In GNU C, we accept any expression
1671 without commas in the syntax (assignment expressions, not just
1672 conditional expressions); assignment expressions will be diagnosed
1677 enumerator-list , enumerator
1680 enumeration-constant
1681 enumeration-constant = constant-expression
1684 static struct c_typespec
1685 c_parser_enum_specifier (c_parser
*parser
)
1687 struct c_typespec ret
;
1689 tree ident
= NULL_TREE
;
1690 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_ENUM
));
1691 c_parser_consume_token (parser
);
1692 attrs
= c_parser_attributes (parser
);
1693 if (c_parser_next_token_is (parser
, CPP_NAME
))
1695 ident
= c_parser_peek_token (parser
)->value
;
1696 c_parser_consume_token (parser
);
1698 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
1700 /* Parse an enum definition. */
1701 struct c_enum_contents the_enum
;
1702 tree type
= start_enum (&the_enum
, ident
);
1704 /* We chain the enumerators in reverse order, then put them in
1705 forward order at the end. */
1706 tree values
= NULL_TREE
;
1707 c_parser_consume_token (parser
);
1714 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
1716 c_parser_error (parser
, "expected identifier");
1717 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
, NULL
);
1718 values
= error_mark_node
;
1721 enum_id
= c_parser_peek_token (parser
)->value
;
1722 c_parser_consume_token (parser
);
1723 if (c_parser_next_token_is (parser
, CPP_EQ
))
1725 c_parser_consume_token (parser
);
1726 enum_value
= c_parser_expr_no_commas (parser
, NULL
).value
;
1729 enum_value
= NULL_TREE
;
1730 enum_decl
= build_enumerator (&the_enum
, enum_id
, enum_value
);
1731 TREE_CHAIN (enum_decl
) = values
;
1734 if (c_parser_next_token_is (parser
, CPP_COMMA
))
1737 c_parser_consume_token (parser
);
1739 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
1741 if (seen_comma
&& pedantic
&& !flag_isoc99
)
1742 pedwarn ("comma at end of enumerator list");
1743 c_parser_consume_token (parser
);
1748 c_parser_error (parser
, "expected %<,%> or %<}%>");
1749 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
, NULL
);
1750 values
= error_mark_node
;
1754 postfix_attrs
= c_parser_attributes (parser
);
1755 ret
.spec
= finish_enum (type
, nreverse (values
),
1756 chainon (attrs
, postfix_attrs
));
1757 ret
.kind
= ctsk_tagdef
;
1762 c_parser_error (parser
, "expected %<{%>");
1763 ret
.spec
= error_mark_node
;
1764 ret
.kind
= ctsk_tagref
;
1767 ret
= parser_xref_tag (ENUMERAL_TYPE
, ident
);
1768 /* In ISO C, enumerated types can be referred to only if already
1770 if (pedantic
&& !COMPLETE_TYPE_P (ret
.spec
))
1771 pedwarn ("ISO C forbids forward references to %<enum%> types");
1775 /* Parse a struct or union specifier (C90 6.5.2.1, C99 6.7.2.1).
1777 struct-or-union-specifier:
1778 struct-or-union attributes[opt] identifier[opt]
1779 { struct-contents } attributes[opt]
1780 struct-or-union attributes[opt] identifier
1783 struct-declaration-list
1785 struct-declaration-list:
1786 struct-declaration ;
1787 struct-declaration-list struct-declaration ;
1794 struct-declaration-list struct-declaration
1796 struct-declaration-list:
1797 struct-declaration-list ;
1800 (Note that in the syntax here, unlike that in ISO C, the semicolons
1801 are included here rather than in struct-declaration, in order to
1802 describe the syntax with extra semicolons and missing semicolon at
1807 struct-declaration-list:
1808 @defs ( class-name )
1810 (Note this does not include a trailing semicolon, but can be
1811 followed by further declarations, and gets a pedwarn-if-pedantic
1812 when followed by a semicolon.) */
1814 static struct c_typespec
1815 c_parser_struct_or_union_specifier (c_parser
*parser
)
1817 struct c_typespec ret
;
1819 tree ident
= NULL_TREE
;
1820 enum tree_code code
;
1821 switch (c_parser_peek_token (parser
)->keyword
)
1832 c_parser_consume_token (parser
);
1833 attrs
= c_parser_attributes (parser
);
1834 if (c_parser_next_token_is (parser
, CPP_NAME
))
1836 ident
= c_parser_peek_token (parser
)->value
;
1837 c_parser_consume_token (parser
);
1839 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
1841 /* Parse a struct or union definition. Start the scope of the
1842 tag before parsing components. */
1843 tree type
= start_struct (code
, ident
);
1845 /* We chain the components in reverse order, then put them in
1846 forward order at the end. Each struct-declaration may
1847 declare multiple components (comma-separated), so we must use
1848 chainon to join them, although when parsing each
1849 struct-declaration we can use TREE_CHAIN directly.
1851 The theory behind all this is that there will be more
1852 semicolon separated fields than comma separated fields, and
1853 so we'll be minimizing the number of node traversals required
1855 tree contents
= NULL_TREE
;
1856 c_parser_consume_token (parser
);
1857 /* Handle the Objective-C @defs construct,
1858 e.g. foo(sizeof(struct{ @defs(ClassName) }));. */
1859 if (c_parser_next_token_is_keyword (parser
, RID_AT_DEFS
))
1862 gcc_assert (c_dialect_objc ());
1863 c_parser_consume_token (parser
);
1864 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1866 if (c_parser_next_token_is (parser
, CPP_NAME
)
1867 && c_parser_peek_token (parser
)->id_kind
== C_ID_CLASSNAME
)
1869 name
= c_parser_peek_token (parser
)->value
;
1870 c_parser_consume_token (parser
);
1874 c_parser_error (parser
, "expected class name");
1875 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
1878 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
1880 contents
= nreverse (objc_get_class_ivars (name
));
1883 /* Parse the struct-declarations and semicolons. Problems with
1884 semicolons are diagnosed here; empty structures are diagnosed
1889 /* Parse any stray semicolon. */
1890 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
1893 pedwarn ("extra semicolon in struct or union specified");
1894 c_parser_consume_token (parser
);
1897 /* Stop if at the end of the struct or union contents. */
1898 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
1900 c_parser_consume_token (parser
);
1903 /* Accept #pragmas at struct scope. */
1904 if (c_parser_next_token_is (parser
, CPP_PRAGMA
))
1906 c_parser_pragma (parser
, pragma_external
);
1909 /* Parse some comma-separated declarations, but not the
1910 trailing semicolon if any. */
1911 decls
= c_parser_struct_declaration (parser
);
1912 contents
= chainon (decls
, contents
);
1913 /* If no semicolon follows, either we have a parse error or
1914 are at the end of the struct or union and should
1916 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
1917 c_parser_consume_token (parser
);
1920 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
1921 pedwarn ("no semicolon at end of struct or union");
1924 c_parser_error (parser
, "expected %<;%>");
1925 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
, NULL
);
1930 postfix_attrs
= c_parser_attributes (parser
);
1931 ret
.spec
= finish_struct (type
, nreverse (contents
),
1932 chainon (attrs
, postfix_attrs
));
1933 ret
.kind
= ctsk_tagdef
;
1938 c_parser_error (parser
, "expected %<{%>");
1939 ret
.spec
= error_mark_node
;
1940 ret
.kind
= ctsk_tagref
;
1943 ret
= parser_xref_tag (code
, ident
);
1947 /* Parse a struct-declaration (C90 6.5.2.1, C99 6.7.2.1), *without*
1948 the trailing semicolon.
1951 specifier-qualifier-list struct-declarator-list
1953 specifier-qualifier-list:
1954 type-specifier specifier-qualifier-list[opt]
1955 type-qualifier specifier-qualifier-list[opt]
1956 attributes specifier-qualifier-list[opt]
1958 struct-declarator-list:
1960 struct-declarator-list , attributes[opt] struct-declarator
1963 declarator attributes[opt]
1964 declarator[opt] : constant-expression attributes[opt]
1969 __extension__ struct-declaration
1970 specifier-qualifier-list
1972 Unlike the ISO C syntax, semicolons are handled elsewhere. The use
1973 of attributes where shown is a GNU extension. In GNU C, we accept
1974 any expression without commas in the syntax (assignment
1975 expressions, not just conditional expressions); assignment
1976 expressions will be diagnosed as non-constant. */
1979 c_parser_struct_declaration (c_parser
*parser
)
1981 struct c_declspecs
*specs
;
1983 tree all_prefix_attrs
;
1985 if (c_parser_next_token_is_keyword (parser
, RID_EXTENSION
))
1989 ext
= disable_extension_diagnostics ();
1990 c_parser_consume_token (parser
);
1991 decl
= c_parser_struct_declaration (parser
);
1992 restore_extension_diagnostics (ext
);
1995 specs
= build_null_declspecs ();
1996 c_parser_declspecs (parser
, specs
, false, true, true);
1999 if (!specs
->declspecs_seen_p
)
2001 c_parser_error (parser
, "expected specifier-qualifier-list");
2004 finish_declspecs (specs
);
2005 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
2008 if (!specs
->type_seen_p
)
2011 pedwarn ("ISO C forbids member declarations with no members");
2012 shadow_tag_warned (specs
, pedantic
);
2017 /* Support for unnamed structs or unions as members of
2018 structs or unions (which is [a] useful and [b] supports
2020 ret
= grokfield (build_id_declarator (NULL_TREE
), specs
, NULL_TREE
);
2024 pending_xref_error ();
2025 prefix_attrs
= specs
->attrs
;
2026 all_prefix_attrs
= prefix_attrs
;
2027 specs
->attrs
= NULL_TREE
;
2031 /* Declaring one or more declarators or un-named bit-fields. */
2032 struct c_declarator
*declarator
;
2034 if (c_parser_next_token_is (parser
, CPP_COLON
))
2035 declarator
= build_id_declarator (NULL_TREE
);
2037 declarator
= c_parser_declarator (parser
, specs
->type_seen_p
,
2038 C_DTR_NORMAL
, &dummy
);
2039 if (declarator
== NULL
)
2041 c_parser_skip_to_end_of_block_or_statement (parser
);
2044 if (c_parser_next_token_is (parser
, CPP_COLON
)
2045 || c_parser_next_token_is (parser
, CPP_COMMA
)
2046 || c_parser_next_token_is (parser
, CPP_SEMICOLON
)
2047 || c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
)
2048 || c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
2050 tree postfix_attrs
= NULL_TREE
;
2051 tree width
= NULL_TREE
;
2053 if (c_parser_next_token_is (parser
, CPP_COLON
))
2055 c_parser_consume_token (parser
);
2056 width
= c_parser_expr_no_commas (parser
, NULL
).value
;
2058 if (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
2059 postfix_attrs
= c_parser_attributes (parser
);
2060 d
= grokfield (declarator
, specs
, width
);
2061 decl_attributes (&d
, chainon (postfix_attrs
,
2062 all_prefix_attrs
), 0);
2063 TREE_CHAIN (d
) = decls
;
2065 if (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
2066 all_prefix_attrs
= chainon (c_parser_attributes (parser
),
2069 all_prefix_attrs
= prefix_attrs
;
2070 if (c_parser_next_token_is (parser
, CPP_COMMA
))
2071 c_parser_consume_token (parser
);
2072 else if (c_parser_next_token_is (parser
, CPP_SEMICOLON
)
2073 || c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
2075 /* Semicolon consumed in caller. */
2080 c_parser_error (parser
, "expected %<,%>, %<;%> or %<}%>");
2086 c_parser_error (parser
,
2087 "expected %<:%>, %<,%>, %<;%>, %<}%> or "
2088 "%<__attribute__%>");
2095 /* Parse a typeof specifier (a GNU extension).
2098 typeof ( expression )
2099 typeof ( type-name )
2102 static struct c_typespec
2103 c_parser_typeof_specifier (c_parser
*parser
)
2105 struct c_typespec ret
;
2106 ret
.kind
= ctsk_typeof
;
2107 ret
.spec
= error_mark_node
;
2108 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_TYPEOF
));
2109 c_parser_consume_token (parser
);
2112 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
2118 if (c_parser_next_token_starts_typename (parser
))
2120 struct c_type_name
*type
= c_parser_type_name (parser
);
2125 ret
.spec
= groktypename (type
);
2126 pop_maybe_used (variably_modified_type_p (ret
.spec
, NULL_TREE
));
2132 struct c_expr expr
= c_parser_expression (parser
);
2135 if (TREE_CODE (expr
.value
) == COMPONENT_REF
2136 && DECL_C_BIT_FIELD (TREE_OPERAND (expr
.value
, 1)))
2137 error ("%<typeof%> applied to a bit-field");
2138 ret
.spec
= TREE_TYPE (expr
.value
);
2139 was_vm
= variably_modified_type_p (ret
.spec
, NULL_TREE
);
2140 /* This should be returned with the type so that when the type
2141 is evaluated, this can be evaluated. For now, we avoid
2142 evaluation when the context might. */
2143 if (!skip_evaluation
&& was_vm
)
2145 tree e
= expr
.value
;
2147 /* If the expression is not of a type to which we cannot assign a line
2148 number, wrap the thing in a no-op NOP_EXPR. */
2149 if (DECL_P (e
) || CONSTANT_CLASS_P (e
))
2150 e
= build1 (NOP_EXPR
, void_type_node
, e
);
2152 if (CAN_HAVE_LOCATION_P (e
))
2153 SET_EXPR_LOCATION (e
, input_location
);
2157 pop_maybe_used (was_vm
);
2159 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
2163 /* Parse a declarator, possibly an abstract declarator (C90 6.5.4,
2164 6.5.5, C99 6.7.5, 6.7.6). If TYPE_SEEN_P then a typedef name may
2165 be redeclared; otherwise it may not. KIND indicates which kind of
2166 declarator is wanted. Returns a valid declarator except in the
2167 case of a syntax error in which case NULL is returned. *SEEN_ID is
2168 set to true if an identifier being declared is seen; this is used
2169 to diagnose bad forms of abstract array declarators and to
2170 determine whether an identifier list is syntactically permitted.
2173 pointer[opt] direct-declarator
2177 ( attributes[opt] declarator )
2178 direct-declarator array-declarator
2179 direct-declarator ( parameter-type-list )
2180 direct-declarator ( identifier-list[opt] )
2183 * type-qualifier-list[opt]
2184 * type-qualifier-list[opt] pointer
2186 type-qualifier-list:
2189 type-qualifier-list type-qualifier
2190 type-qualifier-list attributes
2192 parameter-type-list:
2194 parameter-list , ...
2197 parameter-declaration
2198 parameter-list , parameter-declaration
2200 parameter-declaration:
2201 declaration-specifiers declarator attributes[opt]
2202 declaration-specifiers abstract-declarator[opt] attributes[opt]
2206 identifier-list , identifier
2208 abstract-declarator:
2210 pointer[opt] direct-abstract-declarator
2212 direct-abstract-declarator:
2213 ( attributes[opt] abstract-declarator )
2214 direct-abstract-declarator[opt] array-declarator
2215 direct-abstract-declarator[opt] ( parameter-type-list[opt] )
2220 direct-declarator ( parameter-forward-declarations
2221 parameter-type-list[opt] )
2223 direct-abstract-declarator:
2224 direct-abstract-declarator[opt] ( parameter-forward-declarations
2225 parameter-type-list[opt] )
2227 parameter-forward-declarations:
2229 parameter-forward-declarations parameter-list ;
2231 The uses of attributes shown above are GNU extensions.
2233 Some forms of array declarator are not included in C99 in the
2234 syntax for abstract declarators; these are disallowed elsewhere.
2235 This may be a defect (DR#289).
2237 This function also accepts an omitted abstract declarator as being
2238 an abstract declarator, although not part of the formal syntax. */
2240 static struct c_declarator
*
2241 c_parser_declarator (c_parser
*parser
, bool type_seen_p
, c_dtr_syn kind
,
2244 /* Parse any initial pointer part. */
2245 if (c_parser_next_token_is (parser
, CPP_MULT
))
2247 struct c_declspecs
*quals_attrs
= build_null_declspecs ();
2248 struct c_declarator
*inner
;
2249 c_parser_consume_token (parser
);
2250 c_parser_declspecs (parser
, quals_attrs
, false, false, true);
2251 inner
= c_parser_declarator (parser
, type_seen_p
, kind
, seen_id
);
2255 return make_pointer_declarator (quals_attrs
, inner
);
2257 /* Now we have a direct declarator, direct abstract declarator or
2258 nothing (which counts as a direct abstract declarator here). */
2259 return c_parser_direct_declarator (parser
, type_seen_p
, kind
, seen_id
);
2262 /* Parse a direct declarator or direct abstract declarator; arguments
2263 as c_parser_declarator. */
2265 static struct c_declarator
*
2266 c_parser_direct_declarator (c_parser
*parser
, bool type_seen_p
, c_dtr_syn kind
,
2269 /* The direct declarator must start with an identifier (possibly
2270 omitted) or a parenthesized declarator (possibly abstract). In
2271 an ordinary declarator, initial parentheses must start a
2272 parenthesized declarator. In an abstract declarator or parameter
2273 declarator, they could start a parenthesized declarator or a
2274 parameter list. To tell which, the open parenthesis and any
2275 following attributes must be read. If a declaration specifier
2276 follows, then it is a parameter list; if the specifier is a
2277 typedef name, there might be an ambiguity about redeclaring it,
2278 which is resolved in the direction of treating it as a typedef
2279 name. If a close parenthesis follows, it is also an empty
2280 parameter list, as the syntax does not permit empty abstract
2281 declarators. Otherwise, it is a parenthesized declarator (in
2282 which case the analysis may be repeated inside it, recursively).
2284 ??? There is an ambiguity in a parameter declaration "int
2285 (__attribute__((foo)) x)", where x is not a typedef name: it
2286 could be an abstract declarator for a function, or declare x with
2287 parentheses. The proper resolution of this ambiguity needs
2288 documenting. At present we follow an accident of the old
2289 parser's implementation, whereby the first parameter must have
2290 some declaration specifiers other than just attributes. Thus as
2291 a parameter declaration it is treated as a parenthesized
2292 parameter named x, and as an abstract declarator it is
2295 ??? Also following the old parser, attributes inside an empty
2296 parameter list are ignored, making it a list not yielding a
2297 prototype, rather than giving an error or making it have one
2298 parameter with implicit type int.
2300 ??? Also following the old parser, typedef names may be
2301 redeclared in declarators, but not Objective-C class names. */
2303 if (kind
!= C_DTR_ABSTRACT
2304 && c_parser_next_token_is (parser
, CPP_NAME
)
2306 && c_parser_peek_token (parser
)->id_kind
== C_ID_TYPENAME
)
2307 || c_parser_peek_token (parser
)->id_kind
== C_ID_ID
))
2309 struct c_declarator
*inner
2310 = build_id_declarator (c_parser_peek_token (parser
)->value
);
2312 inner
->id_loc
= c_parser_peek_token (parser
)->location
;
2313 c_parser_consume_token (parser
);
2314 return c_parser_direct_declarator_inner (parser
, *seen_id
, inner
);
2317 if (kind
!= C_DTR_NORMAL
2318 && c_parser_next_token_is (parser
, CPP_OPEN_SQUARE
))
2320 struct c_declarator
*inner
= build_id_declarator (NULL_TREE
);
2321 return c_parser_direct_declarator_inner (parser
, *seen_id
, inner
);
2324 /* Either we are at the end of an abstract declarator, or we have
2327 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
2330 struct c_declarator
*inner
;
2331 c_parser_consume_token (parser
);
2332 attrs
= c_parser_attributes (parser
);
2333 if (kind
!= C_DTR_NORMAL
2334 && (c_parser_next_token_starts_declspecs (parser
)
2335 || c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
)))
2337 struct c_arg_info
*args
2338 = c_parser_parms_declarator (parser
, kind
== C_DTR_NORMAL
,
2345 = build_function_declarator (args
,
2346 build_id_declarator (NULL_TREE
));
2347 return c_parser_direct_declarator_inner (parser
, *seen_id
,
2351 /* A parenthesized declarator. */
2352 inner
= c_parser_declarator (parser
, type_seen_p
, kind
, seen_id
);
2353 if (inner
!= NULL
&& attrs
!= NULL
)
2354 inner
= build_attrs_declarator (attrs
, inner
);
2355 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2357 c_parser_consume_token (parser
);
2361 return c_parser_direct_declarator_inner (parser
, *seen_id
, inner
);
2365 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
2372 if (kind
== C_DTR_NORMAL
)
2374 c_parser_error (parser
, "expected identifier or %<(%>");
2378 return build_id_declarator (NULL_TREE
);
2382 /* Parse part of a direct declarator or direct abstract declarator,
2383 given that some (in INNER) has already been parsed; ID_PRESENT is
2384 true if an identifier is present, false for an abstract
2387 static struct c_declarator
*
2388 c_parser_direct_declarator_inner (c_parser
*parser
, bool id_present
,
2389 struct c_declarator
*inner
)
2391 /* Parse a sequence of array declarators and parameter lists. */
2392 if (c_parser_next_token_is (parser
, CPP_OPEN_SQUARE
))
2394 struct c_declarator
*declarator
;
2395 struct c_declspecs
*quals_attrs
= build_null_declspecs ();
2399 c_parser_consume_token (parser
);
2400 c_parser_declspecs (parser
, quals_attrs
, false, false, true);
2401 static_seen
= c_parser_next_token_is_keyword (parser
, RID_STATIC
);
2403 c_parser_consume_token (parser
);
2404 if (static_seen
&& !quals_attrs
->declspecs_seen_p
)
2405 c_parser_declspecs (parser
, quals_attrs
, false, false, true);
2406 if (!quals_attrs
->declspecs_seen_p
)
2408 /* If "static" is present, there must be an array dimension.
2409 Otherwise, there may be a dimension, "*", or no
2414 dimen
= c_parser_expr_no_commas (parser
, NULL
).value
;
2418 if (c_parser_next_token_is (parser
, CPP_CLOSE_SQUARE
))
2423 else if (c_parser_next_token_is (parser
, CPP_MULT
))
2425 if (c_parser_peek_2nd_token (parser
)->type
== CPP_CLOSE_SQUARE
)
2429 c_parser_consume_token (parser
);
2434 dimen
= c_parser_expr_no_commas (parser
, NULL
).value
;
2440 dimen
= c_parser_expr_no_commas (parser
, NULL
).value
;
2443 if (c_parser_next_token_is (parser
, CPP_CLOSE_SQUARE
))
2444 c_parser_consume_token (parser
);
2447 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
2451 declarator
= build_array_declarator (dimen
, quals_attrs
, static_seen
,
2453 if (declarator
== NULL
)
2455 inner
= set_array_declarator_inner (declarator
, inner
, !id_present
);
2456 return c_parser_direct_declarator_inner (parser
, id_present
, inner
);
2458 else if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
2461 struct c_arg_info
*args
;
2462 c_parser_consume_token (parser
);
2463 attrs
= c_parser_attributes (parser
);
2464 args
= c_parser_parms_declarator (parser
, id_present
, attrs
);
2469 inner
= build_function_declarator (args
, inner
);
2470 return c_parser_direct_declarator_inner (parser
, id_present
, inner
);
2476 /* Parse a parameter list or identifier list, including the closing
2477 parenthesis but not the opening one. ATTRS are the attributes at
2478 the start of the list. ID_LIST_OK is true if an identifier list is
2479 acceptable; such a list must not have attributes at the start. */
2481 static struct c_arg_info
*
2482 c_parser_parms_declarator (c_parser
*parser
, bool id_list_ok
, tree attrs
)
2485 declare_parm_level ();
2486 /* If the list starts with an identifier, it is an identifier list.
2487 Otherwise, it is either a prototype list or an empty list. */
2490 && c_parser_next_token_is (parser
, CPP_NAME
)
2491 && c_parser_peek_token (parser
)->id_kind
== C_ID_ID
)
2493 tree list
= NULL_TREE
, *nextp
= &list
;
2494 while (c_parser_next_token_is (parser
, CPP_NAME
)
2495 && c_parser_peek_token (parser
)->id_kind
== C_ID_ID
)
2497 *nextp
= build_tree_list (NULL_TREE
,
2498 c_parser_peek_token (parser
)->value
);
2499 nextp
= & TREE_CHAIN (*nextp
);
2500 c_parser_consume_token (parser
);
2501 if (c_parser_next_token_is_not (parser
, CPP_COMMA
))
2503 c_parser_consume_token (parser
);
2504 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2506 c_parser_error (parser
, "expected identifier");
2510 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2512 struct c_arg_info
*ret
= XOBNEW (&parser_obstack
, struct c_arg_info
);
2517 ret
->pending_sizes
= 0;
2518 ret
->had_vla_unspec
= 0;
2519 c_parser_consume_token (parser
);
2525 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
2533 struct c_arg_info
*ret
= c_parser_parms_list_declarator (parser
, attrs
);
2539 /* Parse a parameter list (possibly empty), including the closing
2540 parenthesis but not the opening one. ATTRS are the attributes at
2541 the start of the list. */
2543 static struct c_arg_info
*
2544 c_parser_parms_list_declarator (c_parser
*parser
, tree attrs
)
2546 bool good_parm
= false;
2547 /* ??? Following the old parser, forward parameter declarations may
2548 use abstract declarators, and if no real parameter declarations
2549 follow the forward declarations then this is not diagnosed. Also
2550 note as above that attributes are ignored as the only contents of
2551 the parentheses, or as the only contents after forward
2553 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2555 struct c_arg_info
*ret
= XOBNEW (&parser_obstack
, struct c_arg_info
);
2560 ret
->pending_sizes
= 0;
2561 ret
->had_vla_unspec
= 0;
2562 c_parser_consume_token (parser
);
2565 if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
))
2567 struct c_arg_info
*ret
= XOBNEW (&parser_obstack
, struct c_arg_info
);
2571 ret
->pending_sizes
= 0;
2572 ret
->had_vla_unspec
= 0;
2573 /* Suppress -Wold-style-definition for this case. */
2574 ret
->types
= error_mark_node
;
2575 error ("ISO C requires a named argument before %<...%>");
2576 c_parser_consume_token (parser
);
2577 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2579 c_parser_consume_token (parser
);
2584 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
2589 /* Nonempty list of parameters, either terminated with semicolon
2590 (forward declarations; recurse) or with close parenthesis (normal
2591 function) or with ", ... )" (variadic function). */
2594 /* Parse a parameter. */
2595 struct c_parm
*parm
= c_parser_parameter_declaration (parser
, attrs
);
2600 push_parm_decl (parm
);
2602 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
2605 c_parser_consume_token (parser
);
2606 mark_forward_parm_decls ();
2607 new_attrs
= c_parser_attributes (parser
);
2608 return c_parser_parms_list_declarator (parser
, new_attrs
);
2610 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2612 c_parser_consume_token (parser
);
2614 return get_parm_info (false);
2617 struct c_arg_info
*ret
2618 = XOBNEW (&parser_obstack
, struct c_arg_info
);
2623 ret
->pending_sizes
= 0;
2624 ret
->had_vla_unspec
= 0;
2628 if (!c_parser_require (parser
, CPP_COMMA
,
2629 "expected %<;%>, %<,%> or %<)%>"))
2631 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
2634 if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
))
2636 c_parser_consume_token (parser
);
2637 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2639 c_parser_consume_token (parser
);
2641 return get_parm_info (true);
2644 struct c_arg_info
*ret
2645 = XOBNEW (&parser_obstack
, struct c_arg_info
);
2650 ret
->pending_sizes
= 0;
2651 ret
->had_vla_unspec
= 0;
2657 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
2665 /* Parse a parameter declaration. ATTRS are the attributes at the
2666 start of the declaration if it is the first parameter. */
2668 static struct c_parm
*
2669 c_parser_parameter_declaration (c_parser
*parser
, tree attrs
)
2671 struct c_declspecs
*specs
;
2672 struct c_declarator
*declarator
;
2674 tree postfix_attrs
= NULL_TREE
;
2676 if (!c_parser_next_token_starts_declspecs (parser
))
2678 /* ??? In some Objective-C cases '...' isn't applicable so there
2679 should be a different message. */
2680 c_parser_error (parser
,
2681 "expected declaration specifiers or %<...%>");
2682 c_parser_skip_to_end_of_parameter (parser
);
2685 specs
= build_null_declspecs ();
2688 declspecs_add_attrs (specs
, attrs
);
2691 c_parser_declspecs (parser
, specs
, true, true, true);
2692 finish_declspecs (specs
);
2693 pending_xref_error ();
2694 prefix_attrs
= specs
->attrs
;
2695 specs
->attrs
= NULL_TREE
;
2696 declarator
= c_parser_declarator (parser
, specs
->type_seen_p
,
2697 C_DTR_PARM
, &dummy
);
2698 if (declarator
== NULL
)
2700 c_parser_skip_until_found (parser
, CPP_COMMA
, NULL
);
2703 if (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
2704 postfix_attrs
= c_parser_attributes (parser
);
2705 return build_c_parm (specs
, chainon (postfix_attrs
, prefix_attrs
),
2709 /* Parse a string literal in an asm expression. It should not be
2710 translated, and wide string literals are an error although
2711 permitted by the syntax. This is a GNU extension.
2716 ??? At present, following the old parser, the caller needs to have
2717 set c_lex_string_translate to 0. It would be better to follow the
2718 C++ parser rather than using the c_lex_string_translate kludge. */
2721 c_parser_asm_string_literal (c_parser
*parser
)
2724 if (c_parser_next_token_is (parser
, CPP_STRING
))
2726 str
= c_parser_peek_token (parser
)->value
;
2727 c_parser_consume_token (parser
);
2729 else if (c_parser_next_token_is (parser
, CPP_WSTRING
))
2731 error ("wide string literal in %<asm%>");
2732 str
= build_string (1, "");
2733 c_parser_consume_token (parser
);
2737 c_parser_error (parser
, "expected string literal");
2743 /* Parse a simple asm expression. This is used in restricted
2744 contexts, where a full expression with inputs and outputs does not
2745 make sense. This is a GNU extension.
2748 asm ( asm-string-literal )
2752 c_parser_simple_asm_expr (c_parser
*parser
)
2755 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_ASM
));
2756 /* ??? Follow the C++ parser rather than using the
2757 c_lex_string_translate kludge. */
2758 c_lex_string_translate
= 0;
2759 c_parser_consume_token (parser
);
2760 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
2762 c_lex_string_translate
= 1;
2765 str
= c_parser_asm_string_literal (parser
);
2766 c_lex_string_translate
= 1;
2767 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
2769 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
2775 /* Parse (possibly empty) attributes. This is a GNU extension.
2779 attributes attribute
2782 __attribute__ ( ( attribute-list ) )
2786 attribute_list , attrib
2791 any-word ( identifier )
2792 any-word ( identifier , nonempty-expr-list )
2793 any-word ( expr-list )
2795 where the "identifier" must not be declared as a type, and
2796 "any-word" may be any identifier (including one declared as a
2797 type), a reserved word storage class specifier, type specifier or
2798 type qualifier. ??? This still leaves out most reserved keywords
2799 (following the old parser), shouldn't we include them, and why not
2800 allow identifiers declared as types to start the arguments? */
2803 c_parser_attributes (c_parser
*parser
)
2805 tree attrs
= NULL_TREE
;
2806 while (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
2808 /* ??? Follow the C++ parser rather than using the
2809 c_lex_string_translate kludge. */
2810 c_lex_string_translate
= 0;
2811 c_parser_consume_token (parser
);
2812 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
2814 c_lex_string_translate
= 1;
2817 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
2819 c_lex_string_translate
= 1;
2820 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
2823 /* Parse the attribute list. */
2824 while (c_parser_next_token_is (parser
, CPP_COMMA
)
2825 || c_parser_next_token_is (parser
, CPP_NAME
)
2826 || c_parser_next_token_is (parser
, CPP_KEYWORD
))
2828 tree attr
, attr_name
, attr_args
;
2829 if (c_parser_next_token_is (parser
, CPP_COMMA
))
2831 c_parser_consume_token (parser
);
2834 if (c_parser_next_token_is (parser
, CPP_KEYWORD
))
2836 /* ??? See comment above about what keywords are
2839 switch (c_parser_peek_token (parser
)->keyword
)
2874 attr_name
= c_parser_peek_token (parser
)->value
;
2875 c_parser_consume_token (parser
);
2876 if (c_parser_next_token_is_not (parser
, CPP_OPEN_PAREN
))
2878 attr
= build_tree_list (attr_name
, NULL_TREE
);
2879 attrs
= chainon (attrs
, attr
);
2882 c_parser_consume_token (parser
);
2883 /* Parse the attribute contents. If they start with an
2884 identifier which is followed by a comma or close
2885 parenthesis, then the arguments start with that
2886 identifier; otherwise they are an expression list. */
2887 if (c_parser_next_token_is (parser
, CPP_NAME
)
2888 && c_parser_peek_token (parser
)->id_kind
== C_ID_ID
2889 && ((c_parser_peek_2nd_token (parser
)->type
== CPP_COMMA
)
2890 || (c_parser_peek_2nd_token (parser
)->type
2891 == CPP_CLOSE_PAREN
)))
2893 tree arg1
= c_parser_peek_token (parser
)->value
;
2894 c_parser_consume_token (parser
);
2895 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2896 attr_args
= build_tree_list (NULL_TREE
, arg1
);
2899 c_parser_consume_token (parser
);
2900 attr_args
= tree_cons (NULL_TREE
, arg1
,
2901 c_parser_expr_list (parser
, false));
2906 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2907 attr_args
= NULL_TREE
;
2909 attr_args
= c_parser_expr_list (parser
, false);
2911 attr
= build_tree_list (attr_name
, attr_args
);
2912 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2913 c_parser_consume_token (parser
);
2916 c_lex_string_translate
= 1;
2917 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
2921 attrs
= chainon (attrs
, attr
);
2923 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2924 c_parser_consume_token (parser
);
2927 c_lex_string_translate
= 1;
2928 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
2932 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2933 c_parser_consume_token (parser
);
2936 c_lex_string_translate
= 1;
2937 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
2941 c_lex_string_translate
= 1;
2946 /* Parse a type name (C90 6.5.5, C99 6.7.6).
2949 specifier-qualifier-list abstract-declarator[opt]
2952 static struct c_type_name
*
2953 c_parser_type_name (c_parser
*parser
)
2955 struct c_declspecs
*specs
= build_null_declspecs ();
2956 struct c_declarator
*declarator
;
2957 struct c_type_name
*ret
;
2959 c_parser_declspecs (parser
, specs
, false, true, true);
2960 if (!specs
->declspecs_seen_p
)
2962 c_parser_error (parser
, "expected specifier-qualifier-list");
2965 pending_xref_error ();
2966 finish_declspecs (specs
);
2967 declarator
= c_parser_declarator (parser
, specs
->type_seen_p
,
2968 C_DTR_ABSTRACT
, &dummy
);
2969 if (declarator
== NULL
)
2971 ret
= XOBNEW (&parser_obstack
, struct c_type_name
);
2973 ret
->declarator
= declarator
;
2977 /* Parse an initializer (C90 6.5.7, C99 6.7.8).
2980 assignment-expression
2981 { initializer-list }
2982 { initializer-list , }
2985 designation[opt] initializer
2986 initializer-list , designation[opt] initializer
2993 designator-list designator
3000 [ constant-expression ]
3012 [ constant-expression ... constant-expression ]
3014 Any expression without commas is accepted in the syntax for the
3015 constant-expressions, with non-constant expressions rejected later.
3017 This function is only used for top-level initializers; for nested
3018 ones, see c_parser_initval. */
3020 static struct c_expr
3021 c_parser_initializer (c_parser
*parser
)
3023 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
3024 return c_parser_braced_init (parser
, NULL_TREE
, false);
3028 ret
= c_parser_expr_no_commas (parser
, NULL
);
3029 if (TREE_CODE (ret
.value
) != STRING_CST
3030 && TREE_CODE (ret
.value
) != COMPOUND_LITERAL_EXPR
)
3031 ret
= default_function_array_conversion (ret
);
3036 /* Parse a braced initializer list. TYPE is the type specified for a
3037 compound literal, and NULL_TREE for other initializers and for
3038 nested braced lists. NESTED_P is true for nested braced lists,
3039 false for the list of a compound literal or the list that is the
3040 top-level initializer in a declaration. */
3042 static struct c_expr
3043 c_parser_braced_init (c_parser
*parser
, tree type
, bool nested_p
)
3045 gcc_assert (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
));
3046 c_parser_consume_token (parser
);
3048 push_init_level (0);
3050 really_start_incremental_init (type
);
3051 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
3054 pedwarn ("ISO C forbids empty initializer braces");
3058 /* Parse a non-empty initializer list, possibly with a trailing
3062 c_parser_initelt (parser
);
3065 if (c_parser_next_token_is (parser
, CPP_COMMA
))
3066 c_parser_consume_token (parser
);
3069 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
3073 if (c_parser_next_token_is_not (parser
, CPP_CLOSE_BRACE
))
3076 ret
.value
= error_mark_node
;
3077 ret
.original_code
= ERROR_MARK
;
3078 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
, "expected %<}%>");
3081 c_parser_consume_token (parser
);
3082 return pop_init_level (0);
3085 /* Parse a nested initializer, including designators. */
3088 c_parser_initelt (c_parser
*parser
)
3090 /* Parse any designator or designator list. A single array
3091 designator may have the subsequent "=" omitted in GNU C, but a
3092 longer list or a structure member designator may not. */
3093 if (c_parser_next_token_is (parser
, CPP_NAME
)
3094 && c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
)
3096 /* Old-style structure member designator. */
3097 set_init_label (c_parser_peek_token (parser
)->value
);
3099 pedwarn ("obsolete use of designated initializer with %<:%>");
3100 c_parser_consume_token (parser
);
3101 c_parser_consume_token (parser
);
3105 /* des_seen is 0 if there have been no designators, 1 if there
3106 has been a single array designator and 2 otherwise. */
3108 while (c_parser_next_token_is (parser
, CPP_OPEN_SQUARE
)
3109 || c_parser_next_token_is (parser
, CPP_DOT
))
3111 int des_prev
= des_seen
;
3114 if (c_parser_next_token_is (parser
, CPP_DOT
))
3117 c_parser_consume_token (parser
);
3118 if (c_parser_next_token_is (parser
, CPP_NAME
))
3120 set_init_label (c_parser_peek_token (parser
)->value
);
3121 c_parser_consume_token (parser
);
3126 init
.value
= error_mark_node
;
3127 init
.original_code
= ERROR_MARK
;
3128 c_parser_error (parser
, "expected identifier");
3129 c_parser_skip_until_found (parser
, CPP_COMMA
, NULL
);
3130 process_init_element (init
);
3137 /* ??? Following the old parser, [ objc-receiver
3138 objc-message-args ] is accepted as an initializer,
3139 being distinguished from a designator by what follows
3140 the first assignment expression inside the square
3141 brackets, but after a first array designator a
3142 subsequent square bracket is for Objective-C taken to
3143 start an expression, using the obsolete form of
3144 designated initializer without '=', rather than
3145 possibly being a second level of designation: in LALR
3146 terms, the '[' is shifted rather than reducing
3147 designator to designator-list. */
3148 if (des_prev
== 1 && c_dialect_objc ())
3150 des_seen
= des_prev
;
3153 if (des_prev
== 0 && c_dialect_objc ())
3155 /* This might be an array designator or an
3156 Objective-C message expression. If the former,
3157 continue parsing here; if the latter, parse the
3158 remainder of the initializer given the starting
3159 primary-expression. ??? It might make sense to
3160 distinguish when des_prev == 1 as well; see
3161 previous comment. */
3163 struct c_expr mexpr
;
3164 c_parser_consume_token (parser
);
3165 if (c_parser_peek_token (parser
)->type
== CPP_NAME
3166 && ((c_parser_peek_token (parser
)->id_kind
3168 || (c_parser_peek_token (parser
)->id_kind
3169 == C_ID_CLASSNAME
)))
3171 /* Type name receiver. */
3172 tree id
= c_parser_peek_token (parser
)->value
;
3173 c_parser_consume_token (parser
);
3174 rec
= objc_get_class_reference (id
);
3175 goto parse_message_args
;
3177 first
= c_parser_expr_no_commas (parser
, NULL
).value
;
3178 if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
)
3179 || c_parser_next_token_is (parser
, CPP_CLOSE_SQUARE
))
3180 goto array_desig_after_first
;
3181 /* Expression receiver. So far only one part
3182 without commas has been parsed; there might be
3183 more of the expression. */
3185 while (c_parser_next_token_is (parser
, CPP_COMMA
))
3188 c_parser_consume_token (parser
);
3189 next
= c_parser_expr_no_commas (parser
, NULL
);
3190 next
= default_function_array_conversion (next
);
3191 rec
= build_compound_expr (rec
, next
.value
);
3194 /* Now parse the objc-message-args. */
3195 args
= c_parser_objc_message_args (parser
);
3196 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
3199 = objc_build_message_expr (build_tree_list (rec
, args
));
3200 mexpr
.original_code
= ERROR_MARK
;
3201 /* Now parse and process the remainder of the
3202 initializer, starting with this message
3203 expression as a primary-expression. */
3204 c_parser_initval (parser
, &mexpr
);
3207 c_parser_consume_token (parser
);
3208 first
= c_parser_expr_no_commas (parser
, NULL
).value
;
3209 array_desig_after_first
:
3210 if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
))
3212 c_parser_consume_token (parser
);
3213 second
= c_parser_expr_no_commas (parser
, NULL
).value
;
3217 if (c_parser_next_token_is (parser
, CPP_CLOSE_SQUARE
))
3219 c_parser_consume_token (parser
);
3220 set_init_index (first
, second
);
3221 if (pedantic
&& second
)
3222 pedwarn ("ISO C forbids specifying range of "
3223 "elements to initialize");
3226 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
3232 if (c_parser_next_token_is (parser
, CPP_EQ
))
3234 if (pedantic
&& !flag_isoc99
)
3235 pedwarn ("ISO C90 forbids specifying subobject to initialize");
3236 c_parser_consume_token (parser
);
3243 pedwarn ("obsolete use of designated initializer "
3249 init
.value
= error_mark_node
;
3250 init
.original_code
= ERROR_MARK
;
3251 c_parser_error (parser
, "expected %<=%>");
3252 c_parser_skip_until_found (parser
, CPP_COMMA
, NULL
);
3253 process_init_element (init
);
3259 c_parser_initval (parser
, NULL
);
3262 /* Parse a nested initializer; as c_parser_initializer but parses
3263 initializers within braced lists, after any designators have been
3264 applied. If AFTER is not NULL then it is an Objective-C message
3265 expression which is the primary-expression starting the
3269 c_parser_initval (c_parser
*parser
, struct c_expr
*after
)
3272 gcc_assert (!after
|| c_dialect_objc ());
3273 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
) && !after
)
3274 init
= c_parser_braced_init (parser
, NULL_TREE
, true);
3277 init
= c_parser_expr_no_commas (parser
, after
);
3278 if (init
.value
!= NULL_TREE
3279 && TREE_CODE (init
.value
) != STRING_CST
3280 && TREE_CODE (init
.value
) != COMPOUND_LITERAL_EXPR
)
3281 init
= default_function_array_conversion (init
);
3283 process_init_element (init
);
3286 /* Parse a compound statement (possibly a function body) (C90 6.6.2,
3290 { block-item-list[opt] }
3291 { label-declarations block-item-list }
3295 block-item-list block-item
3307 { label-declarations block-item-list }
3310 __extension__ nested-declaration
3311 nested-function-definition
3315 label-declarations label-declaration
3318 __label__ identifier-list ;
3320 Allowing the mixing of declarations and code is new in C99. The
3321 GNU syntax also permits (not shown above) labels at the end of
3322 compound statements, which yield an error. We don't allow labels
3323 on declarations; this might seem like a natural extension, but
3324 there would be a conflict between attributes on the label and
3325 prefix attributes on the declaration. ??? The syntax follows the
3326 old parser in requiring something after label declarations.
3327 Although they are erroneous if the labels declared aren't defined,
3328 is it useful for the syntax to be this way?
3340 c_parser_compound_statement (c_parser
*parser
)
3343 if (!c_parser_require (parser
, CPP_OPEN_BRACE
, "expected %<{%>"))
3344 return error_mark_node
;
3345 stmt
= c_begin_compound_stmt (true);
3346 c_parser_compound_statement_nostart (parser
);
3347 return c_end_compound_stmt (stmt
, true);
3350 /* Parse a compound statement except for the opening brace. This is
3351 used for parsing both compound statements and statement expressions
3352 (which follow different paths to handling the opening). */
3355 c_parser_compound_statement_nostart (c_parser
*parser
)
3357 bool last_stmt
= false;
3358 bool last_label
= false;
3359 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
3361 c_parser_consume_token (parser
);
3364 if (c_parser_next_token_is_keyword (parser
, RID_LABEL
))
3366 /* Read zero or more forward-declarations for labels that nested
3367 functions can jump to. */
3368 while (c_parser_next_token_is_keyword (parser
, RID_LABEL
))
3370 c_parser_consume_token (parser
);
3371 /* Any identifiers, including those declared as type names,
3376 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
3378 c_parser_error (parser
, "expected identifier");
3382 = declare_label (c_parser_peek_token (parser
)->value
);
3383 C_DECLARED_LABEL_FLAG (label
) = 1;
3384 add_stmt (build_stmt (DECL_EXPR
, label
));
3385 c_parser_consume_token (parser
);
3386 if (c_parser_next_token_is (parser
, CPP_COMMA
))
3387 c_parser_consume_token (parser
);
3391 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
3393 /* ??? Locating this diagnostic on the token after the
3394 declarations end follows the old parser, but it might be
3395 better to locate it where the declarations start instead. */
3397 pedwarn ("ISO C forbids label declarations");
3399 /* We must now have at least one statement, label or declaration. */
3400 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
3402 c_parser_error (parser
, "expected declaration or statement");
3403 c_parser_consume_token (parser
);
3406 while (c_parser_next_token_is_not (parser
, CPP_CLOSE_BRACE
))
3408 location_t loc
= c_parser_peek_token (parser
)->location
;
3409 if (c_parser_next_token_is_keyword (parser
, RID_CASE
)
3410 || c_parser_next_token_is_keyword (parser
, RID_DEFAULT
)
3411 || (c_parser_next_token_is (parser
, CPP_NAME
)
3412 && c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
))
3416 c_parser_label (parser
);
3418 else if (!last_label
3419 && c_parser_next_token_starts_declspecs (parser
))
3422 c_parser_declaration_or_fndef (parser
, true, true, true, true);
3424 && ((pedantic
&& !flag_isoc99
)
3425 || warn_declaration_after_statement
))
3426 pedwarn_c90 ("%HISO C90 forbids mixed declarations and code",
3430 else if (!last_label
3431 && c_parser_next_token_is_keyword (parser
, RID_EXTENSION
))
3433 /* __extension__ can start a declaration, but is also an
3434 unary operator that can start an expression. Consume all
3435 but the last of a possible series of __extension__ to
3437 while (c_parser_peek_2nd_token (parser
)->type
== CPP_KEYWORD
3438 && (c_parser_peek_2nd_token (parser
)->keyword
3440 c_parser_consume_token (parser
);
3441 if (c_token_starts_declspecs (c_parser_peek_2nd_token (parser
)))
3444 ext
= disable_extension_diagnostics ();
3445 c_parser_consume_token (parser
);
3447 c_parser_declaration_or_fndef (parser
, true, true, true, true);
3448 /* Following the old parser, __extension__ does not
3449 disable this diagnostic. */
3450 restore_extension_diagnostics (ext
);
3452 && ((pedantic
&& !flag_isoc99
)
3453 || warn_declaration_after_statement
))
3454 pedwarn_c90 ("%HISO C90 forbids mixed declarations and code",
3461 else if (c_parser_next_token_is (parser
, CPP_PRAGMA
))
3463 /* External pragmas, and some omp pragmas, are not associated
3464 with regular c code, and so are not to be considered statements
3465 syntactically. This ensures that the user doesn't put them
3466 places that would turn into syntax errors if the directive
3468 if (c_parser_pragma (parser
, pragma_compound
))
3469 last_label
= false, last_stmt
= true;
3471 else if (c_parser_next_token_is (parser
, CPP_EOF
))
3473 c_parser_error (parser
, "expected declaration or statement");
3481 c_parser_statement_after_labels (parser
);
3484 parser
->error
= false;
3487 error ("label at end of compound statement");
3488 c_parser_consume_token (parser
);
3491 /* Parse a label (C90 6.6.1, C99 6.8.1).
3494 identifier : attributes[opt]
3495 case constant-expression :
3501 case constant-expression ... constant-expression :
3503 The use of attributes on labels is a GNU extension. The syntax in
3504 GNU C accepts any expressions without commas, non-constant
3505 expressions being rejected later. */
3508 c_parser_label (c_parser
*parser
)
3510 location_t loc1
= c_parser_peek_token (parser
)->location
;
3511 tree label
= NULL_TREE
;
3512 if (c_parser_next_token_is_keyword (parser
, RID_CASE
))
3515 c_parser_consume_token (parser
);
3516 exp1
= c_parser_expr_no_commas (parser
, NULL
).value
;
3517 if (c_parser_next_token_is (parser
, CPP_COLON
))
3519 c_parser_consume_token (parser
);
3520 label
= do_case (exp1
, NULL_TREE
);
3522 else if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
))
3524 c_parser_consume_token (parser
);
3525 exp2
= c_parser_expr_no_commas (parser
, NULL
).value
;
3526 if (c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
3527 label
= do_case (exp1
, exp2
);
3530 c_parser_error (parser
, "expected %<:%> or %<...%>");
3532 else if (c_parser_next_token_is_keyword (parser
, RID_DEFAULT
))
3534 c_parser_consume_token (parser
);
3535 if (c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
3536 label
= do_case (NULL_TREE
, NULL_TREE
);
3540 tree name
= c_parser_peek_token (parser
)->value
;
3544 gcc_assert (c_parser_next_token_is (parser
, CPP_NAME
));
3545 c_parser_consume_token (parser
);
3546 gcc_assert (c_parser_next_token_is (parser
, CPP_COLON
));
3547 loc2
= c_parser_peek_token (parser
)->location
;
3548 c_parser_consume_token (parser
);
3549 attrs
= c_parser_attributes (parser
);
3550 tlab
= define_label (loc2
, name
);
3553 decl_attributes (&tlab
, attrs
, 0);
3554 label
= add_stmt (build_stmt (LABEL_EXPR
, tlab
));
3558 SET_EXPR_LOCATION (label
, loc1
);
3561 /* Parse a statement (C90 6.6, C99 6.8).
3566 expression-statement
3574 expression-statement:
3577 selection-statement:
3581 iteration-statement:
3590 return expression[opt] ;
3603 objc-throw-statement
3604 objc-try-catch-statement
3605 objc-synchronized-statement
3607 objc-throw-statement:
3621 parallel-for-construct
3622 parallel-sections-construct
3629 parallel-directive structured-block
3632 for-directive iteration-statement
3635 sections-directive section-scope
3638 single-directive structured-block
3640 parallel-for-construct:
3641 parallel-for-directive iteration-statement
3643 parallel-sections-construct:
3644 parallel-sections-directive section-scope
3647 master-directive structured-block
3650 critical-directive structured-block
3653 atomic-directive expression-statement
3656 ordered-directive structured-block */
3659 c_parser_statement (c_parser
*parser
)
3661 while (c_parser_next_token_is_keyword (parser
, RID_CASE
)
3662 || c_parser_next_token_is_keyword (parser
, RID_DEFAULT
)
3663 || (c_parser_next_token_is (parser
, CPP_NAME
)
3664 && c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
))
3665 c_parser_label (parser
);
3666 c_parser_statement_after_labels (parser
);
3669 /* Parse a statement, other than a labeled statement. */
3672 c_parser_statement_after_labels (c_parser
*parser
)
3674 location_t loc
= c_parser_peek_token (parser
)->location
;
3675 tree stmt
= NULL_TREE
;
3676 switch (c_parser_peek_token (parser
)->type
)
3678 case CPP_OPEN_BRACE
:
3679 add_stmt (c_parser_compound_statement (parser
));
3682 switch (c_parser_peek_token (parser
)->keyword
)
3685 c_parser_if_statement (parser
);
3688 c_parser_switch_statement (parser
);
3691 c_parser_while_statement (parser
);
3694 c_parser_do_statement (parser
);
3697 c_parser_for_statement (parser
);
3700 c_parser_consume_token (parser
);
3701 if (c_parser_next_token_is (parser
, CPP_NAME
))
3703 stmt
= c_finish_goto_label (c_parser_peek_token (parser
)->value
);
3704 c_parser_consume_token (parser
);
3706 else if (c_parser_next_token_is (parser
, CPP_MULT
))
3708 c_parser_consume_token (parser
);
3709 stmt
= c_finish_goto_ptr (c_parser_expression (parser
).value
);
3712 c_parser_error (parser
, "expected identifier or %<*%>");
3713 goto expect_semicolon
;
3715 c_parser_consume_token (parser
);
3716 stmt
= c_finish_bc_stmt (&c_cont_label
, false);
3717 goto expect_semicolon
;
3719 c_parser_consume_token (parser
);
3720 stmt
= c_finish_bc_stmt (&c_break_label
, true);
3721 goto expect_semicolon
;
3723 c_parser_consume_token (parser
);
3724 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
3726 stmt
= c_finish_return (NULL_TREE
);
3727 c_parser_consume_token (parser
);
3731 stmt
= c_finish_return (c_parser_expression_conv (parser
).value
);
3732 goto expect_semicolon
;
3736 stmt
= c_parser_asm_statement (parser
);
3739 gcc_assert (c_dialect_objc ());
3740 c_parser_consume_token (parser
);
3741 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
3743 stmt
= objc_build_throw_stmt (NULL_TREE
);
3744 c_parser_consume_token (parser
);
3749 = objc_build_throw_stmt (c_parser_expression (parser
).value
);
3750 goto expect_semicolon
;
3754 gcc_assert (c_dialect_objc ());
3755 c_parser_objc_try_catch_statement (parser
);
3757 case RID_AT_SYNCHRONIZED
:
3758 gcc_assert (c_dialect_objc ());
3759 c_parser_objc_synchronized_statement (parser
);
3766 c_parser_consume_token (parser
);
3768 case CPP_CLOSE_PAREN
:
3769 case CPP_CLOSE_SQUARE
:
3770 /* Avoid infinite loop in error recovery:
3771 c_parser_skip_until_found stops at a closing nesting
3772 delimiter without consuming it, but here we need to consume
3773 it to proceed further. */
3774 c_parser_error (parser
, "expected statement");
3775 c_parser_consume_token (parser
);
3778 c_parser_pragma (parser
, pragma_stmt
);
3782 stmt
= c_finish_expr_stmt (c_parser_expression_conv (parser
).value
);
3784 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
3787 /* Two cases cannot and do not have line numbers associated: If stmt
3788 is degenerate, such as "2;", then stmt is an INTEGER_CST, which
3789 cannot hold line numbers. But that's OK because the statement
3790 will either be changed to a MODIFY_EXPR during gimplification of
3791 the statement expr, or discarded. If stmt was compound, but
3792 without new variables, we will have skipped the creation of a
3793 BIND and will have a bare STATEMENT_LIST. But that's OK because
3794 (recursively) all of the component statements should already have
3795 line numbers assigned. ??? Can we discard no-op statements
3797 if (stmt
&& CAN_HAVE_LOCATION_P (stmt
))
3798 SET_EXPR_LOCATION (stmt
, loc
);
3801 /* Parse a parenthesized condition from an if, do or while statement.
3807 c_parser_paren_condition (c_parser
*parser
)
3811 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
3812 return error_mark_node
;
3813 loc
= c_parser_peek_token (parser
)->location
;
3814 cond
= c_objc_common_truthvalue_conversion
3815 (c_parser_expression_conv (parser
).value
);
3816 if (CAN_HAVE_LOCATION_P (cond
))
3817 SET_EXPR_LOCATION (cond
, loc
);
3818 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
3822 /* Parse a statement which is a block in C99. */
3825 c_parser_c99_block_statement (c_parser
*parser
)
3827 tree block
= c_begin_compound_stmt (flag_isoc99
);
3828 c_parser_statement (parser
);
3829 return c_end_compound_stmt (block
, flag_isoc99
);
3832 /* Parse the body of an if statement or the else half thereof. This
3833 is just parsing a statement but (a) it is a block in C99, (b) we
3834 track whether the body is an if statement for the sake of
3835 -Wparentheses warnings, (c) we handle an empty body specially for
3836 the sake of -Wempty-body warnings. */
3839 c_parser_if_body (c_parser
*parser
, bool *if_p
)
3841 tree block
= c_begin_compound_stmt (flag_isoc99
);
3842 while (c_parser_next_token_is_keyword (parser
, RID_CASE
)
3843 || c_parser_next_token_is_keyword (parser
, RID_DEFAULT
)
3844 || (c_parser_next_token_is (parser
, CPP_NAME
)
3845 && c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
))
3846 c_parser_label (parser
);
3847 *if_p
= c_parser_next_token_is_keyword (parser
, RID_IF
);
3848 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
3849 add_stmt (build_empty_stmt ());
3850 c_parser_statement_after_labels (parser
);
3851 return c_end_compound_stmt (block
, flag_isoc99
);
3854 /* Parse an if statement (C90 6.6.4, C99 6.8.4).
3857 if ( expression ) statement
3858 if ( expression ) statement else statement
3862 c_parser_if_statement (c_parser
*parser
)
3867 bool first_if
= false, second_if
= false;
3868 tree first_body
, second_body
;
3869 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_IF
));
3870 c_parser_consume_token (parser
);
3871 block
= c_begin_compound_stmt (flag_isoc99
);
3872 loc
= c_parser_peek_token (parser
)->location
;
3873 cond
= c_parser_paren_condition (parser
);
3874 first_body
= c_parser_if_body (parser
, &first_if
);
3875 if (c_parser_next_token_is_keyword (parser
, RID_ELSE
))
3877 c_parser_consume_token (parser
);
3878 second_body
= c_parser_if_body (parser
, &second_if
);
3881 second_body
= NULL_TREE
;
3882 c_finish_if_stmt (loc
, cond
, first_body
, second_body
, first_if
);
3883 add_stmt (c_end_compound_stmt (block
, flag_isoc99
));
3886 /* Parse a switch statement (C90 6.6.4, C99 6.8.4).
3889 switch (expression) statement
3893 c_parser_switch_statement (c_parser
*parser
)
3895 tree block
, expr
, body
, save_break
;
3896 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_SWITCH
));
3897 c_parser_consume_token (parser
);
3898 block
= c_begin_compound_stmt (flag_isoc99
);
3899 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
3901 expr
= c_parser_expression (parser
).value
;
3902 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
3905 expr
= error_mark_node
;
3906 c_start_case (expr
);
3907 save_break
= c_break_label
;
3908 c_break_label
= NULL_TREE
;
3909 body
= c_parser_c99_block_statement (parser
);
3910 c_finish_case (body
);
3912 add_stmt (build1 (LABEL_EXPR
, void_type_node
, c_break_label
));
3913 c_break_label
= save_break
;
3914 add_stmt (c_end_compound_stmt (block
, flag_isoc99
));
3917 /* Parse a while statement (C90 6.6.5, C99 6.8.5).
3920 while (expression) statement
3924 c_parser_while_statement (c_parser
*parser
)
3926 tree block
, cond
, body
, save_break
, save_cont
;
3928 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_WHILE
));
3929 c_parser_consume_token (parser
);
3930 block
= c_begin_compound_stmt (flag_isoc99
);
3931 loc
= c_parser_peek_token (parser
)->location
;
3932 cond
= c_parser_paren_condition (parser
);
3933 save_break
= c_break_label
;
3934 c_break_label
= NULL_TREE
;
3935 save_cont
= c_cont_label
;
3936 c_cont_label
= NULL_TREE
;
3937 body
= c_parser_c99_block_statement (parser
);
3938 c_finish_loop (loc
, cond
, NULL
, body
, c_break_label
, c_cont_label
, true);
3939 add_stmt (c_end_compound_stmt (block
, flag_isoc99
));
3940 c_break_label
= save_break
;
3941 c_cont_label
= save_cont
;
3944 /* Parse a do statement (C90 6.6.5, C99 6.8.5).
3947 do statement while ( expression ) ;
3951 c_parser_do_statement (c_parser
*parser
)
3953 tree block
, cond
, body
, save_break
, save_cont
, new_break
, new_cont
;
3955 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_DO
));
3956 c_parser_consume_token (parser
);
3957 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
3958 warning (OPT_Wempty_body
,
3959 "suggest braces around empty body in %<do%> statement");
3960 block
= c_begin_compound_stmt (flag_isoc99
);
3961 loc
= c_parser_peek_token (parser
)->location
;
3962 save_break
= c_break_label
;
3963 c_break_label
= NULL_TREE
;
3964 save_cont
= c_cont_label
;
3965 c_cont_label
= NULL_TREE
;
3966 body
= c_parser_c99_block_statement (parser
);
3967 c_parser_require_keyword (parser
, RID_WHILE
, "expected %<while%>");
3968 new_break
= c_break_label
;
3969 c_break_label
= save_break
;
3970 new_cont
= c_cont_label
;
3971 c_cont_label
= save_cont
;
3972 cond
= c_parser_paren_condition (parser
);
3973 if (!c_parser_require (parser
, CPP_SEMICOLON
, "expected %<;%>"))
3974 c_parser_skip_to_end_of_block_or_statement (parser
);
3975 c_finish_loop (loc
, cond
, NULL
, body
, new_break
, new_cont
, false);
3976 add_stmt (c_end_compound_stmt (block
, flag_isoc99
));
3979 /* Parse a for statement (C90 6.6.5, C99 6.8.5).
3982 for ( expression[opt] ; expression[opt] ; expression[opt] ) statement
3983 for ( nested-declaration expression[opt] ; expression[opt] ) statement
3985 The form with a declaration is new in C99.
3987 ??? In accordance with the old parser, the declaration may be a
3988 nested function, which is then rejected in check_for_loop_decls,
3989 but does it make any sense for this to be included in the grammar?
3990 Note in particular that the nested function does not include a
3991 trailing ';', whereas the "declaration" production includes one.
3992 Also, can we reject bad declarations earlier and cheaper than
3993 check_for_loop_decls? */
3996 c_parser_for_statement (c_parser
*parser
)
3998 tree block
, cond
, incr
, save_break
, save_cont
, body
;
4000 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_FOR
));
4001 loc
= c_parser_peek_token (parser
)->location
;
4002 c_parser_consume_token (parser
);
4003 block
= c_begin_compound_stmt (flag_isoc99
);
4004 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
4006 /* Parse the initialization declaration or expression. */
4007 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
4009 c_parser_consume_token (parser
);
4010 c_finish_expr_stmt (NULL_TREE
);
4012 else if (c_parser_next_token_starts_declspecs (parser
))
4014 c_parser_declaration_or_fndef (parser
, true, true, true, true);
4015 check_for_loop_decls ();
4017 else if (c_parser_next_token_is_keyword (parser
, RID_EXTENSION
))
4019 /* __extension__ can start a declaration, but is also an
4020 unary operator that can start an expression. Consume all
4021 but the last of a possible series of __extension__ to
4023 while (c_parser_peek_2nd_token (parser
)->type
== CPP_KEYWORD
4024 && (c_parser_peek_2nd_token (parser
)->keyword
4026 c_parser_consume_token (parser
);
4027 if (c_token_starts_declspecs (c_parser_peek_2nd_token (parser
)))
4030 ext
= disable_extension_diagnostics ();
4031 c_parser_consume_token (parser
);
4032 c_parser_declaration_or_fndef (parser
, true, true, true, true);
4033 restore_extension_diagnostics (ext
);
4034 check_for_loop_decls ();
4042 c_finish_expr_stmt (c_parser_expression (parser
).value
);
4043 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
4045 /* Parse the loop condition. */
4046 loc
= c_parser_peek_token (parser
)->location
;
4047 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
4049 c_parser_consume_token (parser
);
4054 tree ocond
= c_parser_expression_conv (parser
).value
;
4055 cond
= c_objc_common_truthvalue_conversion (ocond
);
4056 if (CAN_HAVE_LOCATION_P (cond
))
4057 SET_EXPR_LOCATION (cond
, loc
);
4058 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
4060 /* Parse the increment expression. */
4061 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
4062 incr
= c_process_expr_stmt (NULL_TREE
);
4064 incr
= c_process_expr_stmt (c_parser_expression (parser
).value
);
4065 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
4069 cond
= error_mark_node
;
4070 incr
= error_mark_node
;
4072 save_break
= c_break_label
;
4073 c_break_label
= NULL_TREE
;
4074 save_cont
= c_cont_label
;
4075 c_cont_label
= NULL_TREE
;
4076 body
= c_parser_c99_block_statement (parser
);
4077 c_finish_loop (loc
, cond
, incr
, body
, c_break_label
, c_cont_label
, true);
4078 add_stmt (c_end_compound_stmt (block
, flag_isoc99
));
4079 c_break_label
= save_break
;
4080 c_cont_label
= save_cont
;
4083 /* Parse an asm statement, a GNU extension. This is a full-blown asm
4084 statement with inputs, outputs, clobbers, and volatile tag
4088 asm type-qualifier[opt] ( asm-argument ) ;
4092 asm-string-literal : asm-operands[opt]
4093 asm-string-literal : asm-operands[opt] : asm-operands[opt]
4094 asm-string-literal : asm-operands[opt] : asm-operands[opt] : asm-clobbers
4096 Qualifiers other than volatile are accepted in the syntax but
4100 c_parser_asm_statement (c_parser
*parser
)
4102 tree quals
, str
, outputs
, inputs
, clobbers
, ret
;
4104 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_ASM
));
4105 c_parser_consume_token (parser
);
4106 if (c_parser_next_token_is_keyword (parser
, RID_VOLATILE
))
4108 quals
= c_parser_peek_token (parser
)->value
;
4109 c_parser_consume_token (parser
);
4111 else if (c_parser_next_token_is_keyword (parser
, RID_CONST
)
4112 || c_parser_next_token_is_keyword (parser
, RID_RESTRICT
))
4114 warning (0, "%E qualifier ignored on asm",
4115 c_parser_peek_token (parser
)->value
);
4117 c_parser_consume_token (parser
);
4121 /* ??? Follow the C++ parser rather than using the
4122 c_lex_string_translate kludge. */
4123 c_lex_string_translate
= 0;
4124 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
4126 c_lex_string_translate
= 1;
4129 str
= c_parser_asm_string_literal (parser
);
4130 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
4133 outputs
= NULL_TREE
;
4135 clobbers
= NULL_TREE
;
4138 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%> or %<)%>"))
4140 c_lex_string_translate
= 1;
4141 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
4145 /* Parse outputs. */
4146 if (c_parser_next_token_is (parser
, CPP_COLON
)
4147 || c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
4148 outputs
= NULL_TREE
;
4150 outputs
= c_parser_asm_operands (parser
, false);
4151 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
4154 clobbers
= NULL_TREE
;
4157 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%> or %<)%>"))
4159 c_lex_string_translate
= 1;
4160 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
4164 if (c_parser_next_token_is (parser
, CPP_COLON
)
4165 || c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
4168 inputs
= c_parser_asm_operands (parser
, true);
4169 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
4171 clobbers
= NULL_TREE
;
4174 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%> or %<)%>"))
4176 c_lex_string_translate
= 1;
4177 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
4180 /* Parse clobbers. */
4181 clobbers
= c_parser_asm_clobbers (parser
);
4183 c_lex_string_translate
= 1;
4184 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
4186 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
4189 if (!c_parser_require (parser
, CPP_SEMICOLON
, "expected %<;%>"))
4190 c_parser_skip_to_end_of_block_or_statement (parser
);
4191 ret
= build_asm_stmt (quals
, build_asm_expr (str
, outputs
, inputs
,
4196 /* Parse asm operands, a GNU extension. If CONVERT_P (for inputs but
4197 not outputs), apply the default conversion of functions and arrays
4202 asm-operands , asm-operand
4205 asm-string-literal ( expression )
4206 [ identifier ] asm-string-literal ( expression )
4210 c_parser_asm_operands (c_parser
*parser
, bool convert_p
)
4212 tree list
= NULL_TREE
;
4217 if (c_parser_next_token_is (parser
, CPP_OPEN_SQUARE
))
4219 c_parser_consume_token (parser
);
4220 if (c_parser_next_token_is (parser
, CPP_NAME
))
4222 tree id
= c_parser_peek_token (parser
)->value
;
4223 c_parser_consume_token (parser
);
4224 name
= build_string (IDENTIFIER_LENGTH (id
),
4225 IDENTIFIER_POINTER (id
));
4229 c_parser_error (parser
, "expected identifier");
4230 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
, NULL
);
4233 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
4238 str
= c_parser_asm_string_literal (parser
);
4239 if (str
== NULL_TREE
)
4241 c_lex_string_translate
= 1;
4242 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
4244 c_lex_string_translate
= 0;
4247 expr
= c_parser_expression (parser
);
4249 expr
= default_function_array_conversion (expr
);
4250 c_lex_string_translate
= 0;
4251 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
4253 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
4256 list
= chainon (list
, build_tree_list (build_tree_list (name
, str
),
4258 if (c_parser_next_token_is (parser
, CPP_COMMA
))
4259 c_parser_consume_token (parser
);
4266 /* Parse asm clobbers, a GNU extension.
4270 asm-clobbers , asm-string-literal
4274 c_parser_asm_clobbers (c_parser
*parser
)
4276 tree list
= NULL_TREE
;
4279 tree str
= c_parser_asm_string_literal (parser
);
4281 list
= tree_cons (NULL_TREE
, str
, list
);
4284 if (c_parser_next_token_is (parser
, CPP_COMMA
))
4285 c_parser_consume_token (parser
);
4292 /* Parse an expression other than a compound expression; that is, an
4293 assignment expression (C90 6.3.16, C99 6.5.16). If AFTER is not
4294 NULL then it is an Objective-C message expression which is the
4295 primary-expression starting the expression as an initializer.
4297 assignment-expression:
4298 conditional-expression
4299 unary-expression assignment-operator assignment-expression
4301 assignment-operator: one of
4302 = *= /= %= += -= <<= >>= &= ^= |=
4304 In GNU C we accept any conditional expression on the LHS and
4305 diagnose the invalid lvalue rather than producing a syntax
4308 static struct c_expr
4309 c_parser_expr_no_commas (c_parser
*parser
, struct c_expr
*after
)
4311 struct c_expr lhs
, rhs
, ret
;
4312 enum tree_code code
;
4313 gcc_assert (!after
|| c_dialect_objc ());
4314 lhs
= c_parser_conditional_expression (parser
, after
);
4315 switch (c_parser_peek_token (parser
)->type
)
4324 code
= TRUNC_DIV_EXPR
;
4327 code
= TRUNC_MOD_EXPR
;
4342 code
= BIT_AND_EXPR
;
4345 code
= BIT_XOR_EXPR
;
4348 code
= BIT_IOR_EXPR
;
4353 c_parser_consume_token (parser
);
4354 rhs
= c_parser_expr_no_commas (parser
, NULL
);
4355 rhs
= default_function_array_conversion (rhs
);
4356 ret
.value
= build_modify_expr (lhs
.value
, code
, rhs
.value
);
4357 if (code
== NOP_EXPR
)
4358 ret
.original_code
= MODIFY_EXPR
;
4361 TREE_NO_WARNING (ret
.value
) = 1;
4362 ret
.original_code
= ERROR_MARK
;
4367 /* Parse a conditional expression (C90 6.3.15, C99 6.5.15). If AFTER
4368 is not NULL then it is an Objective-C message expression which is
4369 the primary-expression starting the expression as an initializer.
4371 conditional-expression:
4372 logical-OR-expression
4373 logical-OR-expression ? expression : conditional-expression
4377 conditional-expression:
4378 logical-OR-expression ? : conditional-expression
4381 static struct c_expr
4382 c_parser_conditional_expression (c_parser
*parser
, struct c_expr
*after
)
4384 struct c_expr cond
, exp1
, exp2
, ret
;
4385 gcc_assert (!after
|| c_dialect_objc ());
4386 cond
= c_parser_binary_expression (parser
, after
);
4387 if (c_parser_next_token_is_not (parser
, CPP_QUERY
))
4389 cond
= default_function_array_conversion (cond
);
4390 c_parser_consume_token (parser
);
4391 if (c_parser_next_token_is (parser
, CPP_COLON
))
4394 pedwarn ("ISO C forbids omitting the middle term of a ?: expression");
4395 /* Make sure first operand is calculated only once. */
4396 exp1
.value
= save_expr (default_conversion (cond
.value
));
4397 cond
.value
= c_objc_common_truthvalue_conversion (exp1
.value
);
4398 skip_evaluation
+= cond
.value
== truthvalue_true_node
;
4403 = c_objc_common_truthvalue_conversion
4404 (default_conversion (cond
.value
));
4405 skip_evaluation
+= cond
.value
== truthvalue_false_node
;
4406 exp1
= c_parser_expression_conv (parser
);
4407 skip_evaluation
+= ((cond
.value
== truthvalue_true_node
)
4408 - (cond
.value
== truthvalue_false_node
));
4410 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
4412 skip_evaluation
-= cond
.value
== truthvalue_true_node
;
4413 ret
.value
= error_mark_node
;
4414 ret
.original_code
= ERROR_MARK
;
4417 exp2
= c_parser_conditional_expression (parser
, NULL
);
4418 exp2
= default_function_array_conversion (exp2
);
4419 skip_evaluation
-= cond
.value
== truthvalue_true_node
;
4420 ret
.value
= build_conditional_expr (cond
.value
, exp1
.value
, exp2
.value
);
4421 ret
.original_code
= ERROR_MARK
;
4425 /* Parse a binary expression; that is, a logical-OR-expression (C90
4426 6.3.5-6.3.14, C99 6.5.5-6.5.14). If AFTER is not NULL then it is
4427 an Objective-C message expression which is the primary-expression
4428 starting the expression as an initializer.
4430 multiplicative-expression:
4432 multiplicative-expression * cast-expression
4433 multiplicative-expression / cast-expression
4434 multiplicative-expression % cast-expression
4436 additive-expression:
4437 multiplicative-expression
4438 additive-expression + multiplicative-expression
4439 additive-expression - multiplicative-expression
4443 shift-expression << additive-expression
4444 shift-expression >> additive-expression
4446 relational-expression:
4448 relational-expression < shift-expression
4449 relational-expression > shift-expression
4450 relational-expression <= shift-expression
4451 relational-expression >= shift-expression
4453 equality-expression:
4454 relational-expression
4455 equality-expression == relational-expression
4456 equality-expression != relational-expression
4460 AND-expression & equality-expression
4462 exclusive-OR-expression:
4464 exclusive-OR-expression ^ AND-expression
4466 inclusive-OR-expression:
4467 exclusive-OR-expression
4468 inclusive-OR-expression | exclusive-OR-expression
4470 logical-AND-expression:
4471 inclusive-OR-expression
4472 logical-AND-expression && inclusive-OR-expression
4474 logical-OR-expression:
4475 logical-AND-expression
4476 logical-OR-expression || logical-AND-expression
4479 static struct c_expr
4480 c_parser_binary_expression (c_parser
*parser
, struct c_expr
*after
)
4482 /* A binary expression is parsed using operator-precedence parsing,
4483 with the operands being cast expressions. All the binary
4484 operators are left-associative. Thus a binary expression is of
4487 E0 op1 E1 op2 E2 ...
4489 which we represent on a stack. On the stack, the precedence
4490 levels are strictly increasing. When a new operator is
4491 encountered of higher precedence than that at the top of the
4492 stack, it is pushed; its LHS is the top expression, and its RHS
4493 is everything parsed until it is popped. When a new operator is
4494 encountered with precedence less than or equal to that at the top
4495 of the stack, triples E[i-1] op[i] E[i] are popped and replaced
4496 by the result of the operation until the operator at the top of
4497 the stack has lower precedence than the new operator or there is
4498 only one element on the stack; then the top expression is the LHS
4499 of the new operator. In the case of logical AND and OR
4500 expressions, we also need to adjust skip_evaluation as
4501 appropriate when the operators are pushed and popped. */
4503 /* The precedence levels, where 0 is a dummy lowest level used for
4504 the bottom of the stack. */
4520 /* The expression at this stack level. */
4522 /* The precedence of the operator on its left, PREC_NONE at the
4523 bottom of the stack. */
4525 /* The operation on its left. */
4531 switch (stack[sp].op) \
4533 case TRUTH_ANDIF_EXPR: \
4534 skip_evaluation -= stack[sp - 1].expr.value == truthvalue_false_node; \
4536 case TRUTH_ORIF_EXPR: \
4537 skip_evaluation -= stack[sp - 1].expr.value == truthvalue_true_node; \
4542 stack[sp - 1].expr \
4543 = default_function_array_conversion (stack[sp - 1].expr); \
4545 = default_function_array_conversion (stack[sp].expr); \
4546 stack[sp - 1].expr = parser_build_binary_op (stack[sp].op, \
4547 stack[sp - 1].expr, \
4551 gcc_assert (!after
|| c_dialect_objc ());
4552 stack
[0].expr
= c_parser_cast_expression (parser
, after
);
4553 stack
[0].prec
= PREC_NONE
;
4558 enum tree_code ocode
;
4561 switch (c_parser_peek_token (parser
)->type
)
4569 ocode
= TRUNC_DIV_EXPR
;
4573 ocode
= TRUNC_MOD_EXPR
;
4585 ocode
= LSHIFT_EXPR
;
4589 ocode
= RSHIFT_EXPR
;
4603 case CPP_GREATER_EQ
:
4616 oprec
= PREC_BITAND
;
4617 ocode
= BIT_AND_EXPR
;
4620 oprec
= PREC_BITXOR
;
4621 ocode
= BIT_XOR_EXPR
;
4625 ocode
= BIT_IOR_EXPR
;
4628 oprec
= PREC_LOGAND
;
4629 ocode
= TRUTH_ANDIF_EXPR
;
4633 ocode
= TRUTH_ORIF_EXPR
;
4636 /* Not a binary operator, so end of the binary
4640 c_parser_consume_token (parser
);
4641 while (oprec
<= stack
[sp
].prec
)
4645 case TRUTH_ANDIF_EXPR
:
4647 = default_function_array_conversion (stack
[sp
].expr
);
4648 stack
[sp
].expr
.value
= c_objc_common_truthvalue_conversion
4649 (default_conversion (stack
[sp
].expr
.value
));
4650 skip_evaluation
+= stack
[sp
].expr
.value
== truthvalue_false_node
;
4652 case TRUTH_ORIF_EXPR
:
4654 = default_function_array_conversion (stack
[sp
].expr
);
4655 stack
[sp
].expr
.value
= c_objc_common_truthvalue_conversion
4656 (default_conversion (stack
[sp
].expr
.value
));
4657 skip_evaluation
+= stack
[sp
].expr
.value
== truthvalue_true_node
;
4663 stack
[sp
].expr
= c_parser_cast_expression (parser
, NULL
);
4664 stack
[sp
].prec
= oprec
;
4665 stack
[sp
].op
= ocode
;
4670 return stack
[0].expr
;
4674 /* Parse a cast expression (C90 6.3.4, C99 6.5.4). If AFTER is not
4675 NULL then it is an Objective-C message expression which is the
4676 primary-expression starting the expression as an initializer.
4680 ( type-name ) unary-expression
4683 static struct c_expr
4684 c_parser_cast_expression (c_parser
*parser
, struct c_expr
*after
)
4686 gcc_assert (!after
|| c_dialect_objc ());
4688 return c_parser_postfix_expression_after_primary (parser
, *after
);
4689 /* If the expression begins with a parenthesized type name, it may
4690 be either a cast or a compound literal; we need to see whether
4691 the next character is '{' to tell the difference. If not, it is
4692 an unary expression. */
4693 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
)
4694 && c_token_starts_typename (c_parser_peek_2nd_token (parser
)))
4696 struct c_type_name
*type_name
;
4699 c_parser_consume_token (parser
);
4700 type_name
= c_parser_type_name (parser
);
4701 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
4702 if (type_name
== NULL
)
4704 ret
.value
= error_mark_node
;
4705 ret
.original_code
= ERROR_MARK
;
4709 /* Save casted types in the function's used types hash table. */
4710 used_types_insert (type_name
->specs
->type
);
4712 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
4713 return c_parser_postfix_expression_after_paren_type (parser
,
4715 expr
= c_parser_cast_expression (parser
, NULL
);
4716 expr
= default_function_array_conversion (expr
);
4717 ret
.value
= c_cast_expr (type_name
, expr
.value
);
4718 ret
.original_code
= ERROR_MARK
;
4722 return c_parser_unary_expression (parser
);
4725 /* Parse an unary expression (C90 6.3.3, C99 6.5.3).
4731 unary-operator cast-expression
4732 sizeof unary-expression
4733 sizeof ( type-name )
4735 unary-operator: one of
4741 __alignof__ unary-expression
4742 __alignof__ ( type-name )
4745 unary-operator: one of
4746 __extension__ __real__ __imag__
4748 In addition, the GNU syntax treats ++ and -- as unary operators, so
4749 they may be applied to cast expressions with errors for non-lvalues
4752 static struct c_expr
4753 c_parser_unary_expression (c_parser
*parser
)
4756 struct c_expr ret
, op
;
4757 switch (c_parser_peek_token (parser
)->type
)
4760 c_parser_consume_token (parser
);
4761 op
= c_parser_cast_expression (parser
, NULL
);
4762 op
= default_function_array_conversion (op
);
4763 return parser_build_unary_op (PREINCREMENT_EXPR
, op
);
4764 case CPP_MINUS_MINUS
:
4765 c_parser_consume_token (parser
);
4766 op
= c_parser_cast_expression (parser
, NULL
);
4767 op
= default_function_array_conversion (op
);
4768 return parser_build_unary_op (PREDECREMENT_EXPR
, op
);
4770 c_parser_consume_token (parser
);
4771 return parser_build_unary_op (ADDR_EXPR
,
4772 c_parser_cast_expression (parser
, NULL
));
4774 c_parser_consume_token (parser
);
4775 op
= c_parser_cast_expression (parser
, NULL
);
4776 op
= default_function_array_conversion (op
);
4777 ret
.value
= build_indirect_ref (op
.value
, "unary *");
4778 ret
.original_code
= ERROR_MARK
;
4781 c_parser_consume_token (parser
);
4782 if (!c_dialect_objc () && !in_system_header
)
4783 warning (OPT_Wtraditional
,
4784 "traditional C rejects the unary plus operator");
4785 op
= c_parser_cast_expression (parser
, NULL
);
4786 op
= default_function_array_conversion (op
);
4787 return parser_build_unary_op (CONVERT_EXPR
, op
);
4789 c_parser_consume_token (parser
);
4790 op
= c_parser_cast_expression (parser
, NULL
);
4791 op
= default_function_array_conversion (op
);
4792 return parser_build_unary_op (NEGATE_EXPR
, op
);
4794 c_parser_consume_token (parser
);
4795 op
= c_parser_cast_expression (parser
, NULL
);
4796 op
= default_function_array_conversion (op
);
4797 return parser_build_unary_op (BIT_NOT_EXPR
, op
);
4799 c_parser_consume_token (parser
);
4800 op
= c_parser_cast_expression (parser
, NULL
);
4801 op
= default_function_array_conversion (op
);
4802 return parser_build_unary_op (TRUTH_NOT_EXPR
, op
);
4804 /* Refer to the address of a label as a pointer. */
4805 c_parser_consume_token (parser
);
4806 if (c_parser_next_token_is (parser
, CPP_NAME
))
4808 ret
.value
= finish_label_address_expr
4809 (c_parser_peek_token (parser
)->value
);
4810 c_parser_consume_token (parser
);
4814 c_parser_error (parser
, "expected identifier");
4815 ret
.value
= error_mark_node
;
4817 ret
.original_code
= ERROR_MARK
;
4820 switch (c_parser_peek_token (parser
)->keyword
)
4823 return c_parser_sizeof_expression (parser
);
4825 return c_parser_alignof_expression (parser
);
4827 c_parser_consume_token (parser
);
4828 ext
= disable_extension_diagnostics ();
4829 ret
= c_parser_cast_expression (parser
, NULL
);
4830 restore_extension_diagnostics (ext
);
4833 c_parser_consume_token (parser
);
4834 op
= c_parser_cast_expression (parser
, NULL
);
4835 op
= default_function_array_conversion (op
);
4836 return parser_build_unary_op (REALPART_EXPR
, op
);
4838 c_parser_consume_token (parser
);
4839 op
= c_parser_cast_expression (parser
, NULL
);
4840 op
= default_function_array_conversion (op
);
4841 return parser_build_unary_op (IMAGPART_EXPR
, op
);
4843 return c_parser_postfix_expression (parser
);
4846 return c_parser_postfix_expression (parser
);
4850 /* Parse a sizeof expression. */
4852 static struct c_expr
4853 c_parser_sizeof_expression (c_parser
*parser
)
4856 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_SIZEOF
));
4857 c_parser_consume_token (parser
);
4860 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
)
4861 && c_token_starts_typename (c_parser_peek_2nd_token (parser
)))
4863 /* Either sizeof ( type-name ) or sizeof unary-expression
4864 starting with a compound literal. */
4865 struct c_type_name
*type_name
;
4866 c_parser_consume_token (parser
);
4867 type_name
= c_parser_type_name (parser
);
4868 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
4869 if (type_name
== NULL
)
4874 ret
.value
= error_mark_node
;
4875 ret
.original_code
= ERROR_MARK
;
4878 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
4880 expr
= c_parser_postfix_expression_after_paren_type (parser
,
4884 /* sizeof ( type-name ). */
4887 if (type_name
->declarator
->kind
== cdk_array
4888 && type_name
->declarator
->u
.array
.vla_unspec_p
)
4891 error ("%<[*]%> not allowed in other than a declaration");
4893 return c_expr_sizeof_type (type_name
);
4897 expr
= c_parser_unary_expression (parser
);
4901 if (TREE_CODE (expr
.value
) == COMPONENT_REF
4902 && DECL_C_BIT_FIELD (TREE_OPERAND (expr
.value
, 1)))
4903 error ("%<sizeof%> applied to a bit-field");
4904 return c_expr_sizeof_expr (expr
);
4908 /* Parse an alignof expression. */
4910 static struct c_expr
4911 c_parser_alignof_expression (c_parser
*parser
)
4914 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_ALIGNOF
));
4915 c_parser_consume_token (parser
);
4918 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
)
4919 && c_token_starts_typename (c_parser_peek_2nd_token (parser
)))
4921 /* Either __alignof__ ( type-name ) or __alignof__
4922 unary-expression starting with a compound literal. */
4923 struct c_type_name
*type_name
;
4925 c_parser_consume_token (parser
);
4926 type_name
= c_parser_type_name (parser
);
4927 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
4928 if (type_name
== NULL
)
4933 ret
.value
= error_mark_node
;
4934 ret
.original_code
= ERROR_MARK
;
4937 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
4939 expr
= c_parser_postfix_expression_after_paren_type (parser
,
4943 /* alignof ( type-name ). */
4946 ret
.value
= c_alignof (groktypename (type_name
));
4947 ret
.original_code
= ERROR_MARK
;
4953 expr
= c_parser_unary_expression (parser
);
4957 ret
.value
= c_alignof_expr (expr
.value
);
4958 ret
.original_code
= ERROR_MARK
;
4963 /* Parse a postfix expression (C90 6.3.1-6.3.2, C99 6.5.1-6.5.2).
4967 postfix-expression [ expression ]
4968 postfix-expression ( argument-expression-list[opt] )
4969 postfix-expression . identifier
4970 postfix-expression -> identifier
4971 postfix-expression ++
4972 postfix-expression --
4973 ( type-name ) { initializer-list }
4974 ( type-name ) { initializer-list , }
4976 argument-expression-list:
4978 argument-expression-list , argument-expression
4990 (treated as a keyword in GNU C)
4993 ( compound-statement )
4994 __builtin_va_arg ( assignment-expression , type-name )
4995 __builtin_offsetof ( type-name , offsetof-member-designator )
4996 __builtin_choose_expr ( assignment-expression ,
4997 assignment-expression ,
4998 assignment-expression )
4999 __builtin_types_compatible_p ( type-name , type-name )
5001 offsetof-member-designator:
5003 offsetof-member-designator . identifier
5004 offsetof-member-designator [ expression ]
5009 [ objc-receiver objc-message-args ]
5010 @selector ( objc-selector-arg )
5011 @protocol ( identifier )
5012 @encode ( type-name )
5016 static struct c_expr
5017 c_parser_postfix_expression (c_parser
*parser
)
5019 struct c_expr expr
, e1
, e2
, e3
;
5020 struct c_type_name
*t1
, *t2
;
5021 switch (c_parser_peek_token (parser
)->type
)
5026 expr
.value
= c_parser_peek_token (parser
)->value
;
5027 expr
.original_code
= ERROR_MARK
;
5028 c_parser_consume_token (parser
);
5032 expr
.value
= c_parser_peek_token (parser
)->value
;
5033 expr
.original_code
= STRING_CST
;
5034 c_parser_consume_token (parser
);
5036 case CPP_OBJC_STRING
:
5037 gcc_assert (c_dialect_objc ());
5039 = objc_build_string_object (c_parser_peek_token (parser
)->value
);
5040 expr
.original_code
= ERROR_MARK
;
5041 c_parser_consume_token (parser
);
5044 if (c_parser_peek_token (parser
)->id_kind
!= C_ID_ID
)
5046 c_parser_error (parser
, "expected expression");
5047 expr
.value
= error_mark_node
;
5048 expr
.original_code
= ERROR_MARK
;
5052 tree id
= c_parser_peek_token (parser
)->value
;
5053 location_t loc
= c_parser_peek_token (parser
)->location
;
5054 c_parser_consume_token (parser
);
5055 expr
.value
= build_external_ref (id
,
5056 (c_parser_peek_token (parser
)->type
5057 == CPP_OPEN_PAREN
), loc
);
5058 expr
.original_code
= ERROR_MARK
;
5061 case CPP_OPEN_PAREN
:
5062 /* A parenthesized expression, statement expression or compound
5064 if (c_parser_peek_2nd_token (parser
)->type
== CPP_OPEN_BRACE
)
5066 /* A statement expression. */
5068 c_parser_consume_token (parser
);
5069 c_parser_consume_token (parser
);
5070 if (cur_stmt_list
== NULL
)
5072 error ("braced-group within expression allowed "
5073 "only inside a function");
5074 parser
->error
= true;
5075 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
, NULL
);
5076 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5077 expr
.value
= error_mark_node
;
5078 expr
.original_code
= ERROR_MARK
;
5081 stmt
= c_begin_stmt_expr ();
5082 c_parser_compound_statement_nostart (parser
);
5083 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5086 pedwarn ("ISO C forbids braced-groups within expressions");
5087 expr
.value
= c_finish_stmt_expr (stmt
);
5088 expr
.original_code
= ERROR_MARK
;
5090 else if (c_token_starts_typename (c_parser_peek_2nd_token (parser
)))
5092 /* A compound literal. ??? Can we actually get here rather
5093 than going directly to
5094 c_parser_postfix_expression_after_paren_type from
5096 struct c_type_name
*type_name
;
5097 c_parser_consume_token (parser
);
5098 type_name
= c_parser_type_name (parser
);
5099 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5101 if (type_name
== NULL
)
5103 expr
.value
= error_mark_node
;
5104 expr
.original_code
= ERROR_MARK
;
5107 expr
= c_parser_postfix_expression_after_paren_type (parser
,
5112 /* A parenthesized expression. */
5113 c_parser_consume_token (parser
);
5114 expr
= c_parser_expression (parser
);
5115 if (TREE_CODE (expr
.value
) == MODIFY_EXPR
)
5116 TREE_NO_WARNING (expr
.value
) = 1;
5117 expr
.original_code
= ERROR_MARK
;
5118 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5123 switch (c_parser_peek_token (parser
)->keyword
)
5125 case RID_FUNCTION_NAME
:
5126 case RID_PRETTY_FUNCTION_NAME
:
5127 case RID_C99_FUNCTION_NAME
:
5128 expr
.value
= fname_decl (c_parser_peek_token (parser
)->keyword
,
5129 c_parser_peek_token (parser
)->value
);
5130 expr
.original_code
= ERROR_MARK
;
5131 c_parser_consume_token (parser
);
5134 c_parser_consume_token (parser
);
5135 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
5137 expr
.value
= error_mark_node
;
5138 expr
.original_code
= ERROR_MARK
;
5141 e1
= c_parser_expr_no_commas (parser
, NULL
);
5142 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
5144 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5145 expr
.value
= error_mark_node
;
5146 expr
.original_code
= ERROR_MARK
;
5149 t1
= c_parser_type_name (parser
);
5150 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5154 expr
.value
= error_mark_node
;
5155 expr
.original_code
= ERROR_MARK
;
5159 expr
.value
= build_va_arg (e1
.value
, groktypename (t1
));
5160 expr
.original_code
= ERROR_MARK
;
5164 c_parser_consume_token (parser
);
5165 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
5167 expr
.value
= error_mark_node
;
5168 expr
.original_code
= ERROR_MARK
;
5171 t1
= c_parser_type_name (parser
);
5174 expr
.value
= error_mark_node
;
5175 expr
.original_code
= ERROR_MARK
;
5178 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
5180 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5181 expr
.value
= error_mark_node
;
5182 expr
.original_code
= ERROR_MARK
;
5186 tree type
= groktypename (t1
);
5188 if (type
== error_mark_node
)
5189 offsetof_ref
= error_mark_node
;
5191 offsetof_ref
= build1 (INDIRECT_REF
, type
, null_pointer_node
);
5192 /* Parse the second argument to __builtin_offsetof. We
5193 must have one identifier, and beyond that we want to
5194 accept sub structure and sub array references. */
5195 if (c_parser_next_token_is (parser
, CPP_NAME
))
5197 offsetof_ref
= build_component_ref
5198 (offsetof_ref
, c_parser_peek_token (parser
)->value
);
5199 c_parser_consume_token (parser
);
5200 while (c_parser_next_token_is (parser
, CPP_DOT
)
5201 || c_parser_next_token_is (parser
,
5204 if (c_parser_next_token_is (parser
, CPP_DOT
))
5206 c_parser_consume_token (parser
);
5207 if (c_parser_next_token_is_not (parser
,
5210 c_parser_error (parser
, "expected identifier");
5213 offsetof_ref
= build_component_ref
5215 c_parser_peek_token (parser
)->value
);
5216 c_parser_consume_token (parser
);
5221 c_parser_consume_token (parser
);
5222 idx
= c_parser_expression (parser
).value
;
5223 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
5225 offsetof_ref
= build_array_ref (offsetof_ref
, idx
);
5230 c_parser_error (parser
, "expected identifier");
5231 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5233 expr
.value
= fold_offsetof (offsetof_ref
, NULL_TREE
);
5234 expr
.original_code
= ERROR_MARK
;
5237 case RID_CHOOSE_EXPR
:
5238 c_parser_consume_token (parser
);
5239 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
5241 expr
.value
= error_mark_node
;
5242 expr
.original_code
= ERROR_MARK
;
5245 e1
= c_parser_expr_no_commas (parser
, NULL
);
5246 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
5248 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5249 expr
.value
= error_mark_node
;
5250 expr
.original_code
= ERROR_MARK
;
5253 e2
= c_parser_expr_no_commas (parser
, NULL
);
5254 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
5256 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5257 expr
.value
= error_mark_node
;
5258 expr
.original_code
= ERROR_MARK
;
5261 e3
= c_parser_expr_no_commas (parser
, NULL
);
5262 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5267 c
= fold (e1
.value
);
5268 if (TREE_CODE (c
) != INTEGER_CST
)
5269 error ("first argument to %<__builtin_choose_expr%> not"
5271 expr
= integer_zerop (c
) ? e3
: e2
;
5274 case RID_TYPES_COMPATIBLE_P
:
5275 c_parser_consume_token (parser
);
5276 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
5278 expr
.value
= error_mark_node
;
5279 expr
.original_code
= ERROR_MARK
;
5282 t1
= c_parser_type_name (parser
);
5285 expr
.value
= error_mark_node
;
5286 expr
.original_code
= ERROR_MARK
;
5289 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
5291 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5292 expr
.value
= error_mark_node
;
5293 expr
.original_code
= ERROR_MARK
;
5296 t2
= c_parser_type_name (parser
);
5299 expr
.value
= error_mark_node
;
5300 expr
.original_code
= ERROR_MARK
;
5303 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5308 e1
= TYPE_MAIN_VARIANT (groktypename (t1
));
5309 e2
= TYPE_MAIN_VARIANT (groktypename (t2
));
5311 expr
.value
= comptypes (e1
, e2
)
5312 ? build_int_cst (NULL_TREE
, 1)
5313 : build_int_cst (NULL_TREE
, 0);
5314 expr
.original_code
= ERROR_MARK
;
5317 case RID_AT_SELECTOR
:
5318 gcc_assert (c_dialect_objc ());
5319 c_parser_consume_token (parser
);
5320 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
5322 expr
.value
= error_mark_node
;
5323 expr
.original_code
= ERROR_MARK
;
5327 tree sel
= c_parser_objc_selector_arg (parser
);
5328 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5330 expr
.value
= objc_build_selector_expr (sel
);
5331 expr
.original_code
= ERROR_MARK
;
5334 case RID_AT_PROTOCOL
:
5335 gcc_assert (c_dialect_objc ());
5336 c_parser_consume_token (parser
);
5337 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
5339 expr
.value
= error_mark_node
;
5340 expr
.original_code
= ERROR_MARK
;
5343 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5345 c_parser_error (parser
, "expected identifier");
5346 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5347 expr
.value
= error_mark_node
;
5348 expr
.original_code
= ERROR_MARK
;
5352 tree id
= c_parser_peek_token (parser
)->value
;
5353 c_parser_consume_token (parser
);
5354 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5356 expr
.value
= objc_build_protocol_expr (id
);
5357 expr
.original_code
= ERROR_MARK
;
5361 /* Extension to support C-structures in the archiver. */
5362 gcc_assert (c_dialect_objc ());
5363 c_parser_consume_token (parser
);
5364 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
5366 expr
.value
= error_mark_node
;
5367 expr
.original_code
= ERROR_MARK
;
5370 t1
= c_parser_type_name (parser
);
5373 expr
.value
= error_mark_node
;
5374 expr
.original_code
= ERROR_MARK
;
5375 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5378 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5381 tree type
= groktypename (t1
);
5382 expr
.value
= objc_build_encode_expr (type
);
5383 expr
.original_code
= ERROR_MARK
;
5387 c_parser_error (parser
, "expected expression");
5388 expr
.value
= error_mark_node
;
5389 expr
.original_code
= ERROR_MARK
;
5393 case CPP_OPEN_SQUARE
:
5394 if (c_dialect_objc ())
5396 tree receiver
, args
;
5397 c_parser_consume_token (parser
);
5398 receiver
= c_parser_objc_receiver (parser
);
5399 args
= c_parser_objc_message_args (parser
);
5400 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
5402 expr
.value
= objc_build_message_expr (build_tree_list (receiver
,
5404 expr
.original_code
= ERROR_MARK
;
5407 /* Else fall through to report error. */
5409 c_parser_error (parser
, "expected expression");
5410 expr
.value
= error_mark_node
;
5411 expr
.original_code
= ERROR_MARK
;
5414 return c_parser_postfix_expression_after_primary (parser
, expr
);
5417 /* Parse a postfix expression after a parenthesized type name: the
5418 brace-enclosed initializer of a compound literal, possibly followed
5419 by some postfix operators. This is separate because it is not
5420 possible to tell until after the type name whether a cast
5421 expression has a cast or a compound literal, or whether the operand
5422 of sizeof is a parenthesized type name or starts with a compound
5425 static struct c_expr
5426 c_parser_postfix_expression_after_paren_type (c_parser
*parser
,
5427 struct c_type_name
*type_name
)
5432 start_init (NULL_TREE
, NULL
, 0);
5433 type
= groktypename (type_name
);
5434 if (type
!= error_mark_node
&& C_TYPE_VARIABLE_SIZE (type
))
5436 error ("compound literal has variable size");
5437 type
= error_mark_node
;
5439 init
= c_parser_braced_init (parser
, type
, false);
5441 maybe_warn_string_init (type
, init
);
5443 if (pedantic
&& !flag_isoc99
)
5444 pedwarn ("ISO C90 forbids compound literals");
5445 expr
.value
= build_compound_literal (type
, init
.value
);
5446 expr
.original_code
= ERROR_MARK
;
5447 return c_parser_postfix_expression_after_primary (parser
, expr
);
5450 /* Parse a postfix expression after the initial primary or compound
5451 literal; that is, parse a series of postfix operators. */
5453 static struct c_expr
5454 c_parser_postfix_expression_after_primary (c_parser
*parser
,
5457 tree ident
, idx
, exprlist
;
5460 switch (c_parser_peek_token (parser
)->type
)
5462 case CPP_OPEN_SQUARE
:
5463 /* Array reference. */
5464 c_parser_consume_token (parser
);
5465 idx
= c_parser_expression (parser
).value
;
5466 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
5468 expr
.value
= build_array_ref (expr
.value
, idx
);
5469 expr
.original_code
= ERROR_MARK
;
5471 case CPP_OPEN_PAREN
:
5472 /* Function call. */
5473 c_parser_consume_token (parser
);
5474 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
5475 exprlist
= NULL_TREE
;
5477 exprlist
= c_parser_expr_list (parser
, true);
5478 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5480 expr
.value
= build_function_call (expr
.value
, exprlist
);
5481 expr
.original_code
= ERROR_MARK
;
5484 /* Structure element reference. */
5485 c_parser_consume_token (parser
);
5486 expr
= default_function_array_conversion (expr
);
5487 if (c_parser_next_token_is (parser
, CPP_NAME
))
5488 ident
= c_parser_peek_token (parser
)->value
;
5491 c_parser_error (parser
, "expected identifier");
5492 expr
.value
= error_mark_node
;
5493 expr
.original_code
= ERROR_MARK
;
5496 c_parser_consume_token (parser
);
5497 expr
.value
= build_component_ref (expr
.value
, ident
);
5498 expr
.original_code
= ERROR_MARK
;
5501 /* Structure element reference. */
5502 c_parser_consume_token (parser
);
5503 expr
= default_function_array_conversion (expr
);
5504 if (c_parser_next_token_is (parser
, CPP_NAME
))
5505 ident
= c_parser_peek_token (parser
)->value
;
5508 c_parser_error (parser
, "expected identifier");
5509 expr
.value
= error_mark_node
;
5510 expr
.original_code
= ERROR_MARK
;
5513 c_parser_consume_token (parser
);
5514 expr
.value
= build_component_ref (build_indirect_ref (expr
.value
,
5516 expr
.original_code
= ERROR_MARK
;
5519 /* Postincrement. */
5520 c_parser_consume_token (parser
);
5521 expr
= default_function_array_conversion (expr
);
5522 expr
.value
= build_unary_op (POSTINCREMENT_EXPR
, expr
.value
, 0);
5523 expr
.original_code
= ERROR_MARK
;
5525 case CPP_MINUS_MINUS
:
5526 /* Postdecrement. */
5527 c_parser_consume_token (parser
);
5528 expr
= default_function_array_conversion (expr
);
5529 expr
.value
= build_unary_op (POSTDECREMENT_EXPR
, expr
.value
, 0);
5530 expr
.original_code
= ERROR_MARK
;
5538 /* Parse an expression (C90 6.3.17, C99 6.5.17).
5541 assignment-expression
5542 expression , assignment-expression
5545 static struct c_expr
5546 c_parser_expression (c_parser
*parser
)
5549 expr
= c_parser_expr_no_commas (parser
, NULL
);
5550 while (c_parser_next_token_is (parser
, CPP_COMMA
))
5553 c_parser_consume_token (parser
);
5554 next
= c_parser_expr_no_commas (parser
, NULL
);
5555 next
= default_function_array_conversion (next
);
5556 expr
.value
= build_compound_expr (expr
.value
, next
.value
);
5557 expr
.original_code
= COMPOUND_EXPR
;
5562 /* Parse an expression and convert functions or arrays to
5565 static struct c_expr
5566 c_parser_expression_conv (c_parser
*parser
)
5569 expr
= c_parser_expression (parser
);
5570 expr
= default_function_array_conversion (expr
);
5574 /* Parse a non-empty list of expressions. If CONVERT_P, convert
5575 functions and arrays to pointers.
5578 assignment-expression
5579 nonempty-expr-list , assignment-expression
5583 c_parser_expr_list (c_parser
*parser
, bool convert_p
)
5587 expr
= c_parser_expr_no_commas (parser
, NULL
);
5589 expr
= default_function_array_conversion (expr
);
5590 ret
= cur
= build_tree_list (NULL_TREE
, expr
.value
);
5591 while (c_parser_next_token_is (parser
, CPP_COMMA
))
5593 c_parser_consume_token (parser
);
5594 expr
= c_parser_expr_no_commas (parser
, NULL
);
5596 expr
= default_function_array_conversion (expr
);
5597 cur
= TREE_CHAIN (cur
) = build_tree_list (NULL_TREE
, expr
.value
);
5603 /* Parse Objective-C-specific constructs. */
5605 /* Parse an objc-class-definition.
5607 objc-class-definition:
5608 @interface identifier objc-superclass[opt] objc-protocol-refs[opt]
5609 objc-class-instance-variables[opt] objc-methodprotolist @end
5610 @implementation identifier objc-superclass[opt]
5611 objc-class-instance-variables[opt]
5612 @interface identifier ( identifier ) objc-protocol-refs[opt]
5613 objc-methodprotolist @end
5614 @implementation identifier ( identifier )
5619 "@interface identifier (" must start "@interface identifier (
5620 identifier ) ...": objc-methodprotolist in the first production may
5621 not start with a parenthesized identifier as a declarator of a data
5622 definition with no declaration specifiers if the objc-superclass,
5623 objc-protocol-refs and objc-class-instance-variables are omitted. */
5626 c_parser_objc_class_definition (c_parser
*parser
)
5631 if (c_parser_next_token_is_keyword (parser
, RID_AT_INTERFACE
))
5633 else if (c_parser_next_token_is_keyword (parser
, RID_AT_IMPLEMENTATION
))
5637 c_parser_consume_token (parser
);
5638 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5640 c_parser_error (parser
, "expected identifier");
5643 id1
= c_parser_peek_token (parser
)->value
;
5644 c_parser_consume_token (parser
);
5645 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
5648 tree proto
= NULL_TREE
;
5649 c_parser_consume_token (parser
);
5650 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5652 c_parser_error (parser
, "expected identifier");
5653 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5656 id2
= c_parser_peek_token (parser
)->value
;
5657 c_parser_consume_token (parser
);
5658 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
5661 objc_start_category_implementation (id1
, id2
);
5664 if (c_parser_next_token_is (parser
, CPP_LESS
))
5665 proto
= c_parser_objc_protocol_refs (parser
);
5666 objc_start_category_interface (id1
, id2
, proto
);
5667 c_parser_objc_methodprotolist (parser
);
5668 c_parser_require_keyword (parser
, RID_AT_END
, "expected %<@end%>");
5669 objc_finish_interface ();
5672 if (c_parser_next_token_is (parser
, CPP_COLON
))
5674 c_parser_consume_token (parser
);
5675 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5677 c_parser_error (parser
, "expected identifier");
5680 superclass
= c_parser_peek_token (parser
)->value
;
5681 c_parser_consume_token (parser
);
5684 superclass
= NULL_TREE
;
5687 tree proto
= NULL_TREE
;
5688 if (c_parser_next_token_is (parser
, CPP_LESS
))
5689 proto
= c_parser_objc_protocol_refs (parser
);
5690 objc_start_class_interface (id1
, superclass
, proto
);
5693 objc_start_class_implementation (id1
, superclass
);
5694 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
5695 c_parser_objc_class_instance_variables (parser
);
5698 objc_continue_interface ();
5699 c_parser_objc_methodprotolist (parser
);
5700 c_parser_require_keyword (parser
, RID_AT_END
, "expected %<@end%>");
5701 objc_finish_interface ();
5705 objc_continue_implementation ();
5710 /* Parse objc-class-instance-variables.
5712 objc-class-instance-variables:
5713 { objc-instance-variable-decl-list[opt] }
5715 objc-instance-variable-decl-list:
5716 objc-visibility-spec
5717 objc-instance-variable-decl ;
5719 objc-instance-variable-decl-list objc-visibility-spec
5720 objc-instance-variable-decl-list objc-instance-variable-decl ;
5721 objc-instance-variable-decl-list ;
5723 objc-visibility-spec:
5728 objc-instance-variable-decl:
5733 c_parser_objc_class_instance_variables (c_parser
*parser
)
5735 gcc_assert (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
));
5736 c_parser_consume_token (parser
);
5737 while (c_parser_next_token_is_not (parser
, CPP_EOF
))
5740 /* Parse any stray semicolon. */
5741 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
5744 pedwarn ("extra semicolon in struct or union specified");
5745 c_parser_consume_token (parser
);
5748 /* Stop if at the end of the instance variables. */
5749 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
5751 c_parser_consume_token (parser
);
5754 /* Parse any objc-visibility-spec. */
5755 if (c_parser_next_token_is_keyword (parser
, RID_AT_PRIVATE
))
5757 c_parser_consume_token (parser
);
5758 objc_set_visibility (2);
5761 else if (c_parser_next_token_is_keyword (parser
, RID_AT_PROTECTED
))
5763 c_parser_consume_token (parser
);
5764 objc_set_visibility (0);
5767 else if (c_parser_next_token_is_keyword (parser
, RID_AT_PUBLIC
))
5769 c_parser_consume_token (parser
);
5770 objc_set_visibility (1);
5773 else if (c_parser_next_token_is (parser
, CPP_PRAGMA
))
5775 c_parser_pragma (parser
, pragma_external
);
5779 /* Parse some comma-separated declarations. */
5780 decls
= c_parser_struct_declaration (parser
);
5782 /* Comma-separated instance variables are chained together in
5783 reverse order; add them one by one. */
5784 tree ivar
= nreverse (decls
);
5785 for (; ivar
; ivar
= TREE_CHAIN (ivar
))
5786 objc_add_instance_variable (copy_node (ivar
));
5788 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
5792 /* Parse an objc-class-declaration.
5794 objc-class-declaration:
5795 @class identifier-list ;
5799 c_parser_objc_class_declaration (c_parser
*parser
)
5801 tree list
= NULL_TREE
;
5802 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_AT_CLASS
));
5803 c_parser_consume_token (parser
);
5804 /* Any identifiers, including those declared as type names, are OK
5809 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5811 c_parser_error (parser
, "expected identifier");
5814 id
= c_parser_peek_token (parser
)->value
;
5815 list
= chainon (list
, build_tree_list (NULL_TREE
, id
));
5816 c_parser_consume_token (parser
);
5817 if (c_parser_next_token_is (parser
, CPP_COMMA
))
5818 c_parser_consume_token (parser
);
5822 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
5823 objc_declare_class (list
);
5826 /* Parse an objc-alias-declaration.
5828 objc-alias-declaration:
5829 @compatibility_alias identifier identifier ;
5833 c_parser_objc_alias_declaration (c_parser
*parser
)
5836 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_AT_ALIAS
));
5837 c_parser_consume_token (parser
);
5838 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5840 c_parser_error (parser
, "expected identifier");
5841 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, NULL
);
5844 id1
= c_parser_peek_token (parser
)->value
;
5845 c_parser_consume_token (parser
);
5846 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5848 c_parser_error (parser
, "expected identifier");
5849 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, NULL
);
5852 id2
= c_parser_peek_token (parser
)->value
;
5853 c_parser_consume_token (parser
);
5854 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
5855 objc_declare_alias (id1
, id2
);
5858 /* Parse an objc-protocol-definition.
5860 objc-protocol-definition:
5861 @protocol identifier objc-protocol-refs[opt] objc-methodprotolist @end
5862 @protocol identifier-list ;
5864 "@protocol identifier ;" should be resolved as "@protocol
5865 identifier-list ;": objc-methodprotolist may not start with a
5866 semicolon in the first alternative if objc-protocol-refs are
5870 c_parser_objc_protocol_definition (c_parser
*parser
)
5872 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_AT_PROTOCOL
));
5873 c_parser_consume_token (parser
);
5874 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5876 c_parser_error (parser
, "expected identifier");
5879 if (c_parser_peek_2nd_token (parser
)->type
== CPP_COMMA
5880 || c_parser_peek_2nd_token (parser
)->type
== CPP_SEMICOLON
)
5882 tree list
= NULL_TREE
;
5883 /* Any identifiers, including those declared as type names, are
5888 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5890 c_parser_error (parser
, "expected identifier");
5893 id
= c_parser_peek_token (parser
)->value
;
5894 list
= chainon (list
, build_tree_list (NULL_TREE
, id
));
5895 c_parser_consume_token (parser
);
5896 if (c_parser_next_token_is (parser
, CPP_COMMA
))
5897 c_parser_consume_token (parser
);
5901 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
5902 objc_declare_protocols (list
);
5906 tree id
= c_parser_peek_token (parser
)->value
;
5907 tree proto
= NULL_TREE
;
5908 c_parser_consume_token (parser
);
5909 if (c_parser_next_token_is (parser
, CPP_LESS
))
5910 proto
= c_parser_objc_protocol_refs (parser
);
5911 objc_pq_context
= 1;
5912 objc_start_protocol (id
, proto
);
5913 c_parser_objc_methodprotolist (parser
);
5914 c_parser_require_keyword (parser
, RID_AT_END
, "expected %<@end%>");
5915 objc_pq_context
= 0;
5916 objc_finish_interface ();
5920 /* Parse an objc-method-type.
5927 static enum tree_code
5928 c_parser_objc_method_type (c_parser
*parser
)
5930 switch (c_parser_peek_token (parser
)->type
)
5933 c_parser_consume_token (parser
);
5936 c_parser_consume_token (parser
);
5943 /* Parse an objc-method-definition.
5945 objc-method-definition:
5946 objc-method-type objc-method-decl ;[opt] compound-statement
5950 c_parser_objc_method_definition (c_parser
*parser
)
5952 enum tree_code type
= c_parser_objc_method_type (parser
);
5954 objc_set_method_type (type
);
5955 objc_pq_context
= 1;
5956 decl
= c_parser_objc_method_decl (parser
);
5957 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
5959 c_parser_consume_token (parser
);
5961 pedwarn ("extra semicolon in method definition specified");
5963 if (!c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
5965 c_parser_error (parser
, "expected %<{%>");
5968 objc_pq_context
= 0;
5969 objc_start_method_definition (decl
);
5970 add_stmt (c_parser_compound_statement (parser
));
5971 objc_finish_method_definition (current_function_decl
);
5974 /* Parse an objc-methodprotolist.
5976 objc-methodprotolist:
5978 objc-methodprotolist objc-methodproto
5979 objc-methodprotolist declaration
5980 objc-methodprotolist ;
5982 The declaration is a data definition, which may be missing
5983 declaration specifiers under the same rules and diagnostics as
5984 other data definitions outside functions, and the stray semicolon
5985 is diagnosed the same way as a stray semicolon outside a
5989 c_parser_objc_methodprotolist (c_parser
*parser
)
5993 /* The list is terminated by @end. */
5994 switch (c_parser_peek_token (parser
)->type
)
5998 pedwarn ("ISO C does not allow extra %<;%> outside of a function");
5999 c_parser_consume_token (parser
);
6003 c_parser_objc_methodproto (parser
);
6006 c_parser_pragma (parser
, pragma_external
);
6011 if (c_parser_next_token_is_keyword (parser
, RID_AT_END
))
6013 c_parser_declaration_or_fndef (parser
, false, true, false, true);
6019 /* Parse an objc-methodproto.
6022 objc-method-type objc-method-decl ;
6026 c_parser_objc_methodproto (c_parser
*parser
)
6028 enum tree_code type
= c_parser_objc_method_type (parser
);
6030 objc_set_method_type (type
);
6031 /* Remember protocol qualifiers in prototypes. */
6032 objc_pq_context
= 1;
6033 decl
= c_parser_objc_method_decl (parser
);
6034 /* Forget protocol qualifiers here. */
6035 objc_pq_context
= 0;
6036 objc_add_method_declaration (decl
);
6037 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
6040 /* Parse an objc-method-decl.
6043 ( objc-type-name ) objc-selector
6045 ( objc-type-name ) objc-keyword-selector objc-optparmlist
6046 objc-keyword-selector objc-optparmlist
6048 objc-keyword-selector:
6050 objc-keyword-selector objc-keyword-decl
6053 objc-selector : ( objc-type-name ) identifier
6054 objc-selector : identifier
6055 : ( objc-type-name ) identifier
6059 objc-optparms objc-optellipsis
6063 objc-opt-parms , parameter-declaration
6071 c_parser_objc_method_decl (c_parser
*parser
)
6073 tree type
= NULL_TREE
;
6075 tree parms
= NULL_TREE
;
6076 bool ellipsis
= false;
6078 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
6080 c_parser_consume_token (parser
);
6081 type
= c_parser_objc_type_name (parser
);
6082 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
6084 sel
= c_parser_objc_selector (parser
);
6085 /* If there is no selector, or a colon follows, we have an
6086 objc-keyword-selector. If there is a selector, and a colon does
6087 not follow, that selector ends the objc-method-decl. */
6088 if (!sel
|| c_parser_next_token_is (parser
, CPP_COLON
))
6091 tree list
= NULL_TREE
;
6094 tree atype
= NULL_TREE
, id
, keyworddecl
;
6095 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
6097 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
6099 c_parser_consume_token (parser
);
6100 atype
= c_parser_objc_type_name (parser
);
6101 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
6104 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
6106 c_parser_error (parser
, "expected identifier");
6107 return error_mark_node
;
6109 id
= c_parser_peek_token (parser
)->value
;
6110 c_parser_consume_token (parser
);
6111 keyworddecl
= objc_build_keyword_decl (tsel
, atype
, id
);
6112 list
= chainon (list
, keyworddecl
);
6113 tsel
= c_parser_objc_selector (parser
);
6114 if (!tsel
&& c_parser_next_token_is_not (parser
, CPP_COLON
))
6117 /* Parse the optional parameter list. Optional Objective-C
6118 method parameters follow the C syntax, and may include '...'
6119 to denote a variable number of arguments. */
6120 parms
= make_node (TREE_LIST
);
6121 while (c_parser_next_token_is (parser
, CPP_COMMA
))
6123 struct c_parm
*parm
;
6124 c_parser_consume_token (parser
);
6125 if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
))
6128 c_parser_consume_token (parser
);
6131 parm
= c_parser_parameter_declaration (parser
, NULL_TREE
);
6134 parms
= chainon (parms
,
6135 build_tree_list (NULL_TREE
, grokparm (parm
)));
6139 return objc_build_method_signature (type
, sel
, parms
, ellipsis
);
6142 /* Parse an objc-type-name.
6145 objc-type-qualifiers[opt] type-name
6146 objc-type-qualifiers[opt]
6148 objc-type-qualifiers:
6150 objc-type-qualifiers objc-type-qualifier
6152 objc-type-qualifier: one of
6153 in out inout bycopy byref oneway
6157 c_parser_objc_type_name (c_parser
*parser
)
6159 tree quals
= NULL_TREE
;
6160 struct c_type_name
*typename
= NULL
;
6161 tree type
= NULL_TREE
;
6164 c_token
*token
= c_parser_peek_token (parser
);
6165 if (token
->type
== CPP_KEYWORD
6166 && (token
->keyword
== RID_IN
6167 || token
->keyword
== RID_OUT
6168 || token
->keyword
== RID_INOUT
6169 || token
->keyword
== RID_BYCOPY
6170 || token
->keyword
== RID_BYREF
6171 || token
->keyword
== RID_ONEWAY
))
6173 quals
= chainon (quals
, build_tree_list (NULL_TREE
, token
->value
));
6174 c_parser_consume_token (parser
);
6179 if (c_parser_next_token_starts_typename (parser
))
6180 typename
= c_parser_type_name (parser
);
6182 type
= groktypename (typename
);
6183 return build_tree_list (quals
, type
);
6186 /* Parse objc-protocol-refs.
6193 c_parser_objc_protocol_refs (c_parser
*parser
)
6195 tree list
= NULL_TREE
;
6196 gcc_assert (c_parser_next_token_is (parser
, CPP_LESS
));
6197 c_parser_consume_token (parser
);
6198 /* Any identifiers, including those declared as type names, are OK
6203 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
6205 c_parser_error (parser
, "expected identifier");
6208 id
= c_parser_peek_token (parser
)->value
;
6209 list
= chainon (list
, build_tree_list (NULL_TREE
, id
));
6210 c_parser_consume_token (parser
);
6211 if (c_parser_next_token_is (parser
, CPP_COMMA
))
6212 c_parser_consume_token (parser
);
6216 c_parser_require (parser
, CPP_GREATER
, "expected %<>%>");
6220 /* Parse an objc-try-catch-statement.
6222 objc-try-catch-statement:
6223 @try compound-statement objc-catch-list[opt]
6224 @try compound-statement objc-catch-list[opt] @finally compound-statement
6227 @catch ( parameter-declaration ) compound-statement
6228 objc-catch-list @catch ( parameter-declaration ) compound-statement
6232 c_parser_objc_try_catch_statement (c_parser
*parser
)
6236 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_AT_TRY
));
6237 c_parser_consume_token (parser
);
6238 loc
= c_parser_peek_token (parser
)->location
;
6239 stmt
= c_parser_compound_statement (parser
);
6240 objc_begin_try_stmt (loc
, stmt
);
6241 while (c_parser_next_token_is_keyword (parser
, RID_AT_CATCH
))
6243 struct c_parm
*parm
;
6244 c_parser_consume_token (parser
);
6245 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
6247 parm
= c_parser_parameter_declaration (parser
, NULL_TREE
);
6250 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
6253 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
6254 objc_begin_catch_clause (grokparm (parm
));
6255 if (c_parser_require (parser
, CPP_OPEN_BRACE
, "expected %<{%>"))
6256 c_parser_compound_statement_nostart (parser
);
6257 objc_finish_catch_clause ();
6259 if (c_parser_next_token_is_keyword (parser
, RID_AT_FINALLY
))
6263 c_parser_consume_token (parser
);
6264 finloc
= c_parser_peek_token (parser
)->location
;
6265 finstmt
= c_parser_compound_statement (parser
);
6266 objc_build_finally_clause (finloc
, finstmt
);
6268 objc_finish_try_stmt ();
6271 /* Parse an objc-synchronized-statement.
6273 objc-synchronized-statement:
6274 @synchronized ( expression ) compound-statement
6278 c_parser_objc_synchronized_statement (c_parser
*parser
)
6282 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_AT_SYNCHRONIZED
));
6283 c_parser_consume_token (parser
);
6284 loc
= c_parser_peek_token (parser
)->location
;
6285 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
6287 expr
= c_parser_expression (parser
).value
;
6288 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
6291 expr
= error_mark_node
;
6292 stmt
= c_parser_compound_statement (parser
);
6293 objc_build_synchronized (loc
, expr
, stmt
);
6296 /* Parse an objc-selector; return NULL_TREE without an error if the
6297 next token is not an objc-selector.
6302 enum struct union if else while do for switch case default
6303 break continue return goto asm sizeof typeof __alignof
6304 unsigned long const short volatile signed restrict _Complex
6305 in out inout bycopy byref oneway int char float double void _Bool
6307 ??? Why this selection of keywords but not, for example, storage
6308 class specifiers? */
6311 c_parser_objc_selector (c_parser
*parser
)
6313 c_token
*token
= c_parser_peek_token (parser
);
6314 tree value
= token
->value
;
6315 if (token
->type
== CPP_NAME
)
6317 c_parser_consume_token (parser
);
6320 if (token
->type
!= CPP_KEYWORD
)
6322 switch (token
->keyword
)
6363 c_parser_consume_token (parser
);
6370 /* Parse an objc-selector-arg.
6374 objc-keywordname-list
6376 objc-keywordname-list:
6378 objc-keywordname-list objc-keywordname
6386 c_parser_objc_selector_arg (c_parser
*parser
)
6388 tree sel
= c_parser_objc_selector (parser
);
6389 tree list
= NULL_TREE
;
6390 if (sel
&& c_parser_next_token_is_not (parser
, CPP_COLON
))
6394 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
6396 list
= chainon (list
, build_tree_list (sel
, NULL_TREE
));
6397 sel
= c_parser_objc_selector (parser
);
6398 if (!sel
&& c_parser_next_token_is_not (parser
, CPP_COLON
))
6404 /* Parse an objc-receiver.
6413 c_parser_objc_receiver (c_parser
*parser
)
6415 if (c_parser_peek_token (parser
)->type
== CPP_NAME
6416 && (c_parser_peek_token (parser
)->id_kind
== C_ID_TYPENAME
6417 || c_parser_peek_token (parser
)->id_kind
== C_ID_CLASSNAME
))
6419 tree id
= c_parser_peek_token (parser
)->value
;
6420 c_parser_consume_token (parser
);
6421 return objc_get_class_reference (id
);
6423 return c_parser_expression (parser
).value
;
6426 /* Parse objc-message-args.
6430 objc-keywordarg-list
6432 objc-keywordarg-list:
6434 objc-keywordarg-list objc-keywordarg
6437 objc-selector : objc-keywordexpr
6442 c_parser_objc_message_args (c_parser
*parser
)
6444 tree sel
= c_parser_objc_selector (parser
);
6445 tree list
= NULL_TREE
;
6446 if (sel
&& c_parser_next_token_is_not (parser
, CPP_COLON
))
6451 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
6453 keywordexpr
= c_parser_objc_keywordexpr (parser
);
6454 list
= chainon (list
, build_tree_list (sel
, keywordexpr
));
6455 sel
= c_parser_objc_selector (parser
);
6456 if (!sel
&& c_parser_next_token_is_not (parser
, CPP_COLON
))
6462 /* Parse an objc-keywordexpr.
6469 c_parser_objc_keywordexpr (c_parser
*parser
)
6471 tree list
= c_parser_expr_list (parser
, true);
6472 if (TREE_CHAIN (list
) == NULL_TREE
)
6474 /* Just return the expression, remove a level of
6476 return TREE_VALUE (list
);
6480 /* We have a comma expression, we will collapse later. */
6486 /* Handle pragmas. Some OpenMP pragmas are associated with, and therefore
6487 should be considered, statements. ALLOW_STMT is true if we're within
6488 the context of a function and such pragmas are to be allowed. Returns
6489 true if we actually parsed such a pragma. */
6492 c_parser_pragma (c_parser
*parser
, enum pragma_context context
)
6496 id
= c_parser_peek_token (parser
)->pragma_kind
;
6497 gcc_assert (id
!= PRAGMA_NONE
);
6501 case PRAGMA_OMP_BARRIER
:
6502 if (context
!= pragma_compound
)
6504 if (context
== pragma_stmt
)
6505 c_parser_error (parser
, "%<#pragma omp barrier%> may only be "
6506 "used in compound statements");
6509 c_parser_omp_barrier (parser
);
6512 case PRAGMA_OMP_FLUSH
:
6513 if (context
!= pragma_compound
)
6515 if (context
== pragma_stmt
)
6516 c_parser_error (parser
, "%<#pragma omp flush%> may only be "
6517 "used in compound statements");
6520 c_parser_omp_flush (parser
);
6523 case PRAGMA_OMP_THREADPRIVATE
:
6524 c_parser_omp_threadprivate (parser
);
6527 case PRAGMA_OMP_SECTION
:
6528 error ("%<#pragma omp section%> may only be used in "
6529 "%<#pragma omp sections%> construct");
6530 c_parser_skip_until_found (parser
, CPP_PRAGMA_EOL
, NULL
);
6533 case PRAGMA_GCC_PCH_PREPROCESS
:
6534 c_parser_error (parser
, "%<#pragma GCC pch_preprocess%> must be first");
6535 c_parser_skip_until_found (parser
, CPP_PRAGMA_EOL
, NULL
);
6539 if (id
< PRAGMA_FIRST_EXTERNAL
)
6541 if (context
== pragma_external
)
6544 c_parser_error (parser
, "expected declaration specifiers");
6545 c_parser_skip_until_found (parser
, CPP_PRAGMA_EOL
, NULL
);
6548 c_parser_omp_construct (parser
);
6554 c_parser_consume_pragma (parser
);
6555 c_invoke_pragma_handler (id
);
6557 /* Skip to EOL, but suppress any error message. Those will have been
6558 generated by the handler routine through calling error, as opposed
6559 to calling c_parser_error. */
6560 parser
->error
= true;
6561 c_parser_skip_to_pragma_eol (parser
);
6566 /* The interface the pragma parsers have to the lexer. */
6569 pragma_lex (tree
*value
)
6571 c_token
*tok
= c_parser_peek_token (the_parser
);
6572 enum cpp_ttype ret
= tok
->type
;
6574 *value
= tok
->value
;
6575 if (ret
== CPP_PRAGMA_EOL
|| ret
== CPP_EOF
)
6579 if (ret
== CPP_KEYWORD
)
6581 c_parser_consume_token (the_parser
);
6588 c_parser_pragma_pch_preprocess (c_parser
*parser
)
6592 c_parser_consume_pragma (parser
);
6593 if (c_parser_next_token_is (parser
, CPP_STRING
))
6595 name
= c_parser_peek_token (parser
)->value
;
6596 c_parser_consume_token (parser
);
6599 c_parser_error (parser
, "expected string literal");
6600 c_parser_skip_to_pragma_eol (parser
);
6603 c_common_pch_pragma (parse_in
, TREE_STRING_POINTER (name
));
6606 /* OpenMP 2.5 parsing routines. */
6608 /* Returns name of the next clause.
6609 If the clause is not recognized PRAGMA_OMP_CLAUSE_NONE is returned and
6610 the token is not consumed. Otherwise appropriate pragma_omp_clause is
6611 returned and the token is consumed. */
6613 static pragma_omp_clause
6614 c_parser_omp_clause_name (c_parser
*parser
)
6616 pragma_omp_clause result
= PRAGMA_OMP_CLAUSE_NONE
;
6618 if (c_parser_next_token_is_keyword (parser
, RID_IF
))
6619 result
= PRAGMA_OMP_CLAUSE_IF
;
6620 else if (c_parser_next_token_is_keyword (parser
, RID_DEFAULT
))
6621 result
= PRAGMA_OMP_CLAUSE_DEFAULT
;
6622 else if (c_parser_next_token_is (parser
, CPP_NAME
))
6624 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
6629 if (!strcmp ("copyin", p
))
6630 result
= PRAGMA_OMP_CLAUSE_COPYIN
;
6631 else if (!strcmp ("copyprivate", p
))
6632 result
= PRAGMA_OMP_CLAUSE_COPYPRIVATE
;
6635 if (!strcmp ("firstprivate", p
))
6636 result
= PRAGMA_OMP_CLAUSE_FIRSTPRIVATE
;
6639 if (!strcmp ("lastprivate", p
))
6640 result
= PRAGMA_OMP_CLAUSE_LASTPRIVATE
;
6643 if (!strcmp ("nowait", p
))
6644 result
= PRAGMA_OMP_CLAUSE_NOWAIT
;
6645 else if (!strcmp ("num_threads", p
))
6646 result
= PRAGMA_OMP_CLAUSE_NUM_THREADS
;
6649 if (!strcmp ("ordered", p
))
6650 result
= PRAGMA_OMP_CLAUSE_ORDERED
;
6653 if (!strcmp ("private", p
))
6654 result
= PRAGMA_OMP_CLAUSE_PRIVATE
;
6657 if (!strcmp ("reduction", p
))
6658 result
= PRAGMA_OMP_CLAUSE_REDUCTION
;
6661 if (!strcmp ("schedule", p
))
6662 result
= PRAGMA_OMP_CLAUSE_SCHEDULE
;
6663 else if (!strcmp ("shared", p
))
6664 result
= PRAGMA_OMP_CLAUSE_SHARED
;
6669 if (result
!= PRAGMA_OMP_CLAUSE_NONE
)
6670 c_parser_consume_token (parser
);
6675 /* Validate that a clause of the given type does not already exist. */
6678 check_no_duplicate_clause (tree clauses
, enum tree_code code
, const char *name
)
6682 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
6683 if (OMP_CLAUSE_CODE (c
) == code
)
6685 error ("too many %qs clauses", name
);
6693 variable-list , identifier
6695 If KIND is nonzero, create the appropriate node and install the decl
6696 in OMP_CLAUSE_DECL and add the node to the head of the list.
6698 If KIND is zero, create a TREE_LIST with the decl in TREE_PURPOSE;
6699 return the list created. */
6702 c_parser_omp_variable_list (c_parser
*parser
, enum omp_clause_code kind
,
6705 if (c_parser_next_token_is_not (parser
, CPP_NAME
)
6706 || c_parser_peek_token (parser
)->id_kind
!= C_ID_ID
)
6707 c_parser_error (parser
, "expected identifier");
6709 while (c_parser_next_token_is (parser
, CPP_NAME
)
6710 && c_parser_peek_token (parser
)->id_kind
== C_ID_ID
)
6712 tree t
= lookup_name (c_parser_peek_token (parser
)->value
);
6715 undeclared_variable (c_parser_peek_token (parser
)->value
,
6716 c_parser_peek_token (parser
)->location
);
6717 else if (t
== error_mark_node
)
6721 tree u
= build_omp_clause (kind
);
6722 OMP_CLAUSE_DECL (u
) = t
;
6723 OMP_CLAUSE_CHAIN (u
) = list
;
6727 list
= tree_cons (t
, NULL_TREE
, list
);
6729 c_parser_consume_token (parser
);
6731 if (c_parser_next_token_is_not (parser
, CPP_COMMA
))
6734 c_parser_consume_token (parser
);
6740 /* Similarly, but expect leading and trailing parenthesis. This is a very
6741 common case for omp clauses. */
6744 c_parser_omp_var_list_parens (c_parser
*parser
, enum tree_code kind
, tree list
)
6746 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
6748 list
= c_parser_omp_variable_list (parser
, kind
, list
);
6749 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
6755 copyin ( variable-list ) */
6758 c_parser_omp_clause_copyin (c_parser
*parser
, tree list
)
6760 return c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_COPYIN
, list
);
6764 copyprivate ( variable-list ) */
6767 c_parser_omp_clause_copyprivate (c_parser
*parser
, tree list
)
6769 return c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_COPYPRIVATE
, list
);
6773 default ( shared | none ) */
6776 c_parser_omp_clause_default (c_parser
*parser
, tree list
)
6778 enum omp_clause_default_kind kind
= OMP_CLAUSE_DEFAULT_UNSPECIFIED
;
6781 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
6783 if (c_parser_next_token_is (parser
, CPP_NAME
))
6785 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
6790 if (strcmp ("none", p
) != 0)
6792 kind
= OMP_CLAUSE_DEFAULT_NONE
;
6796 if (strcmp ("shared", p
) != 0)
6798 kind
= OMP_CLAUSE_DEFAULT_SHARED
;
6805 c_parser_consume_token (parser
);
6810 c_parser_error (parser
, "expected %<none%> or %<shared%>");
6812 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
6814 if (kind
== OMP_CLAUSE_DEFAULT_UNSPECIFIED
)
6817 check_no_duplicate_clause (list
, OMP_CLAUSE_DEFAULT
, "default");
6818 c
= build_omp_clause (OMP_CLAUSE_DEFAULT
);
6819 OMP_CLAUSE_CHAIN (c
) = list
;
6820 OMP_CLAUSE_DEFAULT_KIND (c
) = kind
;
6826 firstprivate ( variable-list ) */
6829 c_parser_omp_clause_firstprivate (c_parser
*parser
, tree list
)
6831 return c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_FIRSTPRIVATE
, list
);
6835 if ( expression ) */
6838 c_parser_omp_clause_if (c_parser
*parser
, tree list
)
6840 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
6842 tree t
= c_parser_paren_condition (parser
);
6845 check_no_duplicate_clause (list
, OMP_CLAUSE_IF
, "if");
6847 c
= build_omp_clause (OMP_CLAUSE_IF
);
6848 OMP_CLAUSE_IF_EXPR (c
) = t
;
6849 OMP_CLAUSE_CHAIN (c
) = list
;
6853 c_parser_error (parser
, "expected %<(%>");
6859 lastprivate ( variable-list ) */
6862 c_parser_omp_clause_lastprivate (c_parser
*parser
, tree list
)
6864 return c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_LASTPRIVATE
, list
);
6871 c_parser_omp_clause_nowait (c_parser
*parser ATTRIBUTE_UNUSED
, tree list
)
6875 check_no_duplicate_clause (list
, OMP_CLAUSE_NOWAIT
, "nowait");
6877 c
= build_omp_clause (OMP_CLAUSE_NOWAIT
);
6878 OMP_CLAUSE_CHAIN (c
) = list
;
6883 num_threads ( expression ) */
6886 c_parser_omp_clause_num_threads (c_parser
*parser
, tree list
)
6888 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
6890 tree c
, t
= c_parser_expression (parser
).value
;
6892 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
6894 if (!INTEGRAL_TYPE_P (TREE_TYPE (t
)))
6896 c_parser_error (parser
, "expected integer expression");
6900 /* Attempt to statically determine when the number isn't positive. */
6901 c
= fold_build2 (LE_EXPR
, boolean_type_node
, t
,
6902 build_int_cst (TREE_TYPE (t
), 0));
6903 if (c
== boolean_true_node
)
6905 warning (0, "%<num_threads%> value must be positive");
6906 t
= integer_one_node
;
6909 check_no_duplicate_clause (list
, OMP_CLAUSE_NUM_THREADS
, "num_threads");
6911 c
= build_omp_clause (OMP_CLAUSE_NUM_THREADS
);
6912 OMP_CLAUSE_NUM_THREADS_EXPR (c
) = t
;
6913 OMP_CLAUSE_CHAIN (c
) = list
;
6924 c_parser_omp_clause_ordered (c_parser
*parser ATTRIBUTE_UNUSED
, tree list
)
6928 check_no_duplicate_clause (list
, OMP_CLAUSE_ORDERED
, "ordered");
6930 c
= build_omp_clause (OMP_CLAUSE_ORDERED
);
6931 OMP_CLAUSE_CHAIN (c
) = list
;
6936 private ( variable-list ) */
6939 c_parser_omp_clause_private (c_parser
*parser
, tree list
)
6941 return c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_PRIVATE
, list
);
6945 reduction ( reduction-operator : variable-list )
6948 One of: + * - & ^ | && || */
6951 c_parser_omp_clause_reduction (c_parser
*parser
, tree list
)
6953 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
6955 enum tree_code code
;
6957 switch (c_parser_peek_token (parser
)->type
)
6969 code
= BIT_AND_EXPR
;
6972 code
= BIT_XOR_EXPR
;
6975 code
= BIT_IOR_EXPR
;
6978 code
= TRUTH_ANDIF_EXPR
;
6981 code
= TRUTH_ORIF_EXPR
;
6984 c_parser_error (parser
,
6985 "expected %<+%>, %<*%>, %<-%>, %<&%>, "
6986 "%<^%>, %<|%>, %<&&%>, or %<||%>");
6987 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, 0);
6990 c_parser_consume_token (parser
);
6991 if (c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
6995 nl
= c_parser_omp_variable_list (parser
, OMP_CLAUSE_REDUCTION
, list
);
6996 for (c
= nl
; c
!= list
; c
= OMP_CLAUSE_CHAIN (c
))
6997 OMP_CLAUSE_REDUCTION_CODE (c
) = code
;
7001 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
7007 schedule ( schedule-kind )
7008 schedule ( schedule-kind , expression )
7011 static | dynamic | guided | runtime
7015 c_parser_omp_clause_schedule (c_parser
*parser
, tree list
)
7019 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
7022 c
= build_omp_clause (OMP_CLAUSE_SCHEDULE
);
7024 if (c_parser_next_token_is (parser
, CPP_NAME
))
7026 tree kind
= c_parser_peek_token (parser
)->value
;
7027 const char *p
= IDENTIFIER_POINTER (kind
);
7032 if (strcmp ("dynamic", p
) != 0)
7034 OMP_CLAUSE_SCHEDULE_KIND (c
) = OMP_CLAUSE_SCHEDULE_DYNAMIC
;
7038 if (strcmp ("guided", p
) != 0)
7040 OMP_CLAUSE_SCHEDULE_KIND (c
) = OMP_CLAUSE_SCHEDULE_GUIDED
;
7044 if (strcmp ("runtime", p
) != 0)
7046 OMP_CLAUSE_SCHEDULE_KIND (c
) = OMP_CLAUSE_SCHEDULE_RUNTIME
;
7053 else if (c_parser_next_token_is_keyword (parser
, RID_STATIC
))
7054 OMP_CLAUSE_SCHEDULE_KIND (c
) = OMP_CLAUSE_SCHEDULE_STATIC
;
7058 c_parser_consume_token (parser
);
7059 if (c_parser_next_token_is (parser
, CPP_COMMA
))
7061 c_parser_consume_token (parser
);
7063 t
= c_parser_expr_no_commas (parser
, NULL
).value
;
7065 if (OMP_CLAUSE_SCHEDULE_KIND (c
) == OMP_CLAUSE_SCHEDULE_RUNTIME
)
7066 error ("schedule %<runtime%> does not take "
7067 "a %<chunk_size%> parameter");
7068 else if (TREE_CODE (TREE_TYPE (t
)) == INTEGER_TYPE
)
7069 OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c
) = t
;
7071 c_parser_error (parser
, "expected integer expression");
7073 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
7076 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
7077 "expected %<,%> or %<)%>");
7079 check_no_duplicate_clause (list
, OMP_CLAUSE_SCHEDULE
, "schedule");
7080 OMP_CLAUSE_CHAIN (c
) = list
;
7084 c_parser_error (parser
, "invalid schedule kind");
7085 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, 0);
7090 shared ( variable-list ) */
7093 c_parser_omp_clause_shared (c_parser
*parser
, tree list
)
7095 return c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_SHARED
, list
);
7098 /* Parse all OpenMP clauses. The set clauses allowed by the directive
7099 is a bitmask in MASK. Return the list of clauses found; the result
7100 of clause default goes in *pdefault. */
7103 c_parser_omp_all_clauses (c_parser
*parser
, unsigned int mask
,
7106 tree clauses
= NULL
;
7108 while (c_parser_next_token_is_not (parser
, CPP_PRAGMA_EOL
))
7110 const pragma_omp_clause c_kind
= c_parser_omp_clause_name (parser
);
7112 tree prev
= clauses
;
7116 case PRAGMA_OMP_CLAUSE_COPYIN
:
7117 clauses
= c_parser_omp_clause_copyin (parser
, clauses
);
7120 case PRAGMA_OMP_CLAUSE_COPYPRIVATE
:
7121 clauses
= c_parser_omp_clause_copyprivate (parser
, clauses
);
7122 c_name
= "copyprivate";
7124 case PRAGMA_OMP_CLAUSE_DEFAULT
:
7125 clauses
= c_parser_omp_clause_default (parser
, clauses
);
7128 case PRAGMA_OMP_CLAUSE_FIRSTPRIVATE
:
7129 clauses
= c_parser_omp_clause_firstprivate (parser
, clauses
);
7130 c_name
= "firstprivate";
7132 case PRAGMA_OMP_CLAUSE_IF
:
7133 clauses
= c_parser_omp_clause_if (parser
, clauses
);
7136 case PRAGMA_OMP_CLAUSE_LASTPRIVATE
:
7137 clauses
= c_parser_omp_clause_lastprivate (parser
, clauses
);
7138 c_name
= "lastprivate";
7140 case PRAGMA_OMP_CLAUSE_NOWAIT
:
7141 clauses
= c_parser_omp_clause_nowait (parser
, clauses
);
7144 case PRAGMA_OMP_CLAUSE_NUM_THREADS
:
7145 clauses
= c_parser_omp_clause_num_threads (parser
, clauses
);
7146 c_name
= "num_threads";
7148 case PRAGMA_OMP_CLAUSE_ORDERED
:
7149 clauses
= c_parser_omp_clause_ordered (parser
, clauses
);
7152 case PRAGMA_OMP_CLAUSE_PRIVATE
:
7153 clauses
= c_parser_omp_clause_private (parser
, clauses
);
7156 case PRAGMA_OMP_CLAUSE_REDUCTION
:
7157 clauses
= c_parser_omp_clause_reduction (parser
, clauses
);
7158 c_name
= "reduction";
7160 case PRAGMA_OMP_CLAUSE_SCHEDULE
:
7161 clauses
= c_parser_omp_clause_schedule (parser
, clauses
);
7162 c_name
= "schedule";
7164 case PRAGMA_OMP_CLAUSE_SHARED
:
7165 clauses
= c_parser_omp_clause_shared (parser
, clauses
);
7169 c_parser_error (parser
, "expected %<#pragma omp%> clause");
7173 if (((mask
>> c_kind
) & 1) == 0 && !parser
->error
)
7175 /* Remove the invalid clause(s) from the list to avoid
7176 confusing the rest of the compiler. */
7178 error ("%qs is not valid for %qs", c_name
, where
);
7183 c_parser_skip_to_pragma_eol (parser
);
7185 return c_finish_omp_clauses (clauses
);
7192 In practice, we're also interested in adding the statement to an
7193 outer node. So it is convenient if we work around the fact that
7194 c_parser_statement calls add_stmt. */
7197 c_parser_omp_structured_block (c_parser
*parser
)
7199 tree stmt
= push_stmt_list ();
7200 c_parser_statement (parser
);
7201 return pop_stmt_list (stmt
);
7205 # pragma omp atomic new-line
7209 x binop= expr | x++ | ++x | x-- | --x
7211 +, *, -, /, &, ^, |, <<, >>
7213 where x is an lvalue expression with scalar type. */
7216 c_parser_omp_atomic (c_parser
*parser
)
7220 enum tree_code code
;
7222 c_parser_skip_to_pragma_eol (parser
);
7224 lhs
= c_parser_unary_expression (parser
).value
;
7225 switch (TREE_CODE (lhs
))
7229 c_parser_skip_to_end_of_block_or_statement (parser
);
7232 case PREINCREMENT_EXPR
:
7233 case POSTINCREMENT_EXPR
:
7234 lhs
= TREE_OPERAND (lhs
, 0);
7236 rhs
= integer_one_node
;
7239 case PREDECREMENT_EXPR
:
7240 case POSTDECREMENT_EXPR
:
7241 lhs
= TREE_OPERAND (lhs
, 0);
7243 rhs
= integer_one_node
;
7247 switch (c_parser_peek_token (parser
)->type
)
7253 code
= TRUNC_DIV_EXPR
;
7268 code
= BIT_AND_EXPR
;
7271 code
= BIT_IOR_EXPR
;
7274 code
= BIT_XOR_EXPR
;
7277 c_parser_error (parser
,
7278 "invalid operator for %<#pragma omp atomic%>");
7282 c_parser_consume_token (parser
);
7283 rhs
= c_parser_expression (parser
).value
;
7286 stmt
= c_finish_omp_atomic (code
, lhs
, rhs
);
7287 if (stmt
!= error_mark_node
)
7289 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
7294 # pragma omp barrier new-line
7298 c_parser_omp_barrier (c_parser
*parser
)
7300 c_parser_consume_pragma (parser
);
7301 c_parser_skip_to_pragma_eol (parser
);
7303 c_finish_omp_barrier ();
7307 # pragma omp critical [(name)] new-line
7312 c_parser_omp_critical (c_parser
*parser
)
7314 tree stmt
, name
= NULL
;
7316 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
7318 c_parser_consume_token (parser
);
7319 if (c_parser_next_token_is (parser
, CPP_NAME
))
7321 name
= c_parser_peek_token (parser
)->value
;
7322 c_parser_consume_token (parser
);
7323 c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
7326 c_parser_error (parser
, "expected identifier");
7328 else if (c_parser_next_token_is_not (parser
, CPP_PRAGMA_EOL
))
7329 c_parser_error (parser
, "expected %<(%> or end of line");
7330 c_parser_skip_to_pragma_eol (parser
);
7332 stmt
= c_parser_omp_structured_block (parser
);
7333 return c_finish_omp_critical (stmt
, name
);
7337 # pragma omp flush flush-vars[opt] new-line
7340 ( variable-list ) */
7343 c_parser_omp_flush (c_parser
*parser
)
7345 c_parser_consume_pragma (parser
);
7346 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
7347 c_parser_omp_var_list_parens (parser
, 0, NULL
);
7348 else if (c_parser_next_token_is_not (parser
, CPP_PRAGMA_EOL
))
7349 c_parser_error (parser
, "expected %<(%> or end of line");
7350 c_parser_skip_to_pragma_eol (parser
);
7352 c_finish_omp_flush ();
7355 /* Parse the restricted form of the for statment allowed by OpenMP.
7356 The real trick here is to determine the loop control variable early
7357 so that we can push a new decl if necessary to make it private. */
7360 c_parser_omp_for_loop (c_parser
*parser
)
7362 tree decl
, cond
, incr
, save_break
, save_cont
, body
, init
;
7365 if (!c_parser_next_token_is_keyword (parser
, RID_FOR
))
7367 c_parser_error (parser
, "for statement expected");
7370 loc
= c_parser_peek_token (parser
)->location
;
7371 c_parser_consume_token (parser
);
7373 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
7376 /* Parse the initialization declaration or expression. */
7377 if (c_parser_next_token_starts_declspecs (parser
))
7379 c_parser_declaration_or_fndef (parser
, true, true, true, true);
7380 decl
= check_for_loop_decls ();
7385 else if (c_parser_next_token_is (parser
, CPP_NAME
)
7386 && c_parser_peek_2nd_token (parser
)->type
== CPP_EQ
)
7388 decl
= c_parser_postfix_expression (parser
).value
;
7390 c_parser_require (parser
, CPP_EQ
, "expected %<=%>");
7392 init
= c_parser_expr_no_commas (parser
, NULL
).value
;
7393 init
= build_modify_expr (decl
, NOP_EXPR
, init
);
7394 init
= c_process_expr_stmt (init
);
7396 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
7401 /* Parse the loop condition. */
7403 if (c_parser_next_token_is_not (parser
, CPP_SEMICOLON
))
7405 cond
= c_parser_expression_conv (parser
).value
;
7406 cond
= c_objc_common_truthvalue_conversion (cond
);
7407 if (CAN_HAVE_LOCATION_P (cond
))
7408 SET_EXPR_LOCATION (cond
, input_location
);
7410 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
7412 /* Parse the increment expression. */
7414 if (c_parser_next_token_is_not (parser
, CPP_CLOSE_PAREN
))
7415 incr
= c_process_expr_stmt (c_parser_expression (parser
).value
);
7416 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
7419 save_break
= c_break_label
;
7420 c_break_label
= size_one_node
;
7421 save_cont
= c_cont_label
;
7422 c_cont_label
= NULL_TREE
;
7423 body
= push_stmt_list ();
7425 add_stmt (c_parser_c99_block_statement (parser
));
7427 add_stmt (build1 (LABEL_EXPR
, void_type_node
, c_cont_label
));
7429 body
= pop_stmt_list (body
);
7430 c_break_label
= save_break
;
7431 c_cont_label
= save_cont
;
7433 /* Only bother calling c_finish_omp_for if we havn't already generated
7434 an error from the initialization parsing. */
7435 if (decl
!= NULL
&& decl
!= error_mark_node
&& init
!= error_mark_node
)
7436 return c_finish_omp_for (loc
, decl
, init
, cond
, incr
, body
, NULL
);
7440 c_parser_error (parser
, "expected iteration declaration or initialization");
7441 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
7442 decl
= init
= cond
= incr
= NULL_TREE
;
7447 #pragma omp for for-clause[optseq] new-line
7451 #define OMP_FOR_CLAUSE_MASK \
7452 ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
7453 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
7454 | (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
7455 | (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \
7456 | (1u << PRAGMA_OMP_CLAUSE_ORDERED) \
7457 | (1u << PRAGMA_OMP_CLAUSE_SCHEDULE) \
7458 | (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
7461 c_parser_omp_for (c_parser
*parser
)
7463 tree block
, clauses
, ret
;
7465 clauses
= c_parser_omp_all_clauses (parser
, OMP_FOR_CLAUSE_MASK
,
7468 block
= c_begin_compound_stmt (true);
7469 ret
= c_parser_omp_for_loop (parser
);
7471 OMP_FOR_CLAUSES (ret
) = clauses
;
7472 block
= c_end_compound_stmt (block
, true);
7479 # pragma omp master new-line
7484 c_parser_omp_master (c_parser
*parser
)
7486 c_parser_skip_to_pragma_eol (parser
);
7487 return c_finish_omp_master (c_parser_omp_structured_block (parser
));
7491 # pragma omp ordered new-line
7496 c_parser_omp_ordered (c_parser
*parser
)
7498 c_parser_skip_to_pragma_eol (parser
);
7499 return c_finish_omp_ordered (c_parser_omp_structured_block (parser
));
7505 { section-sequence }
7508 section-directive[opt] structured-block
7509 section-sequence section-directive structured-block */
7512 c_parser_omp_sections_scope (c_parser
*parser
)
7515 bool error_suppress
= false;
7518 if (!c_parser_require (parser
, CPP_OPEN_BRACE
, "expected %<{%>"))
7520 /* Avoid skipping until the end of the block. */
7521 parser
->error
= false;
7525 stmt
= push_stmt_list ();
7527 loc
= c_parser_peek_token (parser
)->location
;
7528 if (c_parser_peek_token (parser
)->pragma_kind
!= PRAGMA_OMP_SECTION
)
7530 substmt
= push_stmt_list ();
7534 c_parser_statement (parser
);
7536 if (c_parser_peek_token (parser
)->pragma_kind
== PRAGMA_OMP_SECTION
)
7538 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
7540 if (c_parser_next_token_is (parser
, CPP_EOF
))
7544 substmt
= pop_stmt_list (substmt
);
7545 substmt
= build1 (OMP_SECTION
, void_type_node
, substmt
);
7546 SET_EXPR_LOCATION (substmt
, loc
);
7552 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
7554 if (c_parser_next_token_is (parser
, CPP_EOF
))
7557 loc
= c_parser_peek_token (parser
)->location
;
7558 if (c_parser_peek_token (parser
)->pragma_kind
== PRAGMA_OMP_SECTION
)
7560 c_parser_consume_pragma (parser
);
7561 c_parser_skip_to_pragma_eol (parser
);
7562 error_suppress
= false;
7564 else if (!error_suppress
)
7566 error ("expected %<#pragma omp section%> or %<}%>");
7567 error_suppress
= true;
7570 substmt
= c_parser_omp_structured_block (parser
);
7571 substmt
= build1 (OMP_SECTION
, void_type_node
, substmt
);
7572 SET_EXPR_LOCATION (substmt
, loc
);
7575 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
,
7576 "expected %<#pragma omp section%> or %<}%>");
7578 substmt
= pop_stmt_list (stmt
);
7580 stmt
= make_node (OMP_SECTIONS
);
7581 TREE_TYPE (stmt
) = void_type_node
;
7582 OMP_SECTIONS_BODY (stmt
) = substmt
;
7584 return add_stmt (stmt
);
7588 # pragma omp sections sections-clause[optseq] newline
7592 #define OMP_SECTIONS_CLAUSE_MASK \
7593 ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
7594 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
7595 | (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
7596 | (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \
7597 | (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
7600 c_parser_omp_sections (c_parser
*parser
)
7602 tree block
, clauses
, ret
;
7604 clauses
= c_parser_omp_all_clauses (parser
, OMP_SECTIONS_CLAUSE_MASK
,
7605 "#pragma omp sections");
7607 block
= c_begin_compound_stmt (true);
7608 ret
= c_parser_omp_sections_scope (parser
);
7610 OMP_SECTIONS_CLAUSES (ret
) = clauses
;
7611 block
= c_end_compound_stmt (block
, true);
7618 # pragma parallel parallel-clause new-line
7619 # pragma parallel for parallel-for-clause new-line
7620 # pragma parallel sections parallel-sections-clause new-line
7623 #define OMP_PARALLEL_CLAUSE_MASK \
7624 ( (1u << PRAGMA_OMP_CLAUSE_IF) \
7625 | (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
7626 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
7627 | (1u << PRAGMA_OMP_CLAUSE_DEFAULT) \
7628 | (1u << PRAGMA_OMP_CLAUSE_SHARED) \
7629 | (1u << PRAGMA_OMP_CLAUSE_COPYIN) \
7630 | (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \
7631 | (1u << PRAGMA_OMP_CLAUSE_NUM_THREADS))
7634 c_parser_omp_parallel (c_parser
*parser
)
7636 enum pragma_kind p_kind
= PRAGMA_OMP_PARALLEL
;
7637 const char *p_name
= "#pragma omp parallel";
7638 tree stmt
, clauses
, par_clause
, ws_clause
, block
;
7639 unsigned int mask
= OMP_PARALLEL_CLAUSE_MASK
;
7641 if (c_parser_next_token_is_keyword (parser
, RID_FOR
))
7643 c_parser_consume_token (parser
);
7644 p_kind
= PRAGMA_OMP_PARALLEL_FOR
;
7645 p_name
= "#pragma omp parallel for";
7646 mask
|= OMP_FOR_CLAUSE_MASK
;
7647 mask
&= ~(1u << PRAGMA_OMP_CLAUSE_NOWAIT
);
7649 else if (c_parser_next_token_is (parser
, CPP_NAME
))
7651 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
7652 if (strcmp (p
, "sections") == 0)
7654 c_parser_consume_token (parser
);
7655 p_kind
= PRAGMA_OMP_PARALLEL_SECTIONS
;
7656 p_name
= "#pragma omp parallel sections";
7657 mask
|= OMP_SECTIONS_CLAUSE_MASK
;
7658 mask
&= ~(1u << PRAGMA_OMP_CLAUSE_NOWAIT
);
7662 clauses
= c_parser_omp_all_clauses (parser
, mask
, p_name
);
7666 case PRAGMA_OMP_PARALLEL
:
7667 block
= c_begin_omp_parallel ();
7668 c_parser_statement (parser
);
7669 stmt
= c_finish_omp_parallel (clauses
, block
);
7672 case PRAGMA_OMP_PARALLEL_FOR
:
7673 block
= c_begin_omp_parallel ();
7674 c_split_parallel_clauses (clauses
, &par_clause
, &ws_clause
);
7675 stmt
= c_parser_omp_for_loop (parser
);
7677 OMP_FOR_CLAUSES (stmt
) = ws_clause
;
7678 stmt
= c_finish_omp_parallel (par_clause
, block
);
7679 OMP_PARALLEL_COMBINED (stmt
) = 1;
7682 case PRAGMA_OMP_PARALLEL_SECTIONS
:
7683 block
= c_begin_omp_parallel ();
7684 c_split_parallel_clauses (clauses
, &par_clause
, &ws_clause
);
7685 stmt
= c_parser_omp_sections_scope (parser
);
7687 OMP_SECTIONS_CLAUSES (stmt
) = ws_clause
;
7688 stmt
= c_finish_omp_parallel (par_clause
, block
);
7689 OMP_PARALLEL_COMBINED (stmt
) = 1;
7700 # pragma omp single single-clause[optseq] new-line
7704 #define OMP_SINGLE_CLAUSE_MASK \
7705 ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
7706 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
7707 | (1u << PRAGMA_OMP_CLAUSE_COPYPRIVATE) \
7708 | (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
7711 c_parser_omp_single (c_parser
*parser
)
7713 tree stmt
= make_node (OMP_SINGLE
);
7714 TREE_TYPE (stmt
) = void_type_node
;
7716 OMP_SINGLE_CLAUSES (stmt
)
7717 = c_parser_omp_all_clauses (parser
, OMP_SINGLE_CLAUSE_MASK
,
7718 "#pragma omp single");
7719 OMP_SINGLE_BODY (stmt
) = c_parser_omp_structured_block (parser
);
7721 return add_stmt (stmt
);
7725 /* Main entry point to parsing most OpenMP pragmas. */
7728 c_parser_omp_construct (c_parser
*parser
)
7730 enum pragma_kind p_kind
;
7734 loc
= c_parser_peek_token (parser
)->location
;
7735 p_kind
= c_parser_peek_token (parser
)->pragma_kind
;
7736 c_parser_consume_pragma (parser
);
7738 /* For all constructs below except #pragma omp atomic
7739 MUST_NOT_THROW catch handlers are needed when exceptions
7741 if (p_kind
!= PRAGMA_OMP_ATOMIC
)
7742 c_maybe_initialize_eh ();
7746 case PRAGMA_OMP_ATOMIC
:
7747 c_parser_omp_atomic (parser
);
7749 case PRAGMA_OMP_CRITICAL
:
7750 stmt
= c_parser_omp_critical (parser
);
7752 case PRAGMA_OMP_FOR
:
7753 stmt
= c_parser_omp_for (parser
);
7755 case PRAGMA_OMP_MASTER
:
7756 stmt
= c_parser_omp_master (parser
);
7758 case PRAGMA_OMP_ORDERED
:
7759 stmt
= c_parser_omp_ordered (parser
);
7761 case PRAGMA_OMP_PARALLEL
:
7762 stmt
= c_parser_omp_parallel (parser
);
7764 case PRAGMA_OMP_SECTIONS
:
7765 stmt
= c_parser_omp_sections (parser
);
7767 case PRAGMA_OMP_SINGLE
:
7768 stmt
= c_parser_omp_single (parser
);
7775 SET_EXPR_LOCATION (stmt
, loc
);
7780 # pragma omp threadprivate (variable-list) */
7783 c_parser_omp_threadprivate (c_parser
*parser
)
7787 c_parser_consume_pragma (parser
);
7788 vars
= c_parser_omp_var_list_parens (parser
, 0, NULL
);
7790 /* Mark every variable in VARS to be assigned thread local storage. */
7791 for (t
= vars
; t
; t
= TREE_CHAIN (t
))
7793 tree v
= TREE_PURPOSE (t
);
7795 /* If V had already been marked threadprivate, it doesn't matter
7796 whether it had been used prior to this point. */
7797 if (TREE_USED (v
) && !C_DECL_THREADPRIVATE_P (v
))
7798 error ("%qE declared %<threadprivate%> after first use", v
);
7799 else if (! TREE_STATIC (v
) && ! DECL_EXTERNAL (v
))
7800 error ("automatic variable %qE cannot be %<threadprivate%>", v
);
7801 else if (! COMPLETE_TYPE_P (TREE_TYPE (v
)))
7802 error ("%<threadprivate%> %qE has incomplete type", v
);
7805 if (! DECL_THREAD_LOCAL_P (v
))
7807 DECL_TLS_MODEL (v
) = decl_default_tls_model (v
);
7808 /* If rtl has been already set for this var, call
7809 make_decl_rtl once again, so that encode_section_info
7810 has a chance to look at the new decl flags. */
7811 if (DECL_RTL_SET_P (v
))
7814 C_DECL_THREADPRIVATE_P (v
) = 1;
7818 c_parser_skip_to_pragma_eol (parser
);
7822 /* Parse a single source file. */
7827 /* Use local storage to begin. If the first token is a pragma, parse it.
7828 If it is #pragma GCC pch_preprocess, then this will load a PCH file
7829 which will cause garbage collection. */
7832 memset (&tparser
, 0, sizeof tparser
);
7833 the_parser
= &tparser
;
7835 if (c_parser_peek_token (&tparser
)->pragma_kind
== PRAGMA_GCC_PCH_PREPROCESS
)
7836 c_parser_pragma_pch_preprocess (&tparser
);
7838 the_parser
= GGC_NEW (c_parser
);
7839 *the_parser
= tparser
;
7841 c_parser_translation_unit (the_parser
);
7845 #include "gt-c-parser.h"