1 /* Parser for C and Objective-C.
2 Copyright (C) 1987-2013 Free Software Foundation, Inc.
4 Parser actions based on the old Bison parser; structure somewhat
5 influenced by and fragments based on the C++ parser.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
25 Make sure all relevant comments, and all relevant code from all
26 actions, brought over from old parser. Verify exact correspondence
29 Add testcases covering every input symbol in every state in old and
32 Include full syntax for GNU C, including erroneous cases accepted
33 with error messages, in syntax productions in comments.
35 Make more diagnostics in the front end generally take an explicit
36 location rather than implicitly using input_location. */
40 #include "coretypes.h"
41 #include "tm.h" /* For rtl.h: needs enum reg_class. */
43 #include "langhooks.h"
47 #include "c-family/c-pragma.h"
52 #include "c-family/c-common.h"
53 #include "c-family/c-objc.h"
60 /* Initialization routine for this file. */
65 /* The only initialization required is of the reserved word
71 /* Make sure RID_MAX hasn't grown past the 8 bits used to hold the keyword in
72 the c_token structure. */
73 gcc_assert (RID_MAX
<= 255);
80 mask
|= D_ASM
| D_EXT
;
84 if (!c_dialect_objc ())
85 mask
|= D_OBJC
| D_CXX_OBJC
;
87 ridpointers
= ggc_alloc_cleared_vec_tree ((int) RID_MAX
);
88 for (i
= 0; i
< num_c_common_reswords
; i
++)
90 /* If a keyword is disabled, do not enter it into the table
91 and so create a canonical spelling that isn't a keyword. */
92 if (c_common_reswords
[i
].disable
& mask
)
95 && (c_common_reswords
[i
].disable
& D_CXXWARN
))
97 id
= get_identifier (c_common_reswords
[i
].word
);
98 C_SET_RID_CODE (id
, RID_CXX_COMPAT_WARN
);
99 C_IS_RESERVED_WORD (id
) = 1;
104 id
= get_identifier (c_common_reswords
[i
].word
);
105 C_SET_RID_CODE (id
, c_common_reswords
[i
].rid
);
106 C_IS_RESERVED_WORD (id
) = 1;
107 ridpointers
[(int) c_common_reswords
[i
].rid
] = id
;
111 /* The C lexer intermediates between the lexer in cpplib and c-lex.c
112 and the C parser. Unlike the C++ lexer, the parser structure
113 stores the lexer information instead of using a separate structure.
114 Identifiers are separated into ordinary identifiers, type names,
115 keywords and some other Objective-C types of identifiers, and some
116 look-ahead is maintained.
118 ??? It might be a good idea to lex the whole file up front (as for
119 C++). It would then be possible to share more of the C and C++
120 lexer code, if desired. */
122 /* The following local token type is used. */
125 #define CPP_KEYWORD ((enum cpp_ttype) (N_TTYPES + 1))
127 /* More information about the type of a CPP_NAME token. */
128 typedef enum c_id_kind
{
129 /* An ordinary identifier. */
131 /* An identifier declared as a typedef name. */
133 /* An identifier declared as an Objective-C class name. */
135 /* An address space identifier. */
137 /* Not an identifier. */
141 /* A single C token after string literal concatenation and conversion
142 of preprocessing tokens to tokens. */
143 typedef struct GTY (()) c_token
{
144 /* The kind of token. */
145 ENUM_BITFIELD (cpp_ttype
) type
: 8;
146 /* If this token is a CPP_NAME, this value indicates whether also
147 declared as some kind of type. Otherwise, it is C_ID_NONE. */
148 ENUM_BITFIELD (c_id_kind
) id_kind
: 8;
149 /* If this token is a keyword, this value indicates which keyword.
150 Otherwise, this value is RID_MAX. */
151 ENUM_BITFIELD (rid
) keyword
: 8;
152 /* If this token is a CPP_PRAGMA, this indicates the pragma that
153 was seen. Otherwise it is PRAGMA_NONE. */
154 ENUM_BITFIELD (pragma_kind
) pragma_kind
: 8;
155 /* The location at which this token was found. */
157 /* The value associated with this token, if any. */
161 /* A parser structure recording information about the state and
162 context of parsing. Includes lexer information with up to two
163 tokens of look-ahead; more are not needed for C. */
164 typedef struct GTY(()) c_parser
{
165 /* The look-ahead tokens. */
166 c_token
* GTY((skip
)) tokens
;
167 /* Buffer for look-ahead tokens. */
168 c_token tokens_buf
[2];
169 /* How many look-ahead tokens are available (0, 1 or 2, or
170 more if parsing from pre-lexed tokens). */
171 unsigned int tokens_avail
;
172 /* True if a syntax error is being recovered from; false otherwise.
173 c_parser_error sets this flag. It should clear this flag when
174 enough tokens have been consumed to recover from the error. */
175 BOOL_BITFIELD error
: 1;
176 /* True if we're processing a pragma, and shouldn't automatically
177 consume CPP_PRAGMA_EOL. */
178 BOOL_BITFIELD in_pragma
: 1;
179 /* True if we're parsing the outermost block of an if statement. */
180 BOOL_BITFIELD in_if_block
: 1;
181 /* True if we want to lex an untranslated string. */
182 BOOL_BITFIELD lex_untranslated_string
: 1;
184 /* Objective-C specific parser/lexer information. */
186 /* True if we are in a context where the Objective-C "PQ" keywords
187 are considered keywords. */
188 BOOL_BITFIELD objc_pq_context
: 1;
189 /* True if we are parsing a (potential) Objective-C foreach
190 statement. This is set to true after we parsed 'for (' and while
191 we wait for 'in' or ';' to decide if it's a standard C for loop or an
192 Objective-C foreach loop. */
193 BOOL_BITFIELD objc_could_be_foreach_context
: 1;
194 /* The following flag is needed to contextualize Objective-C lexical
195 analysis. In some cases (e.g., 'int NSObject;'), it is
196 undesirable to bind an identifier to an Objective-C class, even
197 if a class with that name exists. */
198 BOOL_BITFIELD objc_need_raw_identifier
: 1;
199 /* Nonzero if we're processing a __transaction statement. The value
200 is 1 | TM_STMT_ATTR_*. */
201 unsigned int in_transaction
: 4;
202 /* True if we are in a context where the Objective-C "Property attribute"
203 keywords are valid. */
204 BOOL_BITFIELD objc_property_attr_context
: 1;
208 /* The actual parser and external interface. ??? Does this need to be
209 garbage-collected? */
211 static GTY (()) c_parser
*the_parser
;
213 /* Read in and lex a single token, storing it in *TOKEN. */
216 c_lex_one_token (c_parser
*parser
, c_token
*token
)
218 timevar_push (TV_LEX
);
220 token
->type
= c_lex_with_flags (&token
->value
, &token
->location
, NULL
,
221 (parser
->lex_untranslated_string
222 ? C_LEX_STRING_NO_TRANSLATE
: 0));
223 token
->id_kind
= C_ID_NONE
;
224 token
->keyword
= RID_MAX
;
225 token
->pragma_kind
= PRAGMA_NONE
;
233 bool objc_force_identifier
= parser
->objc_need_raw_identifier
;
234 if (c_dialect_objc ())
235 parser
->objc_need_raw_identifier
= false;
237 if (C_IS_RESERVED_WORD (token
->value
))
239 enum rid rid_code
= C_RID_CODE (token
->value
);
241 if (rid_code
== RID_CXX_COMPAT_WARN
)
243 warning_at (token
->location
,
245 "identifier %qE conflicts with C++ keyword",
248 else if (rid_code
>= RID_FIRST_ADDR_SPACE
249 && rid_code
<= RID_LAST_ADDR_SPACE
)
251 token
->id_kind
= C_ID_ADDRSPACE
;
252 token
->keyword
= rid_code
;
255 else if (c_dialect_objc () && OBJC_IS_PQ_KEYWORD (rid_code
))
257 /* We found an Objective-C "pq" keyword (in, out,
258 inout, bycopy, byref, oneway). They need special
259 care because the interpretation depends on the
261 if (parser
->objc_pq_context
)
263 token
->type
= CPP_KEYWORD
;
264 token
->keyword
= rid_code
;
267 else if (parser
->objc_could_be_foreach_context
268 && rid_code
== RID_IN
)
270 /* We are in Objective-C, inside a (potential)
271 foreach context (which means after having
272 parsed 'for (', but before having parsed ';'),
273 and we found 'in'. We consider it the keyword
274 which terminates the declaration at the
275 beginning of a foreach-statement. Note that
276 this means you can't use 'in' for anything else
277 in that context; in particular, in Objective-C
278 you can't use 'in' as the name of the running
279 variable in a C for loop. We could potentially
280 try to add code here to disambiguate, but it
281 seems a reasonable limitation. */
282 token
->type
= CPP_KEYWORD
;
283 token
->keyword
= rid_code
;
286 /* Else, "pq" keywords outside of the "pq" context are
287 not keywords, and we fall through to the code for
290 else if (c_dialect_objc () && OBJC_IS_PATTR_KEYWORD (rid_code
))
292 /* We found an Objective-C "property attribute"
293 keyword (getter, setter, readonly, etc). These are
294 only valid in the property context. */
295 if (parser
->objc_property_attr_context
)
297 token
->type
= CPP_KEYWORD
;
298 token
->keyword
= rid_code
;
301 /* Else they are not special keywords.
304 else if (c_dialect_objc ()
305 && (OBJC_IS_AT_KEYWORD (rid_code
)
306 || OBJC_IS_CXX_KEYWORD (rid_code
)))
308 /* We found one of the Objective-C "@" keywords (defs,
309 selector, synchronized, etc) or one of the
310 Objective-C "cxx" keywords (class, private,
311 protected, public, try, catch, throw) without a
312 preceding '@' sign. Do nothing and fall through to
313 the code for normal tokens (in C++ we would still
314 consider the CXX ones keywords, but not in C). */
319 token
->type
= CPP_KEYWORD
;
320 token
->keyword
= rid_code
;
325 decl
= lookup_name (token
->value
);
328 if (TREE_CODE (decl
) == TYPE_DECL
)
330 token
->id_kind
= C_ID_TYPENAME
;
334 else if (c_dialect_objc ())
336 tree objc_interface_decl
= objc_is_class_name (token
->value
);
337 /* Objective-C class names are in the same namespace as
338 variables and typedefs, and hence are shadowed by local
340 if (objc_interface_decl
341 && (!objc_force_identifier
|| global_bindings_p ()))
343 token
->value
= objc_interface_decl
;
344 token
->id_kind
= C_ID_CLASSNAME
;
348 token
->id_kind
= C_ID_ID
;
352 /* This only happens in Objective-C; it must be a keyword. */
353 token
->type
= CPP_KEYWORD
;
354 switch (C_RID_CODE (token
->value
))
356 /* Replace 'class' with '@class', 'private' with '@private',
357 etc. This prevents confusion with the C++ keyword
358 'class', and makes the tokens consistent with other
359 Objective-C 'AT' keywords. For example '@class' is
360 reported as RID_AT_CLASS which is consistent with
361 '@synchronized', which is reported as
364 case RID_CLASS
: token
->keyword
= RID_AT_CLASS
; break;
365 case RID_PRIVATE
: token
->keyword
= RID_AT_PRIVATE
; break;
366 case RID_PROTECTED
: token
->keyword
= RID_AT_PROTECTED
; break;
367 case RID_PUBLIC
: token
->keyword
= RID_AT_PUBLIC
; break;
368 case RID_THROW
: token
->keyword
= RID_AT_THROW
; break;
369 case RID_TRY
: token
->keyword
= RID_AT_TRY
; break;
370 case RID_CATCH
: token
->keyword
= RID_AT_CATCH
; break;
371 default: token
->keyword
= C_RID_CODE (token
->value
);
376 case CPP_CLOSE_PAREN
:
378 /* These tokens may affect the interpretation of any identifiers
379 following, if doing Objective-C. */
380 if (c_dialect_objc ())
381 parser
->objc_need_raw_identifier
= false;
384 /* We smuggled the cpp_token->u.pragma value in an INTEGER_CST. */
385 token
->pragma_kind
= (enum pragma_kind
) TREE_INT_CST_LOW (token
->value
);
391 timevar_pop (TV_LEX
);
394 /* Return a pointer to the next token from PARSER, reading it in if
397 static inline c_token
*
398 c_parser_peek_token (c_parser
*parser
)
400 if (parser
->tokens_avail
== 0)
402 c_lex_one_token (parser
, &parser
->tokens
[0]);
403 parser
->tokens_avail
= 1;
405 return &parser
->tokens
[0];
408 /* Return true if the next token from PARSER has the indicated
412 c_parser_next_token_is (c_parser
*parser
, enum cpp_ttype type
)
414 return c_parser_peek_token (parser
)->type
== type
;
417 /* Return true if the next token from PARSER does not have the
421 c_parser_next_token_is_not (c_parser
*parser
, enum cpp_ttype type
)
423 return !c_parser_next_token_is (parser
, type
);
426 /* Return true if the next token from PARSER is the indicated
430 c_parser_next_token_is_keyword (c_parser
*parser
, enum rid keyword
)
432 return c_parser_peek_token (parser
)->keyword
== keyword
;
435 /* Return a pointer to the next-but-one token from PARSER, reading it
436 in if necessary. The next token is already read in. */
439 c_parser_peek_2nd_token (c_parser
*parser
)
441 if (parser
->tokens_avail
>= 2)
442 return &parser
->tokens
[1];
443 gcc_assert (parser
->tokens_avail
== 1);
444 gcc_assert (parser
->tokens
[0].type
!= CPP_EOF
);
445 gcc_assert (parser
->tokens
[0].type
!= CPP_PRAGMA_EOL
);
446 c_lex_one_token (parser
, &parser
->tokens
[1]);
447 parser
->tokens_avail
= 2;
448 return &parser
->tokens
[1];
451 /* Return true if TOKEN can start a type name,
454 c_token_starts_typename (c_token
*token
)
459 switch (token
->id_kind
)
468 gcc_assert (c_dialect_objc ());
474 switch (token
->keyword
)
507 if (c_dialect_objc ())
515 enum c_lookahead_kind
{
516 /* Always treat unknown identifiers as typenames. */
519 /* Could be parsing a nonabstract declarator. Only treat an identifier
520 as a typename if followed by another identifier or a star. */
521 cla_nonabstract_decl
,
523 /* Never treat identifiers as typenames. */
527 /* Return true if the next token from PARSER can start a type name,
528 false otherwise. LA specifies how to do lookahead in order to
529 detect unknown type names. If unsure, pick CLA_PREFER_ID. */
532 c_parser_next_tokens_start_typename (c_parser
*parser
, enum c_lookahead_kind la
)
534 c_token
*token
= c_parser_peek_token (parser
);
535 if (c_token_starts_typename (token
))
538 /* Try a bit harder to detect an unknown typename. */
539 if (la
!= cla_prefer_id
540 && token
->type
== CPP_NAME
541 && token
->id_kind
== C_ID_ID
543 /* Do not try too hard when we could have "object in array". */
544 && !parser
->objc_could_be_foreach_context
546 && (la
== cla_prefer_type
547 || c_parser_peek_2nd_token (parser
)->type
== CPP_NAME
548 || c_parser_peek_2nd_token (parser
)->type
== CPP_MULT
)
550 /* Only unknown identifiers. */
551 && !lookup_name (token
->value
))
557 /* Return true if TOKEN is a type qualifier, false otherwise. */
559 c_token_is_qualifier (c_token
*token
)
564 switch (token
->id_kind
)
572 switch (token
->keyword
)
589 /* Return true if the next token from PARSER is a type qualifier,
592 c_parser_next_token_is_qualifier (c_parser
*parser
)
594 c_token
*token
= c_parser_peek_token (parser
);
595 return c_token_is_qualifier (token
);
598 /* Return true if TOKEN can start declaration specifiers, false
601 c_token_starts_declspecs (c_token
*token
)
606 switch (token
->id_kind
)
615 gcc_assert (c_dialect_objc ());
621 switch (token
->keyword
)
663 if (c_dialect_objc ())
672 /* Return true if TOKEN can start declaration specifiers or a static
673 assertion, false otherwise. */
675 c_token_starts_declaration (c_token
*token
)
677 if (c_token_starts_declspecs (token
)
678 || token
->keyword
== RID_STATIC_ASSERT
)
684 /* Return true if the next token from PARSER can start declaration
685 specifiers, false otherwise. */
687 c_parser_next_token_starts_declspecs (c_parser
*parser
)
689 c_token
*token
= c_parser_peek_token (parser
);
691 /* In Objective-C, a classname normally starts a declspecs unless it
692 is immediately followed by a dot. In that case, it is the
693 Objective-C 2.0 "dot-syntax" for class objects, ie, calls the
694 setter/getter on the class. c_token_starts_declspecs() can't
695 differentiate between the two cases because it only checks the
696 current token, so we have a special check here. */
697 if (c_dialect_objc ()
698 && token
->type
== CPP_NAME
699 && token
->id_kind
== C_ID_CLASSNAME
700 && c_parser_peek_2nd_token (parser
)->type
== CPP_DOT
)
703 return c_token_starts_declspecs (token
);
706 /* Return true if the next tokens from PARSER can start declaration
707 specifiers or a static assertion, false otherwise. */
709 c_parser_next_tokens_start_declaration (c_parser
*parser
)
711 c_token
*token
= c_parser_peek_token (parser
);
714 if (c_dialect_objc ()
715 && token
->type
== CPP_NAME
716 && token
->id_kind
== C_ID_CLASSNAME
717 && c_parser_peek_2nd_token (parser
)->type
== CPP_DOT
)
720 /* Labels do not start declarations. */
721 if (token
->type
== CPP_NAME
722 && c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
)
725 if (c_token_starts_declaration (token
))
728 if (c_parser_next_tokens_start_typename (parser
, cla_nonabstract_decl
))
734 /* Consume the next token from PARSER. */
737 c_parser_consume_token (c_parser
*parser
)
739 gcc_assert (parser
->tokens_avail
>= 1);
740 gcc_assert (parser
->tokens
[0].type
!= CPP_EOF
);
741 gcc_assert (!parser
->in_pragma
|| parser
->tokens
[0].type
!= CPP_PRAGMA_EOL
);
742 gcc_assert (parser
->error
|| parser
->tokens
[0].type
!= CPP_PRAGMA
);
743 if (parser
->tokens
!= &parser
->tokens_buf
[0])
745 else if (parser
->tokens_avail
== 2)
746 parser
->tokens
[0] = parser
->tokens
[1];
747 parser
->tokens_avail
--;
750 /* Expect the current token to be a #pragma. Consume it and remember
751 that we've begun parsing a pragma. */
754 c_parser_consume_pragma (c_parser
*parser
)
756 gcc_assert (!parser
->in_pragma
);
757 gcc_assert (parser
->tokens_avail
>= 1);
758 gcc_assert (parser
->tokens
[0].type
== CPP_PRAGMA
);
759 if (parser
->tokens
!= &parser
->tokens_buf
[0])
761 else if (parser
->tokens_avail
== 2)
762 parser
->tokens
[0] = parser
->tokens
[1];
763 parser
->tokens_avail
--;
764 parser
->in_pragma
= true;
767 /* Update the globals input_location and in_system_header from
770 c_parser_set_source_position_from_token (c_token
*token
)
772 if (token
->type
!= CPP_EOF
)
774 input_location
= token
->location
;
778 /* Issue a diagnostic of the form
779 FILE:LINE: MESSAGE before TOKEN
780 where TOKEN is the next token in the input stream of PARSER.
781 MESSAGE (specified by the caller) is usually of the form "expected
784 Do not issue a diagnostic if still recovering from an error.
786 ??? This is taken from the C++ parser, but building up messages in
787 this way is not i18n-friendly and some other approach should be
791 c_parser_error (c_parser
*parser
, const char *gmsgid
)
793 c_token
*token
= c_parser_peek_token (parser
);
796 parser
->error
= true;
799 /* This diagnostic makes more sense if it is tagged to the line of
800 the token we just peeked at. */
801 c_parser_set_source_position_from_token (token
);
802 c_parse_error (gmsgid
,
803 /* Because c_parse_error does not understand
804 CPP_KEYWORD, keywords are treated like
806 (token
->type
== CPP_KEYWORD
? CPP_NAME
: token
->type
),
807 /* ??? The C parser does not save the cpp flags of a
808 token, we need to pass 0 here and we will not get
809 the source spelling of some tokens but rather the
810 canonical spelling. */
811 token
->value
, /*flags=*/0);
814 /* If the next token is of the indicated TYPE, consume it. Otherwise,
815 issue the error MSGID. If MSGID is NULL then a message has already
816 been produced and no message will be produced this time. Returns
817 true if found, false otherwise. */
820 c_parser_require (c_parser
*parser
,
824 if (c_parser_next_token_is (parser
, type
))
826 c_parser_consume_token (parser
);
831 c_parser_error (parser
, msgid
);
836 /* If the next token is the indicated keyword, consume it. Otherwise,
837 issue the error MSGID. Returns true if found, false otherwise. */
840 c_parser_require_keyword (c_parser
*parser
,
844 if (c_parser_next_token_is_keyword (parser
, keyword
))
846 c_parser_consume_token (parser
);
851 c_parser_error (parser
, msgid
);
856 /* Like c_parser_require, except that tokens will be skipped until the
857 desired token is found. An error message is still produced if the
858 next token is not as expected. If MSGID is NULL then a message has
859 already been produced and no message will be produced this
863 c_parser_skip_until_found (c_parser
*parser
,
867 unsigned nesting_depth
= 0;
869 if (c_parser_require (parser
, type
, msgid
))
872 /* Skip tokens until the desired token is found. */
875 /* Peek at the next token. */
876 c_token
*token
= c_parser_peek_token (parser
);
877 /* If we've reached the token we want, consume it and stop. */
878 if (token
->type
== type
&& !nesting_depth
)
880 c_parser_consume_token (parser
);
884 /* If we've run out of tokens, stop. */
885 if (token
->type
== CPP_EOF
)
887 if (token
->type
== CPP_PRAGMA_EOL
&& parser
->in_pragma
)
889 if (token
->type
== CPP_OPEN_BRACE
890 || token
->type
== CPP_OPEN_PAREN
891 || token
->type
== CPP_OPEN_SQUARE
)
893 else if (token
->type
== CPP_CLOSE_BRACE
894 || token
->type
== CPP_CLOSE_PAREN
895 || token
->type
== CPP_CLOSE_SQUARE
)
897 if (nesting_depth
-- == 0)
900 /* Consume this token. */
901 c_parser_consume_token (parser
);
903 parser
->error
= false;
906 /* Skip tokens until the end of a parameter is found, but do not
907 consume the comma, semicolon or closing delimiter. */
910 c_parser_skip_to_end_of_parameter (c_parser
*parser
)
912 unsigned nesting_depth
= 0;
916 c_token
*token
= c_parser_peek_token (parser
);
917 if ((token
->type
== CPP_COMMA
|| token
->type
== CPP_SEMICOLON
)
920 /* If we've run out of tokens, stop. */
921 if (token
->type
== CPP_EOF
)
923 if (token
->type
== CPP_PRAGMA_EOL
&& parser
->in_pragma
)
925 if (token
->type
== CPP_OPEN_BRACE
926 || token
->type
== CPP_OPEN_PAREN
927 || token
->type
== CPP_OPEN_SQUARE
)
929 else if (token
->type
== CPP_CLOSE_BRACE
930 || token
->type
== CPP_CLOSE_PAREN
931 || token
->type
== CPP_CLOSE_SQUARE
)
933 if (nesting_depth
-- == 0)
936 /* Consume this token. */
937 c_parser_consume_token (parser
);
939 parser
->error
= false;
942 /* Expect to be at the end of the pragma directive and consume an
943 end of line marker. */
946 c_parser_skip_to_pragma_eol (c_parser
*parser
)
948 gcc_assert (parser
->in_pragma
);
949 parser
->in_pragma
= false;
951 if (!c_parser_require (parser
, CPP_PRAGMA_EOL
, "expected end of line"))
954 c_token
*token
= c_parser_peek_token (parser
);
955 if (token
->type
== CPP_EOF
)
957 if (token
->type
== CPP_PRAGMA_EOL
)
959 c_parser_consume_token (parser
);
962 c_parser_consume_token (parser
);
965 parser
->error
= false;
968 /* Skip tokens until we have consumed an entire block, or until we
969 have consumed a non-nested ';'. */
972 c_parser_skip_to_end_of_block_or_statement (c_parser
*parser
)
974 unsigned nesting_depth
= 0;
975 bool save_error
= parser
->error
;
981 /* Peek at the next token. */
982 token
= c_parser_peek_token (parser
);
990 if (parser
->in_pragma
)
995 /* If the next token is a ';', we have reached the
996 end of the statement. */
999 /* Consume the ';'. */
1000 c_parser_consume_token (parser
);
1005 case CPP_CLOSE_BRACE
:
1006 /* If the next token is a non-nested '}', then we have
1007 reached the end of the current block. */
1008 if (nesting_depth
== 0 || --nesting_depth
== 0)
1010 c_parser_consume_token (parser
);
1015 case CPP_OPEN_BRACE
:
1016 /* If it the next token is a '{', then we are entering a new
1017 block. Consume the entire block. */
1022 /* If we see a pragma, consume the whole thing at once. We
1023 have some safeguards against consuming pragmas willy-nilly.
1024 Normally, we'd expect to be here with parser->error set,
1025 which disables these safeguards. But it's possible to get
1026 here for secondary error recovery, after parser->error has
1028 c_parser_consume_pragma (parser
);
1029 c_parser_skip_to_pragma_eol (parser
);
1030 parser
->error
= save_error
;
1037 c_parser_consume_token (parser
);
1041 parser
->error
= false;
1044 /* CPP's options (initialized by c-opts.c). */
1045 extern cpp_options
*cpp_opts
;
1047 /* Save the warning flags which are controlled by __extension__. */
1050 disable_extension_diagnostics (void)
1053 | (warn_pointer_arith
<< 1)
1054 | (warn_traditional
<< 2)
1056 | (warn_long_long
<< 4)
1057 | (warn_cxx_compat
<< 5)
1058 | (warn_overlength_strings
<< 6));
1059 cpp_opts
->cpp_pedantic
= pedantic
= 0;
1060 warn_pointer_arith
= 0;
1061 cpp_opts
->cpp_warn_traditional
= warn_traditional
= 0;
1063 cpp_opts
->cpp_warn_long_long
= warn_long_long
= 0;
1064 warn_cxx_compat
= 0;
1065 warn_overlength_strings
= 0;
1069 /* Restore the warning flags which are controlled by __extension__.
1070 FLAGS is the return value from disable_extension_diagnostics. */
1073 restore_extension_diagnostics (int flags
)
1075 cpp_opts
->cpp_pedantic
= pedantic
= flags
& 1;
1076 warn_pointer_arith
= (flags
>> 1) & 1;
1077 cpp_opts
->cpp_warn_traditional
= warn_traditional
= (flags
>> 2) & 1;
1078 flag_iso
= (flags
>> 3) & 1;
1079 cpp_opts
->cpp_warn_long_long
= warn_long_long
= (flags
>> 4) & 1;
1080 warn_cxx_compat
= (flags
>> 5) & 1;
1081 warn_overlength_strings
= (flags
>> 6) & 1;
1084 /* Possibly kinds of declarator to parse. */
1085 typedef enum c_dtr_syn
{
1086 /* A normal declarator with an identifier. */
1088 /* An abstract declarator (maybe empty). */
1090 /* A parameter declarator: may be either, but after a type name does
1091 not redeclare a typedef name as an identifier if it can
1092 alternatively be interpreted as a typedef name; see DR#009,
1093 applied in C90 TC1, omitted from C99 and reapplied in C99 TC2
1094 following DR#249. For example, given a typedef T, "int T" and
1095 "int *T" are valid parameter declarations redeclaring T, while
1096 "int (T)" and "int * (T)" and "int (T[])" and "int (T (int))" are
1097 abstract declarators rather than involving redundant parentheses;
1098 the same applies with attributes inside the parentheses before
1103 /* The binary operation precedence levels, where 0 is a dummy lowest level
1104 used for the bottom of the stack. */
1105 enum c_parser_prec
{
1120 static void c_parser_external_declaration (c_parser
*);
1121 static void c_parser_asm_definition (c_parser
*);
1122 static void c_parser_declaration_or_fndef (c_parser
*, bool, bool, bool,
1123 bool, bool, tree
*, vec
<c_token
>);
1124 static void c_parser_static_assert_declaration_no_semi (c_parser
*);
1125 static void c_parser_static_assert_declaration (c_parser
*);
1126 static void c_parser_declspecs (c_parser
*, struct c_declspecs
*, bool, bool,
1127 bool, bool, enum c_lookahead_kind
);
1128 static struct c_typespec
c_parser_enum_specifier (c_parser
*);
1129 static struct c_typespec
c_parser_struct_or_union_specifier (c_parser
*);
1130 static tree
c_parser_struct_declaration (c_parser
*);
1131 static struct c_typespec
c_parser_typeof_specifier (c_parser
*);
1132 static tree
c_parser_alignas_specifier (c_parser
*);
1133 static struct c_declarator
*c_parser_declarator (c_parser
*, bool, c_dtr_syn
,
1135 static struct c_declarator
*c_parser_direct_declarator (c_parser
*, bool,
1137 static struct c_declarator
*c_parser_direct_declarator_inner (c_parser
*,
1139 struct c_declarator
*);
1140 static struct c_arg_info
*c_parser_parms_declarator (c_parser
*, bool, tree
);
1141 static struct c_arg_info
*c_parser_parms_list_declarator (c_parser
*, tree
,
1143 static struct c_parm
*c_parser_parameter_declaration (c_parser
*, tree
);
1144 static tree
c_parser_simple_asm_expr (c_parser
*);
1145 static tree
c_parser_attributes (c_parser
*);
1146 static struct c_type_name
*c_parser_type_name (c_parser
*);
1147 static struct c_expr
c_parser_initializer (c_parser
*);
1148 static struct c_expr
c_parser_braced_init (c_parser
*, tree
, bool);
1149 static void c_parser_initelt (c_parser
*, struct obstack
*);
1150 static void c_parser_initval (c_parser
*, struct c_expr
*,
1152 static tree
c_parser_compound_statement (c_parser
*);
1153 static void c_parser_compound_statement_nostart (c_parser
*);
1154 static void c_parser_label (c_parser
*);
1155 static void c_parser_statement (c_parser
*);
1156 static void c_parser_statement_after_labels (c_parser
*);
1157 static void c_parser_if_statement (c_parser
*);
1158 static void c_parser_switch_statement (c_parser
*);
1159 static void c_parser_while_statement (c_parser
*);
1160 static void c_parser_do_statement (c_parser
*);
1161 static void c_parser_for_statement (c_parser
*);
1162 static tree
c_parser_asm_statement (c_parser
*);
1163 static tree
c_parser_asm_operands (c_parser
*);
1164 static tree
c_parser_asm_goto_operands (c_parser
*);
1165 static tree
c_parser_asm_clobbers (c_parser
*);
1166 static struct c_expr
c_parser_expr_no_commas (c_parser
*, struct c_expr
*,
1168 static struct c_expr
c_parser_conditional_expression (c_parser
*,
1169 struct c_expr
*, tree
);
1170 static struct c_expr
c_parser_binary_expression (c_parser
*, struct c_expr
*,
1172 static struct c_expr
c_parser_cast_expression (c_parser
*, struct c_expr
*);
1173 static struct c_expr
c_parser_unary_expression (c_parser
*);
1174 static struct c_expr
c_parser_sizeof_expression (c_parser
*);
1175 static struct c_expr
c_parser_alignof_expression (c_parser
*);
1176 static struct c_expr
c_parser_postfix_expression (c_parser
*);
1177 static struct c_expr
c_parser_postfix_expression_after_paren_type (c_parser
*,
1178 struct c_type_name
*,
1180 static struct c_expr
c_parser_postfix_expression_after_primary (c_parser
*,
1183 static tree
c_parser_transaction (c_parser
*, enum rid
);
1184 static struct c_expr
c_parser_transaction_expression (c_parser
*, enum rid
);
1185 static tree
c_parser_transaction_cancel (c_parser
*);
1186 static struct c_expr
c_parser_expression (c_parser
*);
1187 static struct c_expr
c_parser_expression_conv (c_parser
*);
1188 static vec
<tree
, va_gc
> *c_parser_expr_list (c_parser
*, bool, bool,
1189 vec
<tree
, va_gc
> **, location_t
*,
1191 static void c_parser_omp_construct (c_parser
*);
1192 static void c_parser_omp_threadprivate (c_parser
*);
1193 static void c_parser_omp_barrier (c_parser
*);
1194 static void c_parser_omp_flush (c_parser
*);
1195 static void c_parser_omp_taskwait (c_parser
*);
1196 static void c_parser_omp_taskyield (c_parser
*);
1197 static void c_parser_omp_cancel (c_parser
*);
1198 static void c_parser_omp_cancellation_point (c_parser
*);
1200 enum pragma_context
{ pragma_external
, pragma_struct
, pragma_param
,
1201 pragma_stmt
, pragma_compound
};
1202 static bool c_parser_pragma (c_parser
*, enum pragma_context
);
1203 static bool c_parser_omp_target (c_parser
*, enum pragma_context
);
1204 static void c_parser_omp_end_declare_target (c_parser
*);
1205 static void c_parser_omp_declare (c_parser
*, enum pragma_context
);
1207 /* These Objective-C parser functions are only ever called when
1208 compiling Objective-C. */
1209 static void c_parser_objc_class_definition (c_parser
*, tree
);
1210 static void c_parser_objc_class_instance_variables (c_parser
*);
1211 static void c_parser_objc_class_declaration (c_parser
*);
1212 static void c_parser_objc_alias_declaration (c_parser
*);
1213 static void c_parser_objc_protocol_definition (c_parser
*, tree
);
1214 static bool c_parser_objc_method_type (c_parser
*);
1215 static void c_parser_objc_method_definition (c_parser
*);
1216 static void c_parser_objc_methodprotolist (c_parser
*);
1217 static void c_parser_objc_methodproto (c_parser
*);
1218 static tree
c_parser_objc_method_decl (c_parser
*, bool, tree
*, tree
*);
1219 static tree
c_parser_objc_type_name (c_parser
*);
1220 static tree
c_parser_objc_protocol_refs (c_parser
*);
1221 static void c_parser_objc_try_catch_finally_statement (c_parser
*);
1222 static void c_parser_objc_synchronized_statement (c_parser
*);
1223 static tree
c_parser_objc_selector (c_parser
*);
1224 static tree
c_parser_objc_selector_arg (c_parser
*);
1225 static tree
c_parser_objc_receiver (c_parser
*);
1226 static tree
c_parser_objc_message_args (c_parser
*);
1227 static tree
c_parser_objc_keywordexpr (c_parser
*);
1228 static void c_parser_objc_at_property_declaration (c_parser
*);
1229 static void c_parser_objc_at_synthesize_declaration (c_parser
*);
1230 static void c_parser_objc_at_dynamic_declaration (c_parser
*);
1231 static bool c_parser_objc_diagnose_bad_element_prefix
1232 (c_parser
*, struct c_declspecs
*);
1234 static tree
c_parser_array_notation (location_t
, c_parser
*, tree
, tree
);
1236 /* Parse a translation unit (C90 6.7, C99 6.9).
1239 external-declarations
1241 external-declarations:
1242 external-declaration
1243 external-declarations external-declaration
1252 c_parser_translation_unit (c_parser
*parser
)
1254 if (c_parser_next_token_is (parser
, CPP_EOF
))
1256 pedwarn (c_parser_peek_token (parser
)->location
, OPT_Wpedantic
,
1257 "ISO C forbids an empty translation unit");
1261 void *obstack_position
= obstack_alloc (&parser_obstack
, 0);
1262 mark_valid_location_for_stdc_pragma (false);
1266 c_parser_external_declaration (parser
);
1267 obstack_free (&parser_obstack
, obstack_position
);
1269 while (c_parser_next_token_is_not (parser
, CPP_EOF
));
1273 /* Parse an external declaration (C90 6.7, C99 6.9).
1275 external-declaration:
1281 external-declaration:
1284 __extension__ external-declaration
1288 external-declaration:
1289 objc-class-definition
1290 objc-class-declaration
1291 objc-alias-declaration
1292 objc-protocol-definition
1293 objc-method-definition
1298 c_parser_external_declaration (c_parser
*parser
)
1301 switch (c_parser_peek_token (parser
)->type
)
1304 switch (c_parser_peek_token (parser
)->keyword
)
1307 ext
= disable_extension_diagnostics ();
1308 c_parser_consume_token (parser
);
1309 c_parser_external_declaration (parser
);
1310 restore_extension_diagnostics (ext
);
1313 c_parser_asm_definition (parser
);
1315 case RID_AT_INTERFACE
:
1316 case RID_AT_IMPLEMENTATION
:
1317 gcc_assert (c_dialect_objc ());
1318 c_parser_objc_class_definition (parser
, NULL_TREE
);
1321 gcc_assert (c_dialect_objc ());
1322 c_parser_objc_class_declaration (parser
);
1325 gcc_assert (c_dialect_objc ());
1326 c_parser_objc_alias_declaration (parser
);
1328 case RID_AT_PROTOCOL
:
1329 gcc_assert (c_dialect_objc ());
1330 c_parser_objc_protocol_definition (parser
, NULL_TREE
);
1332 case RID_AT_PROPERTY
:
1333 gcc_assert (c_dialect_objc ());
1334 c_parser_objc_at_property_declaration (parser
);
1336 case RID_AT_SYNTHESIZE
:
1337 gcc_assert (c_dialect_objc ());
1338 c_parser_objc_at_synthesize_declaration (parser
);
1340 case RID_AT_DYNAMIC
:
1341 gcc_assert (c_dialect_objc ());
1342 c_parser_objc_at_dynamic_declaration (parser
);
1345 gcc_assert (c_dialect_objc ());
1346 c_parser_consume_token (parser
);
1347 objc_finish_implementation ();
1354 pedwarn (c_parser_peek_token (parser
)->location
, OPT_Wpedantic
,
1355 "ISO C does not allow extra %<;%> outside of a function");
1356 c_parser_consume_token (parser
);
1359 mark_valid_location_for_stdc_pragma (true);
1360 c_parser_pragma (parser
, pragma_external
);
1361 mark_valid_location_for_stdc_pragma (false);
1365 if (c_dialect_objc ())
1367 c_parser_objc_method_definition (parser
);
1370 /* Else fall through, and yield a syntax error trying to parse
1371 as a declaration or function definition. */
1374 /* A declaration or a function definition (or, in Objective-C,
1375 an @interface or @protocol with prefix attributes). We can
1376 only tell which after parsing the declaration specifiers, if
1377 any, and the first declarator. */
1378 c_parser_declaration_or_fndef (parser
, true, true, true, false, true,
1384 static void c_finish_omp_declare_simd (c_parser
*, tree
, tree
, vec
<c_token
>);
1386 /* Parse a declaration or function definition (C90 6.5, 6.7.1, C99
1387 6.7, 6.9.1). If FNDEF_OK is true, a function definition is
1388 accepted; otherwise (old-style parameter declarations) only other
1389 declarations are accepted. If STATIC_ASSERT_OK is true, a static
1390 assertion is accepted; otherwise (old-style parameter declarations)
1391 it is not. If NESTED is true, we are inside a function or parsing
1392 old-style parameter declarations; any functions encountered are
1393 nested functions and declaration specifiers are required; otherwise
1394 we are at top level and functions are normal functions and
1395 declaration specifiers may be optional. If EMPTY_OK is true, empty
1396 declarations are OK (subject to all other constraints); otherwise
1397 (old-style parameter declarations) they are diagnosed. If
1398 START_ATTR_OK is true, the declaration specifiers may start with
1399 attributes; otherwise they may not.
1400 OBJC_FOREACH_OBJECT_DECLARATION can be used to get back the parsed
1401 declaration when parsing an Objective-C foreach statement.
1404 declaration-specifiers init-declarator-list[opt] ;
1405 static_assert-declaration
1407 function-definition:
1408 declaration-specifiers[opt] declarator declaration-list[opt]
1413 declaration-list declaration
1415 init-declarator-list:
1417 init-declarator-list , init-declarator
1420 declarator simple-asm-expr[opt] attributes[opt]
1421 declarator simple-asm-expr[opt] attributes[opt] = initializer
1425 nested-function-definition:
1426 declaration-specifiers declarator declaration-list[opt]
1430 attributes objc-class-definition
1431 attributes objc-category-definition
1432 attributes objc-protocol-definition
1434 The simple-asm-expr and attributes are GNU extensions.
1436 This function does not handle __extension__; that is handled in its
1437 callers. ??? Following the old parser, __extension__ may start
1438 external declarations, declarations in functions and declarations
1439 at the start of "for" loops, but not old-style parameter
1442 C99 requires declaration specifiers in a function definition; the
1443 absence is diagnosed through the diagnosis of implicit int. In GNU
1444 C we also allow but diagnose declarations without declaration
1445 specifiers, but only at top level (elsewhere they conflict with
1448 In Objective-C, declarations of the looping variable in a foreach
1449 statement are exceptionally terminated by 'in' (for example, 'for
1450 (NSObject *object in array) { ... }').
1455 threadprivate-directive */
1458 c_parser_declaration_or_fndef (c_parser
*parser
, bool fndef_ok
,
1459 bool static_assert_ok
, bool empty_ok
,
1460 bool nested
, bool start_attr_ok
,
1461 tree
*objc_foreach_object_declaration
,
1462 vec
<c_token
> omp_declare_simd_clauses
)
1464 struct c_declspecs
*specs
;
1466 tree all_prefix_attrs
;
1467 bool diagnosed_no_specs
= false;
1468 location_t here
= c_parser_peek_token (parser
)->location
;
1470 if (static_assert_ok
1471 && c_parser_next_token_is_keyword (parser
, RID_STATIC_ASSERT
))
1473 c_parser_static_assert_declaration (parser
);
1476 specs
= build_null_declspecs ();
1478 /* Try to detect an unknown type name when we have "A B" or "A *B". */
1479 if (c_parser_peek_token (parser
)->type
== CPP_NAME
1480 && c_parser_peek_token (parser
)->id_kind
== C_ID_ID
1481 && (c_parser_peek_2nd_token (parser
)->type
== CPP_NAME
1482 || c_parser_peek_2nd_token (parser
)->type
== CPP_MULT
)
1483 && (!nested
|| !lookup_name (c_parser_peek_token (parser
)->value
)))
1485 error_at (here
, "unknown type name %qE",
1486 c_parser_peek_token (parser
)->value
);
1488 /* Parse declspecs normally to get a correct pointer type, but avoid
1489 a further "fails to be a type name" error. Refuse nested functions
1490 since it is not how the user likely wants us to recover. */
1491 c_parser_peek_token (parser
)->type
= CPP_KEYWORD
;
1492 c_parser_peek_token (parser
)->keyword
= RID_VOID
;
1493 c_parser_peek_token (parser
)->value
= error_mark_node
;
1497 c_parser_declspecs (parser
, specs
, true, true, start_attr_ok
,
1498 true, cla_nonabstract_decl
);
1501 c_parser_skip_to_end_of_block_or_statement (parser
);
1504 if (nested
&& !specs
->declspecs_seen_p
)
1506 c_parser_error (parser
, "expected declaration specifiers");
1507 c_parser_skip_to_end_of_block_or_statement (parser
);
1510 finish_declspecs (specs
);
1511 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
1517 shadow_tag_warned (specs
, 1);
1518 pedwarn (here
, 0, "empty declaration");
1520 c_parser_consume_token (parser
);
1524 /* Provide better error recovery. Note that a type name here is usually
1525 better diagnosed as a redeclaration. */
1527 && specs
->typespec_kind
== ctsk_tagdef
1528 && c_parser_next_token_starts_declspecs (parser
)
1529 && !c_parser_next_token_is (parser
, CPP_NAME
))
1531 c_parser_error (parser
, "expected %<;%>, identifier or %<(%>");
1532 parser
->error
= false;
1533 shadow_tag_warned (specs
, 1);
1536 else if (c_dialect_objc ())
1538 /* Prefix attributes are an error on method decls. */
1539 switch (c_parser_peek_token (parser
)->type
)
1543 if (c_parser_objc_diagnose_bad_element_prefix (parser
, specs
))
1547 warning_at (c_parser_peek_token (parser
)->location
,
1549 "prefix attributes are ignored for methods");
1550 specs
->attrs
= NULL_TREE
;
1553 c_parser_objc_method_definition (parser
);
1555 c_parser_objc_methodproto (parser
);
1561 /* This is where we parse 'attributes @interface ...',
1562 'attributes @implementation ...', 'attributes @protocol ...'
1563 (where attributes could be, for example, __attribute__
1566 switch (c_parser_peek_token (parser
)->keyword
)
1568 case RID_AT_INTERFACE
:
1570 if (c_parser_objc_diagnose_bad_element_prefix (parser
, specs
))
1572 c_parser_objc_class_definition (parser
, specs
->attrs
);
1576 case RID_AT_IMPLEMENTATION
:
1578 if (c_parser_objc_diagnose_bad_element_prefix (parser
, specs
))
1582 warning_at (c_parser_peek_token (parser
)->location
,
1584 "prefix attributes are ignored for implementations");
1585 specs
->attrs
= NULL_TREE
;
1587 c_parser_objc_class_definition (parser
, NULL_TREE
);
1591 case RID_AT_PROTOCOL
:
1593 if (c_parser_objc_diagnose_bad_element_prefix (parser
, specs
))
1595 c_parser_objc_protocol_definition (parser
, specs
->attrs
);
1602 case RID_AT_PROPERTY
:
1605 c_parser_error (parser
, "unexpected attribute");
1606 specs
->attrs
= NULL
;
1614 pending_xref_error ();
1615 prefix_attrs
= specs
->attrs
;
1616 all_prefix_attrs
= prefix_attrs
;
1617 specs
->attrs
= NULL_TREE
;
1620 struct c_declarator
*declarator
;
1624 /* Declaring either one or more declarators (in which case we
1625 should diagnose if there were no declaration specifiers) or a
1626 function definition (in which case the diagnostic for
1627 implicit int suffices). */
1628 declarator
= c_parser_declarator (parser
,
1629 specs
->typespec_kind
!= ctsk_none
,
1630 C_DTR_NORMAL
, &dummy
);
1631 if (declarator
== NULL
)
1633 if (omp_declare_simd_clauses
.exists ())
1634 c_finish_omp_declare_simd (parser
, NULL_TREE
, NULL_TREE
,
1635 omp_declare_simd_clauses
);
1636 c_parser_skip_to_end_of_block_or_statement (parser
);
1639 if (c_parser_next_token_is (parser
, CPP_EQ
)
1640 || c_parser_next_token_is (parser
, CPP_COMMA
)
1641 || c_parser_next_token_is (parser
, CPP_SEMICOLON
)
1642 || c_parser_next_token_is_keyword (parser
, RID_ASM
)
1643 || c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
)
1644 || c_parser_next_token_is_keyword (parser
, RID_IN
))
1646 tree asm_name
= NULL_TREE
;
1647 tree postfix_attrs
= NULL_TREE
;
1648 if (!diagnosed_no_specs
&& !specs
->declspecs_seen_p
)
1650 diagnosed_no_specs
= true;
1651 pedwarn (here
, 0, "data definition has no type or storage class");
1653 /* Having seen a data definition, there cannot now be a
1654 function definition. */
1656 if (c_parser_next_token_is_keyword (parser
, RID_ASM
))
1657 asm_name
= c_parser_simple_asm_expr (parser
);
1658 if (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
1659 postfix_attrs
= c_parser_attributes (parser
);
1660 if (c_parser_next_token_is (parser
, CPP_EQ
))
1664 location_t init_loc
;
1665 c_parser_consume_token (parser
);
1666 /* The declaration of the variable is in effect while
1667 its initializer is parsed. */
1668 d
= start_decl (declarator
, specs
, true,
1669 chainon (postfix_attrs
, all_prefix_attrs
));
1671 d
= error_mark_node
;
1672 if (omp_declare_simd_clauses
.exists ())
1673 c_finish_omp_declare_simd (parser
, d
, NULL_TREE
,
1674 omp_declare_simd_clauses
);
1675 start_init (d
, asm_name
, global_bindings_p ());
1676 init_loc
= c_parser_peek_token (parser
)->location
;
1677 init
= c_parser_initializer (parser
);
1679 if (d
!= error_mark_node
)
1681 maybe_warn_string_init (TREE_TYPE (d
), init
);
1682 finish_decl (d
, init_loc
, init
.value
,
1683 init
.original_type
, asm_name
);
1688 tree d
= start_decl (declarator
, specs
, false,
1689 chainon (postfix_attrs
,
1691 if (omp_declare_simd_clauses
.exists ())
1693 tree parms
= NULL_TREE
;
1694 if (d
&& TREE_CODE (d
) == FUNCTION_DECL
)
1696 struct c_declarator
*ce
= declarator
;
1698 if (ce
->kind
== cdk_function
)
1700 parms
= ce
->u
.arg_info
->parms
;
1704 ce
= ce
->declarator
;
1707 temp_store_parm_decls (d
, parms
);
1708 c_finish_omp_declare_simd (parser
, d
, parms
,
1709 omp_declare_simd_clauses
);
1711 temp_pop_parm_decls ();
1714 finish_decl (d
, UNKNOWN_LOCATION
, NULL_TREE
,
1715 NULL_TREE
, asm_name
);
1717 if (c_parser_next_token_is_keyword (parser
, RID_IN
))
1720 *objc_foreach_object_declaration
= d
;
1722 *objc_foreach_object_declaration
= error_mark_node
;
1725 if (c_parser_next_token_is (parser
, CPP_COMMA
))
1727 c_parser_consume_token (parser
);
1728 if (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
1729 all_prefix_attrs
= chainon (c_parser_attributes (parser
),
1732 all_prefix_attrs
= prefix_attrs
;
1735 else if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
1737 c_parser_consume_token (parser
);
1740 else if (c_parser_next_token_is_keyword (parser
, RID_IN
))
1742 /* This can only happen in Objective-C: we found the
1743 'in' that terminates the declaration inside an
1744 Objective-C foreach statement. Do not consume the
1745 token, so that the caller can use it to determine
1746 that this indeed is a foreach context. */
1751 c_parser_error (parser
, "expected %<,%> or %<;%>");
1752 c_parser_skip_to_end_of_block_or_statement (parser
);
1758 c_parser_error (parser
, "expected %<=%>, %<,%>, %<;%>, "
1759 "%<asm%> or %<__attribute__%>");
1760 c_parser_skip_to_end_of_block_or_statement (parser
);
1763 /* Function definition (nested or otherwise). */
1766 pedwarn (here
, OPT_Wpedantic
, "ISO C forbids nested functions");
1767 c_push_function_context ();
1769 if (!start_function (specs
, declarator
, all_prefix_attrs
))
1771 /* This can appear in many cases looking nothing like a
1772 function definition, so we don't give a more specific
1773 error suggesting there was one. */
1774 c_parser_error (parser
, "expected %<=%>, %<,%>, %<;%>, %<asm%> "
1775 "or %<__attribute__%>");
1777 c_pop_function_context ();
1781 if (DECL_DECLARED_INLINE_P (current_function_decl
))
1782 tv
= TV_PARSE_INLINE
;
1787 /* Parse old-style parameter declarations. ??? Attributes are
1788 not allowed to start declaration specifiers here because of a
1789 syntax conflict between a function declaration with attribute
1790 suffix and a function definition with an attribute prefix on
1791 first old-style parameter declaration. Following the old
1792 parser, they are not accepted on subsequent old-style
1793 parameter declarations either. However, there is no
1794 ambiguity after the first declaration, nor indeed on the
1795 first as long as we don't allow postfix attributes after a
1796 declarator with a nonempty identifier list in a definition;
1797 and postfix attributes have never been accepted here in
1798 function definitions either. */
1799 while (c_parser_next_token_is_not (parser
, CPP_EOF
)
1800 && c_parser_next_token_is_not (parser
, CPP_OPEN_BRACE
))
1801 c_parser_declaration_or_fndef (parser
, false, false, false,
1802 true, false, NULL
, vNULL
);
1803 store_parm_decls ();
1804 if (omp_declare_simd_clauses
.exists ())
1805 c_finish_omp_declare_simd (parser
, current_function_decl
, NULL_TREE
,
1806 omp_declare_simd_clauses
);
1807 DECL_STRUCT_FUNCTION (current_function_decl
)->function_start_locus
1808 = c_parser_peek_token (parser
)->location
;
1809 fnbody
= c_parser_compound_statement (parser
);
1810 if (flag_enable_cilkplus
&& contains_array_notation_expr (fnbody
))
1811 fnbody
= expand_array_notation_exprs (fnbody
);
1814 tree decl
= current_function_decl
;
1815 /* Mark nested functions as needing static-chain initially.
1816 lower_nested_functions will recompute it but the
1817 DECL_STATIC_CHAIN flag is also used before that happens,
1818 by initializer_constant_valid_p. See gcc.dg/nested-fn-2.c. */
1819 DECL_STATIC_CHAIN (decl
) = 1;
1822 c_pop_function_context ();
1823 add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl
), DECL_EXPR
, decl
));
1836 /* Parse an asm-definition (asm() outside a function body). This is a
1844 c_parser_asm_definition (c_parser
*parser
)
1846 tree asm_str
= c_parser_simple_asm_expr (parser
);
1848 add_asm_node (asm_str
);
1849 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
1852 /* Parse a static assertion (C11 6.7.10).
1854 static_assert-declaration:
1855 static_assert-declaration-no-semi ;
1859 c_parser_static_assert_declaration (c_parser
*parser
)
1861 c_parser_static_assert_declaration_no_semi (parser
);
1863 || !c_parser_require (parser
, CPP_SEMICOLON
, "expected %<;%>"))
1864 c_parser_skip_to_end_of_block_or_statement (parser
);
1867 /* Parse a static assertion (C11 6.7.10), without the trailing
1870 static_assert-declaration-no-semi:
1871 _Static_assert ( constant-expression , string-literal )
1875 c_parser_static_assert_declaration_no_semi (c_parser
*parser
)
1877 location_t assert_loc
, value_loc
;
1881 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_STATIC_ASSERT
));
1882 assert_loc
= c_parser_peek_token (parser
)->location
;
1886 pedwarn (assert_loc
, OPT_Wpedantic
,
1887 "ISO C99 does not support %<_Static_assert%>");
1889 pedwarn (assert_loc
, OPT_Wpedantic
,
1890 "ISO C90 does not support %<_Static_assert%>");
1892 c_parser_consume_token (parser
);
1893 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1895 value_loc
= c_parser_peek_token (parser
)->location
;
1896 value
= c_parser_expr_no_commas (parser
, NULL
).value
;
1897 parser
->lex_untranslated_string
= true;
1898 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
1900 parser
->lex_untranslated_string
= false;
1903 switch (c_parser_peek_token (parser
)->type
)
1909 case CPP_UTF8STRING
:
1910 string
= c_parser_peek_token (parser
)->value
;
1911 c_parser_consume_token (parser
);
1912 parser
->lex_untranslated_string
= false;
1915 c_parser_error (parser
, "expected string literal");
1916 parser
->lex_untranslated_string
= false;
1919 c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
1921 if (!INTEGRAL_TYPE_P (TREE_TYPE (value
)))
1923 error_at (value_loc
, "expression in static assertion is not an integer");
1926 if (TREE_CODE (value
) != INTEGER_CST
)
1928 value
= c_fully_fold (value
, false, NULL
);
1929 if (TREE_CODE (value
) == INTEGER_CST
)
1930 pedwarn (value_loc
, OPT_Wpedantic
, "expression in static assertion "
1931 "is not an integer constant expression");
1933 if (TREE_CODE (value
) != INTEGER_CST
)
1935 error_at (value_loc
, "expression in static assertion is not constant");
1938 constant_expression_warning (value
);
1939 if (integer_zerop (value
))
1940 error_at (assert_loc
, "static assertion failed: %E", string
);
1943 /* Parse some declaration specifiers (possibly none) (C90 6.5, C99
1944 6.7), adding them to SPECS (which may already include some).
1945 Storage class specifiers are accepted iff SCSPEC_OK; type
1946 specifiers are accepted iff TYPESPEC_OK; alignment specifiers are
1947 accepted iff ALIGNSPEC_OK; attributes are accepted at the start
1950 declaration-specifiers:
1951 storage-class-specifier declaration-specifiers[opt]
1952 type-specifier declaration-specifiers[opt]
1953 type-qualifier declaration-specifiers[opt]
1954 function-specifier declaration-specifiers[opt]
1955 alignment-specifier declaration-specifiers[opt]
1957 Function specifiers (inline) are from C99, and are currently
1958 handled as storage class specifiers, as is __thread. Alignment
1959 specifiers are from C11.
1961 C90 6.5.1, C99 6.7.1:
1962 storage-class-specifier:
1974 (_Noreturn is new in C11.)
1976 C90 6.5.2, C99 6.7.2:
1989 [_Imaginary removed in C99 TC2]
1990 struct-or-union-specifier
1994 (_Bool and _Complex are new in C99.)
1996 C90 6.5.3, C99 6.7.3:
2002 address-space-qualifier
2004 (restrict is new in C99.)
2008 declaration-specifiers:
2009 attributes declaration-specifiers[opt]
2015 identifier recognized by the target
2017 storage-class-specifier:
2030 (_Fract, _Accum, and _Sat are new from ISO/IEC DTR 18037:
2031 http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1169.pdf)
2036 class-name objc-protocol-refs[opt]
2037 typedef-name objc-protocol-refs
2042 c_parser_declspecs (c_parser
*parser
, struct c_declspecs
*specs
,
2043 bool scspec_ok
, bool typespec_ok
, bool start_attr_ok
,
2044 bool alignspec_ok
, enum c_lookahead_kind la
)
2046 bool attrs_ok
= start_attr_ok
;
2047 bool seen_type
= specs
->typespec_kind
!= ctsk_none
;
2050 gcc_assert (la
== cla_prefer_id
);
2052 while (c_parser_next_token_is (parser
, CPP_NAME
)
2053 || c_parser_next_token_is (parser
, CPP_KEYWORD
)
2054 || (c_dialect_objc () && c_parser_next_token_is (parser
, CPP_LESS
)))
2056 struct c_typespec t
;
2059 location_t loc
= c_parser_peek_token (parser
)->location
;
2061 /* If we cannot accept a type, exit if the next token must start
2062 one. Also, if we already have seen a tagged definition,
2063 a typename would be an error anyway and likely the user
2064 has simply forgotten a semicolon, so we exit. */
2065 if ((!typespec_ok
|| specs
->typespec_kind
== ctsk_tagdef
)
2066 && c_parser_next_tokens_start_typename (parser
, la
)
2067 && !c_parser_next_token_is_qualifier (parser
))
2070 if (c_parser_next_token_is (parser
, CPP_NAME
))
2072 c_token
*name_token
= c_parser_peek_token (parser
);
2073 tree value
= name_token
->value
;
2074 c_id_kind kind
= name_token
->id_kind
;
2076 if (kind
== C_ID_ADDRSPACE
)
2079 = name_token
->keyword
- RID_FIRST_ADDR_SPACE
;
2080 declspecs_add_addrspace (name_token
->location
, specs
, as
);
2081 c_parser_consume_token (parser
);
2086 gcc_assert (!c_parser_next_token_is_qualifier (parser
));
2088 /* If we cannot accept a type, and the next token must start one,
2089 exit. Do the same if we already have seen a tagged definition,
2090 since it would be an error anyway and likely the user has simply
2091 forgotten a semicolon. */
2092 if (seen_type
|| !c_parser_next_tokens_start_typename (parser
, la
))
2095 /* Now at an unknown typename (C_ID_ID), a C_ID_TYPENAME or
2096 a C_ID_CLASSNAME. */
2097 c_parser_consume_token (parser
);
2100 if (kind
== C_ID_ID
)
2102 error ("unknown type name %qE", value
);
2103 t
.kind
= ctsk_typedef
;
2104 t
.spec
= error_mark_node
;
2106 else if (kind
== C_ID_TYPENAME
2107 && (!c_dialect_objc ()
2108 || c_parser_next_token_is_not (parser
, CPP_LESS
)))
2110 t
.kind
= ctsk_typedef
;
2111 /* For a typedef name, record the meaning, not the name.
2112 In case of 'foo foo, bar;'. */
2113 t
.spec
= lookup_name (value
);
2117 tree proto
= NULL_TREE
;
2118 gcc_assert (c_dialect_objc ());
2120 if (c_parser_next_token_is (parser
, CPP_LESS
))
2121 proto
= c_parser_objc_protocol_refs (parser
);
2122 t
.spec
= objc_get_protocol_qualified_type (value
, proto
);
2125 t
.expr_const_operands
= true;
2126 declspecs_add_type (name_token
->location
, specs
, t
);
2129 if (c_parser_next_token_is (parser
, CPP_LESS
))
2131 /* Make "<SomeProtocol>" equivalent to "id <SomeProtocol>" -
2132 nisse@lysator.liu.se. */
2134 gcc_assert (c_dialect_objc ());
2135 if (!typespec_ok
|| seen_type
)
2137 proto
= c_parser_objc_protocol_refs (parser
);
2139 t
.spec
= objc_get_protocol_qualified_type (NULL_TREE
, proto
);
2141 t
.expr_const_operands
= true;
2142 declspecs_add_type (loc
, specs
, t
);
2145 gcc_assert (c_parser_next_token_is (parser
, CPP_KEYWORD
));
2146 switch (c_parser_peek_token (parser
)->keyword
)
2159 /* TODO: Distinguish between function specifiers (inline, noreturn)
2160 and storage class specifiers, either here or in
2161 declspecs_add_scspec. */
2162 declspecs_add_scspec (loc
, specs
,
2163 c_parser_peek_token (parser
)->value
);
2164 c_parser_consume_token (parser
);
2188 if (c_dialect_objc ())
2189 parser
->objc_need_raw_identifier
= true;
2190 t
.kind
= ctsk_resword
;
2191 t
.spec
= c_parser_peek_token (parser
)->value
;
2193 t
.expr_const_operands
= true;
2194 declspecs_add_type (loc
, specs
, t
);
2195 c_parser_consume_token (parser
);
2202 t
= c_parser_enum_specifier (parser
);
2203 declspecs_add_type (loc
, specs
, t
);
2211 t
= c_parser_struct_or_union_specifier (parser
);
2212 invoke_plugin_callbacks (PLUGIN_FINISH_TYPE
, t
.spec
);
2213 declspecs_add_type (loc
, specs
, t
);
2216 /* ??? The old parser rejected typeof after other type
2217 specifiers, but is a syntax error the best way of
2219 if (!typespec_ok
|| seen_type
)
2223 t
= c_parser_typeof_specifier (parser
);
2224 declspecs_add_type (loc
, specs
, t
);
2230 declspecs_add_qual (loc
, specs
, c_parser_peek_token (parser
)->value
);
2231 c_parser_consume_token (parser
);
2236 attrs
= c_parser_attributes (parser
);
2237 declspecs_add_attrs (loc
, specs
, attrs
);
2242 align
= c_parser_alignas_specifier (parser
);
2243 declspecs_add_alignas (loc
, specs
, align
);
2252 /* Parse an enum specifier (C90 6.5.2.2, C99 6.7.2.2).
2255 enum attributes[opt] identifier[opt] { enumerator-list } attributes[opt]
2256 enum attributes[opt] identifier[opt] { enumerator-list , } attributes[opt]
2257 enum attributes[opt] identifier
2259 The form with trailing comma is new in C99. The forms with
2260 attributes are GNU extensions. In GNU C, we accept any expression
2261 without commas in the syntax (assignment expressions, not just
2262 conditional expressions); assignment expressions will be diagnosed
2267 enumerator-list , enumerator
2270 enumeration-constant
2271 enumeration-constant = constant-expression
2274 static struct c_typespec
2275 c_parser_enum_specifier (c_parser
*parser
)
2277 struct c_typespec ret
;
2279 tree ident
= NULL_TREE
;
2280 location_t enum_loc
;
2281 location_t ident_loc
= UNKNOWN_LOCATION
; /* Quiet warning. */
2282 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_ENUM
));
2283 enum_loc
= c_parser_peek_token (parser
)->location
;
2284 c_parser_consume_token (parser
);
2285 attrs
= c_parser_attributes (parser
);
2286 enum_loc
= c_parser_peek_token (parser
)->location
;
2287 /* Set the location in case we create a decl now. */
2288 c_parser_set_source_position_from_token (c_parser_peek_token (parser
));
2289 if (c_parser_next_token_is (parser
, CPP_NAME
))
2291 ident
= c_parser_peek_token (parser
)->value
;
2292 ident_loc
= c_parser_peek_token (parser
)->location
;
2293 enum_loc
= ident_loc
;
2294 c_parser_consume_token (parser
);
2296 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
2298 /* Parse an enum definition. */
2299 struct c_enum_contents the_enum
;
2302 /* We chain the enumerators in reverse order, then put them in
2303 forward order at the end. */
2305 timevar_push (TV_PARSE_ENUM
);
2306 type
= start_enum (enum_loc
, &the_enum
, ident
);
2308 c_parser_consume_token (parser
);
2316 location_t comma_loc
= UNKNOWN_LOCATION
; /* Quiet warning. */
2317 location_t decl_loc
, value_loc
;
2318 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
2320 c_parser_error (parser
, "expected identifier");
2321 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
, NULL
);
2322 values
= error_mark_node
;
2325 token
= c_parser_peek_token (parser
);
2326 enum_id
= token
->value
;
2327 /* Set the location in case we create a decl now. */
2328 c_parser_set_source_position_from_token (token
);
2329 decl_loc
= value_loc
= token
->location
;
2330 c_parser_consume_token (parser
);
2331 if (c_parser_next_token_is (parser
, CPP_EQ
))
2333 c_parser_consume_token (parser
);
2334 value_loc
= c_parser_peek_token (parser
)->location
;
2335 enum_value
= c_parser_expr_no_commas (parser
, NULL
).value
;
2338 enum_value
= NULL_TREE
;
2339 enum_decl
= build_enumerator (decl_loc
, value_loc
,
2340 &the_enum
, enum_id
, enum_value
);
2341 TREE_CHAIN (enum_decl
) = values
;
2344 if (c_parser_next_token_is (parser
, CPP_COMMA
))
2346 comma_loc
= c_parser_peek_token (parser
)->location
;
2348 c_parser_consume_token (parser
);
2350 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
2352 if (seen_comma
&& !flag_isoc99
)
2353 pedwarn (comma_loc
, OPT_Wpedantic
, "comma at end of enumerator list");
2354 c_parser_consume_token (parser
);
2359 c_parser_error (parser
, "expected %<,%> or %<}%>");
2360 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
, NULL
);
2361 values
= error_mark_node
;
2365 postfix_attrs
= c_parser_attributes (parser
);
2366 ret
.spec
= finish_enum (type
, nreverse (values
),
2367 chainon (attrs
, postfix_attrs
));
2368 ret
.kind
= ctsk_tagdef
;
2369 ret
.expr
= NULL_TREE
;
2370 ret
.expr_const_operands
= true;
2371 timevar_pop (TV_PARSE_ENUM
);
2376 c_parser_error (parser
, "expected %<{%>");
2377 ret
.spec
= error_mark_node
;
2378 ret
.kind
= ctsk_tagref
;
2379 ret
.expr
= NULL_TREE
;
2380 ret
.expr_const_operands
= true;
2383 ret
= parser_xref_tag (ident_loc
, ENUMERAL_TYPE
, ident
);
2384 /* In ISO C, enumerated types can be referred to only if already
2386 if (pedantic
&& !COMPLETE_TYPE_P (ret
.spec
))
2389 pedwarn (enum_loc
, OPT_Wpedantic
,
2390 "ISO C forbids forward references to %<enum%> types");
2395 /* Parse a struct or union specifier (C90 6.5.2.1, C99 6.7.2.1).
2397 struct-or-union-specifier:
2398 struct-or-union attributes[opt] identifier[opt]
2399 { struct-contents } attributes[opt]
2400 struct-or-union attributes[opt] identifier
2403 struct-declaration-list
2405 struct-declaration-list:
2406 struct-declaration ;
2407 struct-declaration-list struct-declaration ;
2414 struct-declaration-list struct-declaration
2416 struct-declaration-list:
2417 struct-declaration-list ;
2420 (Note that in the syntax here, unlike that in ISO C, the semicolons
2421 are included here rather than in struct-declaration, in order to
2422 describe the syntax with extra semicolons and missing semicolon at
2427 struct-declaration-list:
2428 @defs ( class-name )
2430 (Note this does not include a trailing semicolon, but can be
2431 followed by further declarations, and gets a pedwarn-if-pedantic
2432 when followed by a semicolon.) */
2434 static struct c_typespec
2435 c_parser_struct_or_union_specifier (c_parser
*parser
)
2437 struct c_typespec ret
;
2439 tree ident
= NULL_TREE
;
2440 location_t struct_loc
;
2441 location_t ident_loc
= UNKNOWN_LOCATION
;
2442 enum tree_code code
;
2443 switch (c_parser_peek_token (parser
)->keyword
)
2454 struct_loc
= c_parser_peek_token (parser
)->location
;
2455 c_parser_consume_token (parser
);
2456 attrs
= c_parser_attributes (parser
);
2458 /* Set the location in case we create a decl now. */
2459 c_parser_set_source_position_from_token (c_parser_peek_token (parser
));
2461 if (c_parser_next_token_is (parser
, CPP_NAME
))
2463 ident
= c_parser_peek_token (parser
)->value
;
2464 ident_loc
= c_parser_peek_token (parser
)->location
;
2465 struct_loc
= ident_loc
;
2466 c_parser_consume_token (parser
);
2468 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
2470 /* Parse a struct or union definition. Start the scope of the
2471 tag before parsing components. */
2472 struct c_struct_parse_info
*struct_info
;
2473 tree type
= start_struct (struct_loc
, code
, ident
, &struct_info
);
2475 /* We chain the components in reverse order, then put them in
2476 forward order at the end. Each struct-declaration may
2477 declare multiple components (comma-separated), so we must use
2478 chainon to join them, although when parsing each
2479 struct-declaration we can use TREE_CHAIN directly.
2481 The theory behind all this is that there will be more
2482 semicolon separated fields than comma separated fields, and
2483 so we'll be minimizing the number of node traversals required
2486 timevar_push (TV_PARSE_STRUCT
);
2487 contents
= NULL_TREE
;
2488 c_parser_consume_token (parser
);
2489 /* Handle the Objective-C @defs construct,
2490 e.g. foo(sizeof(struct{ @defs(ClassName) }));. */
2491 if (c_parser_next_token_is_keyword (parser
, RID_AT_DEFS
))
2494 gcc_assert (c_dialect_objc ());
2495 c_parser_consume_token (parser
);
2496 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
2498 if (c_parser_next_token_is (parser
, CPP_NAME
)
2499 && c_parser_peek_token (parser
)->id_kind
== C_ID_CLASSNAME
)
2501 name
= c_parser_peek_token (parser
)->value
;
2502 c_parser_consume_token (parser
);
2506 c_parser_error (parser
, "expected class name");
2507 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
2510 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
2512 contents
= nreverse (objc_get_class_ivars (name
));
2515 /* Parse the struct-declarations and semicolons. Problems with
2516 semicolons are diagnosed here; empty structures are diagnosed
2521 /* Parse any stray semicolon. */
2522 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
2524 pedwarn (c_parser_peek_token (parser
)->location
, OPT_Wpedantic
,
2525 "extra semicolon in struct or union specified");
2526 c_parser_consume_token (parser
);
2529 /* Stop if at the end of the struct or union contents. */
2530 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
2532 c_parser_consume_token (parser
);
2535 /* Accept #pragmas at struct scope. */
2536 if (c_parser_next_token_is (parser
, CPP_PRAGMA
))
2538 c_parser_pragma (parser
, pragma_struct
);
2541 /* Parse some comma-separated declarations, but not the
2542 trailing semicolon if any. */
2543 decls
= c_parser_struct_declaration (parser
);
2544 contents
= chainon (decls
, contents
);
2545 /* If no semicolon follows, either we have a parse error or
2546 are at the end of the struct or union and should
2548 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
2549 c_parser_consume_token (parser
);
2552 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
2553 pedwarn (c_parser_peek_token (parser
)->location
, 0,
2554 "no semicolon at end of struct or union");
2555 else if (parser
->error
2556 || !c_parser_next_token_starts_declspecs (parser
))
2558 c_parser_error (parser
, "expected %<;%>");
2559 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
, NULL
);
2563 /* If we come here, we have already emitted an error
2564 for an expected `;', identifier or `(', and we also
2565 recovered already. Go on with the next field. */
2568 postfix_attrs
= c_parser_attributes (parser
);
2569 ret
.spec
= finish_struct (struct_loc
, type
, nreverse (contents
),
2570 chainon (attrs
, postfix_attrs
), struct_info
);
2571 ret
.kind
= ctsk_tagdef
;
2572 ret
.expr
= NULL_TREE
;
2573 ret
.expr_const_operands
= true;
2574 timevar_pop (TV_PARSE_STRUCT
);
2579 c_parser_error (parser
, "expected %<{%>");
2580 ret
.spec
= error_mark_node
;
2581 ret
.kind
= ctsk_tagref
;
2582 ret
.expr
= NULL_TREE
;
2583 ret
.expr_const_operands
= true;
2586 ret
= parser_xref_tag (ident_loc
, code
, ident
);
2590 /* Parse a struct-declaration (C90 6.5.2.1, C99 6.7.2.1), *without*
2591 the trailing semicolon.
2594 specifier-qualifier-list struct-declarator-list
2595 static_assert-declaration-no-semi
2597 specifier-qualifier-list:
2598 type-specifier specifier-qualifier-list[opt]
2599 type-qualifier specifier-qualifier-list[opt]
2600 attributes specifier-qualifier-list[opt]
2602 struct-declarator-list:
2604 struct-declarator-list , attributes[opt] struct-declarator
2607 declarator attributes[opt]
2608 declarator[opt] : constant-expression attributes[opt]
2613 __extension__ struct-declaration
2614 specifier-qualifier-list
2616 Unlike the ISO C syntax, semicolons are handled elsewhere. The use
2617 of attributes where shown is a GNU extension. In GNU C, we accept
2618 any expression without commas in the syntax (assignment
2619 expressions, not just conditional expressions); assignment
2620 expressions will be diagnosed as non-constant. */
2623 c_parser_struct_declaration (c_parser
*parser
)
2625 struct c_declspecs
*specs
;
2627 tree all_prefix_attrs
;
2629 location_t decl_loc
;
2630 if (c_parser_next_token_is_keyword (parser
, RID_EXTENSION
))
2634 ext
= disable_extension_diagnostics ();
2635 c_parser_consume_token (parser
);
2636 decl
= c_parser_struct_declaration (parser
);
2637 restore_extension_diagnostics (ext
);
2640 if (c_parser_next_token_is_keyword (parser
, RID_STATIC_ASSERT
))
2642 c_parser_static_assert_declaration_no_semi (parser
);
2645 specs
= build_null_declspecs ();
2646 decl_loc
= c_parser_peek_token (parser
)->location
;
2647 c_parser_declspecs (parser
, specs
, false, true, true,
2648 true, cla_nonabstract_decl
);
2651 if (!specs
->declspecs_seen_p
)
2653 c_parser_error (parser
, "expected specifier-qualifier-list");
2656 finish_declspecs (specs
);
2657 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
)
2658 || c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
2661 if (specs
->typespec_kind
== ctsk_none
)
2663 pedwarn (decl_loc
, OPT_Wpedantic
,
2664 "ISO C forbids member declarations with no members");
2665 shadow_tag_warned (specs
, pedantic
);
2670 /* Support for unnamed structs or unions as members of
2671 structs or unions (which is [a] useful and [b] supports
2675 ret
= grokfield (c_parser_peek_token (parser
)->location
,
2676 build_id_declarator (NULL_TREE
), specs
,
2679 decl_attributes (&ret
, attrs
, 0);
2684 /* Provide better error recovery. Note that a type name here is valid,
2685 and will be treated as a field name. */
2686 if (specs
->typespec_kind
== ctsk_tagdef
2687 && TREE_CODE (specs
->type
) != ENUMERAL_TYPE
2688 && c_parser_next_token_starts_declspecs (parser
)
2689 && !c_parser_next_token_is (parser
, CPP_NAME
))
2691 c_parser_error (parser
, "expected %<;%>, identifier or %<(%>");
2692 parser
->error
= false;
2696 pending_xref_error ();
2697 prefix_attrs
= specs
->attrs
;
2698 all_prefix_attrs
= prefix_attrs
;
2699 specs
->attrs
= NULL_TREE
;
2703 /* Declaring one or more declarators or un-named bit-fields. */
2704 struct c_declarator
*declarator
;
2706 if (c_parser_next_token_is (parser
, CPP_COLON
))
2707 declarator
= build_id_declarator (NULL_TREE
);
2709 declarator
= c_parser_declarator (parser
,
2710 specs
->typespec_kind
!= ctsk_none
,
2711 C_DTR_NORMAL
, &dummy
);
2712 if (declarator
== NULL
)
2714 c_parser_skip_to_end_of_block_or_statement (parser
);
2717 if (c_parser_next_token_is (parser
, CPP_COLON
)
2718 || c_parser_next_token_is (parser
, CPP_COMMA
)
2719 || c_parser_next_token_is (parser
, CPP_SEMICOLON
)
2720 || c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
)
2721 || c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
2723 tree postfix_attrs
= NULL_TREE
;
2724 tree width
= NULL_TREE
;
2726 if (c_parser_next_token_is (parser
, CPP_COLON
))
2728 c_parser_consume_token (parser
);
2729 width
= c_parser_expr_no_commas (parser
, NULL
).value
;
2731 if (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
2732 postfix_attrs
= c_parser_attributes (parser
);
2733 d
= grokfield (c_parser_peek_token (parser
)->location
,
2734 declarator
, specs
, width
, &all_prefix_attrs
);
2735 decl_attributes (&d
, chainon (postfix_attrs
,
2736 all_prefix_attrs
), 0);
2737 DECL_CHAIN (d
) = decls
;
2739 if (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
2740 all_prefix_attrs
= chainon (c_parser_attributes (parser
),
2743 all_prefix_attrs
= prefix_attrs
;
2744 if (c_parser_next_token_is (parser
, CPP_COMMA
))
2745 c_parser_consume_token (parser
);
2746 else if (c_parser_next_token_is (parser
, CPP_SEMICOLON
)
2747 || c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
2749 /* Semicolon consumed in caller. */
2754 c_parser_error (parser
, "expected %<,%>, %<;%> or %<}%>");
2760 c_parser_error (parser
,
2761 "expected %<:%>, %<,%>, %<;%>, %<}%> or "
2762 "%<__attribute__%>");
2769 /* Parse a typeof specifier (a GNU extension).
2772 typeof ( expression )
2773 typeof ( type-name )
2776 static struct c_typespec
2777 c_parser_typeof_specifier (c_parser
*parser
)
2779 struct c_typespec ret
;
2780 ret
.kind
= ctsk_typeof
;
2781 ret
.spec
= error_mark_node
;
2782 ret
.expr
= NULL_TREE
;
2783 ret
.expr_const_operands
= true;
2784 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_TYPEOF
));
2785 c_parser_consume_token (parser
);
2786 c_inhibit_evaluation_warnings
++;
2788 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
2790 c_inhibit_evaluation_warnings
--;
2794 if (c_parser_next_tokens_start_typename (parser
, cla_prefer_id
))
2796 struct c_type_name
*type
= c_parser_type_name (parser
);
2797 c_inhibit_evaluation_warnings
--;
2801 ret
.spec
= groktypename (type
, &ret
.expr
, &ret
.expr_const_operands
);
2802 pop_maybe_used (variably_modified_type_p (ret
.spec
, NULL_TREE
));
2808 location_t here
= c_parser_peek_token (parser
)->location
;
2809 struct c_expr expr
= c_parser_expression (parser
);
2810 c_inhibit_evaluation_warnings
--;
2812 if (TREE_CODE (expr
.value
) == COMPONENT_REF
2813 && DECL_C_BIT_FIELD (TREE_OPERAND (expr
.value
, 1)))
2814 error_at (here
, "%<typeof%> applied to a bit-field");
2815 mark_exp_read (expr
.value
);
2816 ret
.spec
= TREE_TYPE (expr
.value
);
2817 was_vm
= variably_modified_type_p (ret
.spec
, NULL_TREE
);
2818 /* This is returned with the type so that when the type is
2819 evaluated, this can be evaluated. */
2821 ret
.expr
= c_fully_fold (expr
.value
, false, &ret
.expr_const_operands
);
2822 pop_maybe_used (was_vm
);
2824 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
2828 /* Parse an alignment-specifier.
2832 alignment-specifier:
2833 _Alignas ( type-name )
2834 _Alignas ( constant-expression )
2838 c_parser_alignas_specifier (c_parser
* parser
)
2840 tree ret
= error_mark_node
;
2841 location_t loc
= c_parser_peek_token (parser
)->location
;
2842 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_ALIGNAS
));
2843 c_parser_consume_token (parser
);
2847 pedwarn (loc
, OPT_Wpedantic
,
2848 "ISO C99 does not support %<_Alignas%>");
2850 pedwarn (loc
, OPT_Wpedantic
,
2851 "ISO C90 does not support %<_Alignas%>");
2853 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
2855 if (c_parser_next_tokens_start_typename (parser
, cla_prefer_id
))
2857 struct c_type_name
*type
= c_parser_type_name (parser
);
2859 ret
= c_alignof (loc
, groktypename (type
, NULL
, NULL
));
2862 ret
= c_parser_expr_no_commas (parser
, NULL
).value
;
2863 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
2867 /* Parse a declarator, possibly an abstract declarator (C90 6.5.4,
2868 6.5.5, C99 6.7.5, 6.7.6). If TYPE_SEEN_P then a typedef name may
2869 be redeclared; otherwise it may not. KIND indicates which kind of
2870 declarator is wanted. Returns a valid declarator except in the
2871 case of a syntax error in which case NULL is returned. *SEEN_ID is
2872 set to true if an identifier being declared is seen; this is used
2873 to diagnose bad forms of abstract array declarators and to
2874 determine whether an identifier list is syntactically permitted.
2877 pointer[opt] direct-declarator
2881 ( attributes[opt] declarator )
2882 direct-declarator array-declarator
2883 direct-declarator ( parameter-type-list )
2884 direct-declarator ( identifier-list[opt] )
2887 * type-qualifier-list[opt]
2888 * type-qualifier-list[opt] pointer
2890 type-qualifier-list:
2893 type-qualifier-list type-qualifier
2894 type-qualifier-list attributes
2897 [ type-qualifier-list[opt] assignment-expression[opt] ]
2898 [ static type-qualifier-list[opt] assignment-expression ]
2899 [ type-qualifier-list static assignment-expression ]
2900 [ type-qualifier-list[opt] * ]
2902 parameter-type-list:
2904 parameter-list , ...
2907 parameter-declaration
2908 parameter-list , parameter-declaration
2910 parameter-declaration:
2911 declaration-specifiers declarator attributes[opt]
2912 declaration-specifiers abstract-declarator[opt] attributes[opt]
2916 identifier-list , identifier
2918 abstract-declarator:
2920 pointer[opt] direct-abstract-declarator
2922 direct-abstract-declarator:
2923 ( attributes[opt] abstract-declarator )
2924 direct-abstract-declarator[opt] array-declarator
2925 direct-abstract-declarator[opt] ( parameter-type-list[opt] )
2930 direct-declarator ( parameter-forward-declarations
2931 parameter-type-list[opt] )
2933 direct-abstract-declarator:
2934 direct-abstract-declarator[opt] ( parameter-forward-declarations
2935 parameter-type-list[opt] )
2937 parameter-forward-declarations:
2939 parameter-forward-declarations parameter-list ;
2941 The uses of attributes shown above are GNU extensions.
2943 Some forms of array declarator are not included in C99 in the
2944 syntax for abstract declarators; these are disallowed elsewhere.
2945 This may be a defect (DR#289).
2947 This function also accepts an omitted abstract declarator as being
2948 an abstract declarator, although not part of the formal syntax. */
2950 static struct c_declarator
*
2951 c_parser_declarator (c_parser
*parser
, bool type_seen_p
, c_dtr_syn kind
,
2954 /* Parse any initial pointer part. */
2955 if (c_parser_next_token_is (parser
, CPP_MULT
))
2957 struct c_declspecs
*quals_attrs
= build_null_declspecs ();
2958 struct c_declarator
*inner
;
2959 c_parser_consume_token (parser
);
2960 c_parser_declspecs (parser
, quals_attrs
, false, false, true,
2961 true, cla_prefer_id
);
2962 inner
= c_parser_declarator (parser
, type_seen_p
, kind
, seen_id
);
2966 return make_pointer_declarator (quals_attrs
, inner
);
2968 /* Now we have a direct declarator, direct abstract declarator or
2969 nothing (which counts as a direct abstract declarator here). */
2970 return c_parser_direct_declarator (parser
, type_seen_p
, kind
, seen_id
);
2973 /* Parse a direct declarator or direct abstract declarator; arguments
2974 as c_parser_declarator. */
2976 static struct c_declarator
*
2977 c_parser_direct_declarator (c_parser
*parser
, bool type_seen_p
, c_dtr_syn kind
,
2980 /* The direct declarator must start with an identifier (possibly
2981 omitted) or a parenthesized declarator (possibly abstract). In
2982 an ordinary declarator, initial parentheses must start a
2983 parenthesized declarator. In an abstract declarator or parameter
2984 declarator, they could start a parenthesized declarator or a
2985 parameter list. To tell which, the open parenthesis and any
2986 following attributes must be read. If a declaration specifier
2987 follows, then it is a parameter list; if the specifier is a
2988 typedef name, there might be an ambiguity about redeclaring it,
2989 which is resolved in the direction of treating it as a typedef
2990 name. If a close parenthesis follows, it is also an empty
2991 parameter list, as the syntax does not permit empty abstract
2992 declarators. Otherwise, it is a parenthesized declarator (in
2993 which case the analysis may be repeated inside it, recursively).
2995 ??? There is an ambiguity in a parameter declaration "int
2996 (__attribute__((foo)) x)", where x is not a typedef name: it
2997 could be an abstract declarator for a function, or declare x with
2998 parentheses. The proper resolution of this ambiguity needs
2999 documenting. At present we follow an accident of the old
3000 parser's implementation, whereby the first parameter must have
3001 some declaration specifiers other than just attributes. Thus as
3002 a parameter declaration it is treated as a parenthesized
3003 parameter named x, and as an abstract declarator it is
3006 ??? Also following the old parser, attributes inside an empty
3007 parameter list are ignored, making it a list not yielding a
3008 prototype, rather than giving an error or making it have one
3009 parameter with implicit type int.
3011 ??? Also following the old parser, typedef names may be
3012 redeclared in declarators, but not Objective-C class names. */
3014 if (kind
!= C_DTR_ABSTRACT
3015 && c_parser_next_token_is (parser
, CPP_NAME
)
3017 && (c_parser_peek_token (parser
)->id_kind
== C_ID_TYPENAME
3018 || c_parser_peek_token (parser
)->id_kind
== C_ID_CLASSNAME
))
3019 || c_parser_peek_token (parser
)->id_kind
== C_ID_ID
))
3021 struct c_declarator
*inner
3022 = build_id_declarator (c_parser_peek_token (parser
)->value
);
3024 inner
->id_loc
= c_parser_peek_token (parser
)->location
;
3025 c_parser_consume_token (parser
);
3026 return c_parser_direct_declarator_inner (parser
, *seen_id
, inner
);
3029 if (kind
!= C_DTR_NORMAL
3030 && c_parser_next_token_is (parser
, CPP_OPEN_SQUARE
))
3032 struct c_declarator
*inner
= build_id_declarator (NULL_TREE
);
3033 return c_parser_direct_declarator_inner (parser
, *seen_id
, inner
);
3036 /* Either we are at the end of an abstract declarator, or we have
3039 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
3042 struct c_declarator
*inner
;
3043 c_parser_consume_token (parser
);
3044 attrs
= c_parser_attributes (parser
);
3045 if (kind
!= C_DTR_NORMAL
3046 && (c_parser_next_token_starts_declspecs (parser
)
3047 || c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
)))
3049 struct c_arg_info
*args
3050 = c_parser_parms_declarator (parser
, kind
== C_DTR_NORMAL
,
3057 = build_function_declarator (args
,
3058 build_id_declarator (NULL_TREE
));
3059 return c_parser_direct_declarator_inner (parser
, *seen_id
,
3063 /* A parenthesized declarator. */
3064 inner
= c_parser_declarator (parser
, type_seen_p
, kind
, seen_id
);
3065 if (inner
!= NULL
&& attrs
!= NULL
)
3066 inner
= build_attrs_declarator (attrs
, inner
);
3067 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
3069 c_parser_consume_token (parser
);
3073 return c_parser_direct_declarator_inner (parser
, *seen_id
, inner
);
3077 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
3084 if (kind
== C_DTR_NORMAL
)
3086 c_parser_error (parser
, "expected identifier or %<(%>");
3090 return build_id_declarator (NULL_TREE
);
3094 /* Parse part of a direct declarator or direct abstract declarator,
3095 given that some (in INNER) has already been parsed; ID_PRESENT is
3096 true if an identifier is present, false for an abstract
3099 static struct c_declarator
*
3100 c_parser_direct_declarator_inner (c_parser
*parser
, bool id_present
,
3101 struct c_declarator
*inner
)
3103 /* Parse a sequence of array declarators and parameter lists. */
3104 if (c_parser_next_token_is (parser
, CPP_OPEN_SQUARE
))
3106 location_t brace_loc
= c_parser_peek_token (parser
)->location
;
3107 struct c_declarator
*declarator
;
3108 struct c_declspecs
*quals_attrs
= build_null_declspecs ();
3112 c_parser_consume_token (parser
);
3113 c_parser_declspecs (parser
, quals_attrs
, false, false, true,
3114 false, cla_prefer_id
);
3115 static_seen
= c_parser_next_token_is_keyword (parser
, RID_STATIC
);
3117 c_parser_consume_token (parser
);
3118 if (static_seen
&& !quals_attrs
->declspecs_seen_p
)
3119 c_parser_declspecs (parser
, quals_attrs
, false, false, true,
3120 false, cla_prefer_id
);
3121 if (!quals_attrs
->declspecs_seen_p
)
3123 /* If "static" is present, there must be an array dimension.
3124 Otherwise, there may be a dimension, "*", or no
3129 dimen
= c_parser_expr_no_commas (parser
, NULL
).value
;
3133 if (c_parser_next_token_is (parser
, CPP_CLOSE_SQUARE
))
3138 else if (flag_enable_cilkplus
3139 && c_parser_next_token_is (parser
, CPP_COLON
))
3141 dimen
= error_mark_node
;
3143 error_at (c_parser_peek_token (parser
)->location
,
3144 "array notations cannot be used in declaration");
3145 c_parser_consume_token (parser
);
3147 else if (c_parser_next_token_is (parser
, CPP_MULT
))
3149 if (c_parser_peek_2nd_token (parser
)->type
== CPP_CLOSE_SQUARE
)
3153 c_parser_consume_token (parser
);
3158 dimen
= c_parser_expr_no_commas (parser
, NULL
).value
;
3164 dimen
= c_parser_expr_no_commas (parser
, NULL
).value
;
3167 if (c_parser_next_token_is (parser
, CPP_CLOSE_SQUARE
))
3168 c_parser_consume_token (parser
);
3169 else if (flag_enable_cilkplus
3170 && c_parser_next_token_is (parser
, CPP_COLON
))
3172 error_at (c_parser_peek_token (parser
)->location
,
3173 "array notations cannot be used in declaration");
3174 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
, NULL
);
3179 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
3184 mark_exp_read (dimen
);
3185 declarator
= build_array_declarator (brace_loc
, dimen
, quals_attrs
,
3186 static_seen
, star_seen
);
3187 if (declarator
== NULL
)
3189 inner
= set_array_declarator_inner (declarator
, inner
);
3190 return c_parser_direct_declarator_inner (parser
, id_present
, inner
);
3192 else if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
3195 struct c_arg_info
*args
;
3196 c_parser_consume_token (parser
);
3197 attrs
= c_parser_attributes (parser
);
3198 args
= c_parser_parms_declarator (parser
, id_present
, attrs
);
3203 inner
= build_function_declarator (args
, inner
);
3204 return c_parser_direct_declarator_inner (parser
, id_present
, inner
);
3210 /* Parse a parameter list or identifier list, including the closing
3211 parenthesis but not the opening one. ATTRS are the attributes at
3212 the start of the list. ID_LIST_OK is true if an identifier list is
3213 acceptable; such a list must not have attributes at the start. */
3215 static struct c_arg_info
*
3216 c_parser_parms_declarator (c_parser
*parser
, bool id_list_ok
, tree attrs
)
3219 declare_parm_level ();
3220 /* If the list starts with an identifier, it is an identifier list.
3221 Otherwise, it is either a prototype list or an empty list. */
3224 && c_parser_next_token_is (parser
, CPP_NAME
)
3225 && c_parser_peek_token (parser
)->id_kind
== C_ID_ID
3227 /* Look ahead to detect typos in type names. */
3228 && c_parser_peek_2nd_token (parser
)->type
!= CPP_NAME
3229 && c_parser_peek_2nd_token (parser
)->type
!= CPP_MULT
3230 && c_parser_peek_2nd_token (parser
)->type
!= CPP_OPEN_PAREN
3231 && c_parser_peek_2nd_token (parser
)->type
!= CPP_OPEN_SQUARE
)
3233 tree list
= NULL_TREE
, *nextp
= &list
;
3234 while (c_parser_next_token_is (parser
, CPP_NAME
)
3235 && c_parser_peek_token (parser
)->id_kind
== C_ID_ID
)
3237 *nextp
= build_tree_list (NULL_TREE
,
3238 c_parser_peek_token (parser
)->value
);
3239 nextp
= & TREE_CHAIN (*nextp
);
3240 c_parser_consume_token (parser
);
3241 if (c_parser_next_token_is_not (parser
, CPP_COMMA
))
3243 c_parser_consume_token (parser
);
3244 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
3246 c_parser_error (parser
, "expected identifier");
3250 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
3252 struct c_arg_info
*ret
= build_arg_info ();
3254 c_parser_consume_token (parser
);
3260 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
3268 struct c_arg_info
*ret
= c_parser_parms_list_declarator (parser
, attrs
,
3275 /* Parse a parameter list (possibly empty), including the closing
3276 parenthesis but not the opening one. ATTRS are the attributes at
3277 the start of the list. EXPR is NULL or an expression that needs to
3278 be evaluated for the side effects of array size expressions in the
3281 static struct c_arg_info
*
3282 c_parser_parms_list_declarator (c_parser
*parser
, tree attrs
, tree expr
)
3284 bool bad_parm
= false;
3286 /* ??? Following the old parser, forward parameter declarations may
3287 use abstract declarators, and if no real parameter declarations
3288 follow the forward declarations then this is not diagnosed. Also
3289 note as above that attributes are ignored as the only contents of
3290 the parentheses, or as the only contents after forward
3292 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
3294 struct c_arg_info
*ret
= build_arg_info ();
3295 c_parser_consume_token (parser
);
3298 if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
))
3300 struct c_arg_info
*ret
= build_arg_info ();
3302 if (flag_allow_parameterless_variadic_functions
)
3304 /* F (...) is allowed. */
3305 ret
->types
= NULL_TREE
;
3309 /* Suppress -Wold-style-definition for this case. */
3310 ret
->types
= error_mark_node
;
3311 error_at (c_parser_peek_token (parser
)->location
,
3312 "ISO C requires a named argument before %<...%>");
3314 c_parser_consume_token (parser
);
3315 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
3317 c_parser_consume_token (parser
);
3322 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
3327 /* Nonempty list of parameters, either terminated with semicolon
3328 (forward declarations; recurse) or with close parenthesis (normal
3329 function) or with ", ... )" (variadic function). */
3332 /* Parse a parameter. */
3333 struct c_parm
*parm
= c_parser_parameter_declaration (parser
, attrs
);
3338 push_parm_decl (parm
, &expr
);
3339 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
3342 c_parser_consume_token (parser
);
3343 mark_forward_parm_decls ();
3344 new_attrs
= c_parser_attributes (parser
);
3345 return c_parser_parms_list_declarator (parser
, new_attrs
, expr
);
3347 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
3349 c_parser_consume_token (parser
);
3353 return get_parm_info (false, expr
);
3355 if (!c_parser_require (parser
, CPP_COMMA
,
3356 "expected %<;%>, %<,%> or %<)%>"))
3358 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
3361 if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
))
3363 c_parser_consume_token (parser
);
3364 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
3366 c_parser_consume_token (parser
);
3370 return get_parm_info (true, expr
);
3374 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
3382 /* Parse a parameter declaration. ATTRS are the attributes at the
3383 start of the declaration if it is the first parameter. */
3385 static struct c_parm
*
3386 c_parser_parameter_declaration (c_parser
*parser
, tree attrs
)
3388 struct c_declspecs
*specs
;
3389 struct c_declarator
*declarator
;
3391 tree postfix_attrs
= NULL_TREE
;
3394 /* Accept #pragmas between parameter declarations. */
3395 while (c_parser_next_token_is (parser
, CPP_PRAGMA
))
3396 c_parser_pragma (parser
, pragma_param
);
3398 if (!c_parser_next_token_starts_declspecs (parser
))
3400 c_token
*token
= c_parser_peek_token (parser
);
3403 c_parser_set_source_position_from_token (token
);
3404 if (c_parser_next_tokens_start_typename (parser
, cla_prefer_type
))
3406 error ("unknown type name %qE", token
->value
);
3407 parser
->error
= true;
3409 /* ??? In some Objective-C cases '...' isn't applicable so there
3410 should be a different message. */
3412 c_parser_error (parser
,
3413 "expected declaration specifiers or %<...%>");
3414 c_parser_skip_to_end_of_parameter (parser
);
3417 specs
= build_null_declspecs ();
3420 declspecs_add_attrs (input_location
, specs
, attrs
);
3423 c_parser_declspecs (parser
, specs
, true, true, true, true,
3424 cla_nonabstract_decl
);
3425 finish_declspecs (specs
);
3426 pending_xref_error ();
3427 prefix_attrs
= specs
->attrs
;
3428 specs
->attrs
= NULL_TREE
;
3429 declarator
= c_parser_declarator (parser
,
3430 specs
->typespec_kind
!= ctsk_none
,
3431 C_DTR_PARM
, &dummy
);
3432 if (declarator
== NULL
)
3434 c_parser_skip_until_found (parser
, CPP_COMMA
, NULL
);
3437 if (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
3438 postfix_attrs
= c_parser_attributes (parser
);
3439 return build_c_parm (specs
, chainon (postfix_attrs
, prefix_attrs
),
3443 /* Parse a string literal in an asm expression. It should not be
3444 translated, and wide string literals are an error although
3445 permitted by the syntax. This is a GNU extension.
3450 ??? At present, following the old parser, the caller needs to have
3451 set lex_untranslated_string to 1. It would be better to follow the
3452 C++ parser rather than using this kludge. */
3455 c_parser_asm_string_literal (c_parser
*parser
)
3458 int save_flag
= warn_overlength_strings
;
3459 warn_overlength_strings
= 0;
3460 if (c_parser_next_token_is (parser
, CPP_STRING
))
3462 str
= c_parser_peek_token (parser
)->value
;
3463 c_parser_consume_token (parser
);
3465 else if (c_parser_next_token_is (parser
, CPP_WSTRING
))
3467 error_at (c_parser_peek_token (parser
)->location
,
3468 "wide string literal in %<asm%>");
3469 str
= build_string (1, "");
3470 c_parser_consume_token (parser
);
3474 c_parser_error (parser
, "expected string literal");
3477 warn_overlength_strings
= save_flag
;
3481 /* Parse a simple asm expression. This is used in restricted
3482 contexts, where a full expression with inputs and outputs does not
3483 make sense. This is a GNU extension.
3486 asm ( asm-string-literal )
3490 c_parser_simple_asm_expr (c_parser
*parser
)
3493 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_ASM
));
3494 /* ??? Follow the C++ parser rather than using the
3495 lex_untranslated_string kludge. */
3496 parser
->lex_untranslated_string
= true;
3497 c_parser_consume_token (parser
);
3498 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
3500 parser
->lex_untranslated_string
= false;
3503 str
= c_parser_asm_string_literal (parser
);
3504 parser
->lex_untranslated_string
= false;
3505 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
3507 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
3514 c_parser_attribute_any_word (c_parser
*parser
)
3516 tree attr_name
= NULL_TREE
;
3518 if (c_parser_next_token_is (parser
, CPP_KEYWORD
))
3520 /* ??? See comment above about what keywords are accepted here. */
3522 switch (c_parser_peek_token (parser
)->keyword
)
3553 case RID_TRANSACTION_ATOMIC
:
3554 case RID_TRANSACTION_CANCEL
:
3564 /* Accept __attribute__((__const)) as __attribute__((const)) etc. */
3565 attr_name
= ridpointers
[(int) c_parser_peek_token (parser
)->keyword
];
3567 else if (c_parser_next_token_is (parser
, CPP_NAME
))
3568 attr_name
= c_parser_peek_token (parser
)->value
;
3573 /* Parse (possibly empty) attributes. This is a GNU extension.
3577 attributes attribute
3580 __attribute__ ( ( attribute-list ) )
3584 attribute_list , attrib
3589 any-word ( identifier )
3590 any-word ( identifier , nonempty-expr-list )
3591 any-word ( expr-list )
3593 where the "identifier" must not be declared as a type, and
3594 "any-word" may be any identifier (including one declared as a
3595 type), a reserved word storage class specifier, type specifier or
3596 type qualifier. ??? This still leaves out most reserved keywords
3597 (following the old parser), shouldn't we include them, and why not
3598 allow identifiers declared as types to start the arguments? */
3601 c_parser_attributes (c_parser
*parser
)
3603 tree attrs
= NULL_TREE
;
3604 while (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
3606 /* ??? Follow the C++ parser rather than using the
3607 lex_untranslated_string kludge. */
3608 parser
->lex_untranslated_string
= true;
3609 c_parser_consume_token (parser
);
3610 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
3612 parser
->lex_untranslated_string
= false;
3615 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
3617 parser
->lex_untranslated_string
= false;
3618 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
3621 /* Parse the attribute list. */
3622 while (c_parser_next_token_is (parser
, CPP_COMMA
)
3623 || c_parser_next_token_is (parser
, CPP_NAME
)
3624 || c_parser_next_token_is (parser
, CPP_KEYWORD
))
3626 tree attr
, attr_name
, attr_args
;
3627 vec
<tree
, va_gc
> *expr_list
;
3628 if (c_parser_next_token_is (parser
, CPP_COMMA
))
3630 c_parser_consume_token (parser
);
3634 attr_name
= c_parser_attribute_any_word (parser
);
3635 if (attr_name
== NULL
)
3637 c_parser_consume_token (parser
);
3638 if (c_parser_next_token_is_not (parser
, CPP_OPEN_PAREN
))
3640 attr
= build_tree_list (attr_name
, NULL_TREE
);
3641 attrs
= chainon (attrs
, attr
);
3644 c_parser_consume_token (parser
);
3645 /* Parse the attribute contents. If they start with an
3646 identifier which is followed by a comma or close
3647 parenthesis, then the arguments start with that
3648 identifier; otherwise they are an expression list.
3649 In objective-c the identifier may be a classname. */
3650 if (c_parser_next_token_is (parser
, CPP_NAME
)
3651 && (c_parser_peek_token (parser
)->id_kind
== C_ID_ID
3652 || (c_dialect_objc ()
3653 && c_parser_peek_token (parser
)->id_kind
== C_ID_CLASSNAME
))
3654 && ((c_parser_peek_2nd_token (parser
)->type
== CPP_COMMA
)
3655 || (c_parser_peek_2nd_token (parser
)->type
3656 == CPP_CLOSE_PAREN
)))
3658 tree arg1
= c_parser_peek_token (parser
)->value
;
3659 c_parser_consume_token (parser
);
3660 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
3661 attr_args
= build_tree_list (NULL_TREE
, arg1
);
3665 c_parser_consume_token (parser
);
3666 expr_list
= c_parser_expr_list (parser
, false, true,
3668 tree_list
= build_tree_list_vec (expr_list
);
3669 attr_args
= tree_cons (NULL_TREE
, arg1
, tree_list
);
3670 release_tree_vector (expr_list
);
3675 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
3676 attr_args
= NULL_TREE
;
3679 expr_list
= c_parser_expr_list (parser
, false, true,
3681 attr_args
= build_tree_list_vec (expr_list
);
3682 release_tree_vector (expr_list
);
3685 attr
= build_tree_list (attr_name
, attr_args
);
3686 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
3687 c_parser_consume_token (parser
);
3690 parser
->lex_untranslated_string
= false;
3691 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
3695 attrs
= chainon (attrs
, attr
);
3697 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
3698 c_parser_consume_token (parser
);
3701 parser
->lex_untranslated_string
= false;
3702 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
3706 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
3707 c_parser_consume_token (parser
);
3710 parser
->lex_untranslated_string
= false;
3711 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
3715 parser
->lex_untranslated_string
= false;
3720 /* Parse a type name (C90 6.5.5, C99 6.7.6).
3723 specifier-qualifier-list abstract-declarator[opt]
3726 static struct c_type_name
*
3727 c_parser_type_name (c_parser
*parser
)
3729 struct c_declspecs
*specs
= build_null_declspecs ();
3730 struct c_declarator
*declarator
;
3731 struct c_type_name
*ret
;
3733 c_parser_declspecs (parser
, specs
, false, true, true, false,
3735 if (!specs
->declspecs_seen_p
)
3737 c_parser_error (parser
, "expected specifier-qualifier-list");
3740 if (specs
->type
!= error_mark_node
)
3742 pending_xref_error ();
3743 finish_declspecs (specs
);
3745 declarator
= c_parser_declarator (parser
,
3746 specs
->typespec_kind
!= ctsk_none
,
3747 C_DTR_ABSTRACT
, &dummy
);
3748 if (declarator
== NULL
)
3750 ret
= XOBNEW (&parser_obstack
, struct c_type_name
);
3752 ret
->declarator
= declarator
;
3756 /* Parse an initializer (C90 6.5.7, C99 6.7.8).
3759 assignment-expression
3760 { initializer-list }
3761 { initializer-list , }
3764 designation[opt] initializer
3765 initializer-list , designation[opt] initializer
3772 designator-list designator
3779 [ constant-expression ]
3791 [ constant-expression ... constant-expression ]
3793 Any expression without commas is accepted in the syntax for the
3794 constant-expressions, with non-constant expressions rejected later.
3796 This function is only used for top-level initializers; for nested
3797 ones, see c_parser_initval. */
3799 static struct c_expr
3800 c_parser_initializer (c_parser
*parser
)
3802 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
3803 return c_parser_braced_init (parser
, NULL_TREE
, false);
3807 location_t loc
= c_parser_peek_token (parser
)->location
;
3808 ret
= c_parser_expr_no_commas (parser
, NULL
);
3809 if (TREE_CODE (ret
.value
) != STRING_CST
3810 && TREE_CODE (ret
.value
) != COMPOUND_LITERAL_EXPR
)
3811 ret
= default_function_array_read_conversion (loc
, ret
);
3816 /* Parse a braced initializer list. TYPE is the type specified for a
3817 compound literal, and NULL_TREE for other initializers and for
3818 nested braced lists. NESTED_P is true for nested braced lists,
3819 false for the list of a compound literal or the list that is the
3820 top-level initializer in a declaration. */
3822 static struct c_expr
3823 c_parser_braced_init (c_parser
*parser
, tree type
, bool nested_p
)
3826 struct obstack braced_init_obstack
;
3827 location_t brace_loc
= c_parser_peek_token (parser
)->location
;
3828 gcc_obstack_init (&braced_init_obstack
);
3829 gcc_assert (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
));
3830 c_parser_consume_token (parser
);
3832 push_init_level (0, &braced_init_obstack
);
3834 really_start_incremental_init (type
);
3835 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
3837 pedwarn (brace_loc
, OPT_Wpedantic
, "ISO C forbids empty initializer braces");
3841 /* Parse a non-empty initializer list, possibly with a trailing
3845 c_parser_initelt (parser
, &braced_init_obstack
);
3848 if (c_parser_next_token_is (parser
, CPP_COMMA
))
3849 c_parser_consume_token (parser
);
3852 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
3856 if (c_parser_next_token_is_not (parser
, CPP_CLOSE_BRACE
))
3858 ret
.value
= error_mark_node
;
3859 ret
.original_code
= ERROR_MARK
;
3860 ret
.original_type
= NULL
;
3861 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
, "expected %<}%>");
3862 pop_init_level (0, &braced_init_obstack
);
3863 obstack_free (&braced_init_obstack
, NULL
);
3866 c_parser_consume_token (parser
);
3867 ret
= pop_init_level (0, &braced_init_obstack
);
3868 obstack_free (&braced_init_obstack
, NULL
);
3872 /* Parse a nested initializer, including designators. */
3875 c_parser_initelt (c_parser
*parser
, struct obstack
* braced_init_obstack
)
3877 /* Parse any designator or designator list. A single array
3878 designator may have the subsequent "=" omitted in GNU C, but a
3879 longer list or a structure member designator may not. */
3880 if (c_parser_next_token_is (parser
, CPP_NAME
)
3881 && c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
)
3883 /* Old-style structure member designator. */
3884 set_init_label (c_parser_peek_token (parser
)->value
,
3885 braced_init_obstack
);
3886 /* Use the colon as the error location. */
3887 pedwarn (c_parser_peek_2nd_token (parser
)->location
, OPT_Wpedantic
,
3888 "obsolete use of designated initializer with %<:%>");
3889 c_parser_consume_token (parser
);
3890 c_parser_consume_token (parser
);
3894 /* des_seen is 0 if there have been no designators, 1 if there
3895 has been a single array designator and 2 otherwise. */
3897 /* Location of a designator. */
3898 location_t des_loc
= UNKNOWN_LOCATION
; /* Quiet warning. */
3899 while (c_parser_next_token_is (parser
, CPP_OPEN_SQUARE
)
3900 || c_parser_next_token_is (parser
, CPP_DOT
))
3902 int des_prev
= des_seen
;
3904 des_loc
= c_parser_peek_token (parser
)->location
;
3907 if (c_parser_next_token_is (parser
, CPP_DOT
))
3910 c_parser_consume_token (parser
);
3911 if (c_parser_next_token_is (parser
, CPP_NAME
))
3913 set_init_label (c_parser_peek_token (parser
)->value
,
3914 braced_init_obstack
);
3915 c_parser_consume_token (parser
);
3920 init
.value
= error_mark_node
;
3921 init
.original_code
= ERROR_MARK
;
3922 init
.original_type
= NULL
;
3923 c_parser_error (parser
, "expected identifier");
3924 c_parser_skip_until_found (parser
, CPP_COMMA
, NULL
);
3925 process_init_element (init
, false, braced_init_obstack
);
3932 location_t ellipsis_loc
= UNKNOWN_LOCATION
; /* Quiet warning. */
3933 /* ??? Following the old parser, [ objc-receiver
3934 objc-message-args ] is accepted as an initializer,
3935 being distinguished from a designator by what follows
3936 the first assignment expression inside the square
3937 brackets, but after a first array designator a
3938 subsequent square bracket is for Objective-C taken to
3939 start an expression, using the obsolete form of
3940 designated initializer without '=', rather than
3941 possibly being a second level of designation: in LALR
3942 terms, the '[' is shifted rather than reducing
3943 designator to designator-list. */
3944 if (des_prev
== 1 && c_dialect_objc ())
3946 des_seen
= des_prev
;
3949 if (des_prev
== 0 && c_dialect_objc ())
3951 /* This might be an array designator or an
3952 Objective-C message expression. If the former,
3953 continue parsing here; if the latter, parse the
3954 remainder of the initializer given the starting
3955 primary-expression. ??? It might make sense to
3956 distinguish when des_prev == 1 as well; see
3957 previous comment. */
3959 struct c_expr mexpr
;
3960 c_parser_consume_token (parser
);
3961 if (c_parser_peek_token (parser
)->type
== CPP_NAME
3962 && ((c_parser_peek_token (parser
)->id_kind
3964 || (c_parser_peek_token (parser
)->id_kind
3965 == C_ID_CLASSNAME
)))
3967 /* Type name receiver. */
3968 tree id
= c_parser_peek_token (parser
)->value
;
3969 c_parser_consume_token (parser
);
3970 rec
= objc_get_class_reference (id
);
3971 goto parse_message_args
;
3973 first
= c_parser_expr_no_commas (parser
, NULL
).value
;
3974 mark_exp_read (first
);
3975 if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
)
3976 || c_parser_next_token_is (parser
, CPP_CLOSE_SQUARE
))
3977 goto array_desig_after_first
;
3978 /* Expression receiver. So far only one part
3979 without commas has been parsed; there might be
3980 more of the expression. */
3982 while (c_parser_next_token_is (parser
, CPP_COMMA
))
3985 location_t comma_loc
, exp_loc
;
3986 comma_loc
= c_parser_peek_token (parser
)->location
;
3987 c_parser_consume_token (parser
);
3988 exp_loc
= c_parser_peek_token (parser
)->location
;
3989 next
= c_parser_expr_no_commas (parser
, NULL
);
3990 next
= default_function_array_read_conversion (exp_loc
,
3992 rec
= build_compound_expr (comma_loc
, rec
, next
.value
);
3995 /* Now parse the objc-message-args. */
3996 args
= c_parser_objc_message_args (parser
);
3997 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
4000 = objc_build_message_expr (rec
, args
);
4001 mexpr
.original_code
= ERROR_MARK
;
4002 mexpr
.original_type
= NULL
;
4003 /* Now parse and process the remainder of the
4004 initializer, starting with this message
4005 expression as a primary-expression. */
4006 c_parser_initval (parser
, &mexpr
, braced_init_obstack
);
4009 c_parser_consume_token (parser
);
4010 first
= c_parser_expr_no_commas (parser
, NULL
).value
;
4011 mark_exp_read (first
);
4012 array_desig_after_first
:
4013 if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
))
4015 ellipsis_loc
= c_parser_peek_token (parser
)->location
;
4016 c_parser_consume_token (parser
);
4017 second
= c_parser_expr_no_commas (parser
, NULL
).value
;
4018 mark_exp_read (second
);
4022 if (c_parser_next_token_is (parser
, CPP_CLOSE_SQUARE
))
4024 c_parser_consume_token (parser
);
4025 set_init_index (first
, second
, braced_init_obstack
);
4027 pedwarn (ellipsis_loc
, OPT_Wpedantic
,
4028 "ISO C forbids specifying range of elements to initialize");
4031 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
4037 if (c_parser_next_token_is (parser
, CPP_EQ
))
4040 pedwarn (des_loc
, OPT_Wpedantic
,
4041 "ISO C90 forbids specifying subobject to initialize");
4042 c_parser_consume_token (parser
);
4047 pedwarn (c_parser_peek_token (parser
)->location
, OPT_Wpedantic
,
4048 "obsolete use of designated initializer without %<=%>");
4052 init
.value
= error_mark_node
;
4053 init
.original_code
= ERROR_MARK
;
4054 init
.original_type
= NULL
;
4055 c_parser_error (parser
, "expected %<=%>");
4056 c_parser_skip_until_found (parser
, CPP_COMMA
, NULL
);
4057 process_init_element (init
, false, braced_init_obstack
);
4063 c_parser_initval (parser
, NULL
, braced_init_obstack
);
4066 /* Parse a nested initializer; as c_parser_initializer but parses
4067 initializers within braced lists, after any designators have been
4068 applied. If AFTER is not NULL then it is an Objective-C message
4069 expression which is the primary-expression starting the
4073 c_parser_initval (c_parser
*parser
, struct c_expr
*after
,
4074 struct obstack
* braced_init_obstack
)
4077 gcc_assert (!after
|| c_dialect_objc ());
4078 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
) && !after
)
4079 init
= c_parser_braced_init (parser
, NULL_TREE
, true);
4082 location_t loc
= c_parser_peek_token (parser
)->location
;
4083 init
= c_parser_expr_no_commas (parser
, after
);
4084 if (init
.value
!= NULL_TREE
4085 && TREE_CODE (init
.value
) != STRING_CST
4086 && TREE_CODE (init
.value
) != COMPOUND_LITERAL_EXPR
)
4087 init
= default_function_array_read_conversion (loc
, init
);
4089 process_init_element (init
, false, braced_init_obstack
);
4092 /* Parse a compound statement (possibly a function body) (C90 6.6.2,
4096 { block-item-list[opt] }
4097 { label-declarations block-item-list }
4101 block-item-list block-item
4113 { label-declarations block-item-list }
4116 __extension__ nested-declaration
4117 nested-function-definition
4121 label-declarations label-declaration
4124 __label__ identifier-list ;
4126 Allowing the mixing of declarations and code is new in C99. The
4127 GNU syntax also permits (not shown above) labels at the end of
4128 compound statements, which yield an error. We don't allow labels
4129 on declarations; this might seem like a natural extension, but
4130 there would be a conflict between attributes on the label and
4131 prefix attributes on the declaration. ??? The syntax follows the
4132 old parser in requiring something after label declarations.
4133 Although they are erroneous if the labels declared aren't defined,
4134 is it useful for the syntax to be this way?
4147 cancellation-point-directive */
4150 c_parser_compound_statement (c_parser
*parser
)
4153 location_t brace_loc
;
4154 brace_loc
= c_parser_peek_token (parser
)->location
;
4155 if (!c_parser_require (parser
, CPP_OPEN_BRACE
, "expected %<{%>"))
4157 /* Ensure a scope is entered and left anyway to avoid confusion
4158 if we have just prepared to enter a function body. */
4159 stmt
= c_begin_compound_stmt (true);
4160 c_end_compound_stmt (brace_loc
, stmt
, true);
4161 return error_mark_node
;
4163 stmt
= c_begin_compound_stmt (true);
4164 c_parser_compound_statement_nostart (parser
);
4166 /* If the compound stmt contains array notations, then we expand them. */
4167 if (flag_enable_cilkplus
&& contains_array_notation_expr (stmt
))
4168 stmt
= expand_array_notation_exprs (stmt
);
4169 return c_end_compound_stmt (brace_loc
, stmt
, true);
4172 /* Parse a compound statement except for the opening brace. This is
4173 used for parsing both compound statements and statement expressions
4174 (which follow different paths to handling the opening). */
4177 c_parser_compound_statement_nostart (c_parser
*parser
)
4179 bool last_stmt
= false;
4180 bool last_label
= false;
4181 bool save_valid_for_pragma
= valid_location_for_stdc_pragma_p ();
4182 location_t label_loc
= UNKNOWN_LOCATION
; /* Quiet warning. */
4183 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
4185 c_parser_consume_token (parser
);
4188 mark_valid_location_for_stdc_pragma (true);
4189 if (c_parser_next_token_is_keyword (parser
, RID_LABEL
))
4191 /* Read zero or more forward-declarations for labels that nested
4192 functions can jump to. */
4193 mark_valid_location_for_stdc_pragma (false);
4194 while (c_parser_next_token_is_keyword (parser
, RID_LABEL
))
4196 label_loc
= c_parser_peek_token (parser
)->location
;
4197 c_parser_consume_token (parser
);
4198 /* Any identifiers, including those declared as type names,
4203 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
4205 c_parser_error (parser
, "expected identifier");
4209 = declare_label (c_parser_peek_token (parser
)->value
);
4210 C_DECLARED_LABEL_FLAG (label
) = 1;
4211 add_stmt (build_stmt (label_loc
, DECL_EXPR
, label
));
4212 c_parser_consume_token (parser
);
4213 if (c_parser_next_token_is (parser
, CPP_COMMA
))
4214 c_parser_consume_token (parser
);
4218 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
4220 pedwarn (label_loc
, OPT_Wpedantic
, "ISO C forbids label declarations");
4222 /* We must now have at least one statement, label or declaration. */
4223 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
4225 mark_valid_location_for_stdc_pragma (save_valid_for_pragma
);
4226 c_parser_error (parser
, "expected declaration or statement");
4227 c_parser_consume_token (parser
);
4230 while (c_parser_next_token_is_not (parser
, CPP_CLOSE_BRACE
))
4232 location_t loc
= c_parser_peek_token (parser
)->location
;
4233 if (c_parser_next_token_is_keyword (parser
, RID_CASE
)
4234 || c_parser_next_token_is_keyword (parser
, RID_DEFAULT
)
4235 || (c_parser_next_token_is (parser
, CPP_NAME
)
4236 && c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
))
4238 if (c_parser_next_token_is_keyword (parser
, RID_CASE
))
4239 label_loc
= c_parser_peek_2nd_token (parser
)->location
;
4241 label_loc
= c_parser_peek_token (parser
)->location
;
4244 mark_valid_location_for_stdc_pragma (false);
4245 c_parser_label (parser
);
4247 else if (!last_label
4248 && c_parser_next_tokens_start_declaration (parser
))
4251 mark_valid_location_for_stdc_pragma (false);
4252 c_parser_declaration_or_fndef (parser
, true, true, true, true,
4256 (pedantic
&& !flag_isoc99
)
4258 : OPT_Wdeclaration_after_statement
,
4259 "ISO C90 forbids mixed declarations and code");
4262 else if (!last_label
4263 && c_parser_next_token_is_keyword (parser
, RID_EXTENSION
))
4265 /* __extension__ can start a declaration, but is also an
4266 unary operator that can start an expression. Consume all
4267 but the last of a possible series of __extension__ to
4269 while (c_parser_peek_2nd_token (parser
)->type
== CPP_KEYWORD
4270 && (c_parser_peek_2nd_token (parser
)->keyword
4272 c_parser_consume_token (parser
);
4273 if (c_token_starts_declaration (c_parser_peek_2nd_token (parser
)))
4276 ext
= disable_extension_diagnostics ();
4277 c_parser_consume_token (parser
);
4279 mark_valid_location_for_stdc_pragma (false);
4280 c_parser_declaration_or_fndef (parser
, true, true, true, true,
4282 /* Following the old parser, __extension__ does not
4283 disable this diagnostic. */
4284 restore_extension_diagnostics (ext
);
4286 pedwarn_c90 (loc
, (pedantic
&& !flag_isoc99
)
4288 : OPT_Wdeclaration_after_statement
,
4289 "ISO C90 forbids mixed declarations and code");
4295 else if (c_parser_next_token_is (parser
, CPP_PRAGMA
))
4297 /* External pragmas, and some omp pragmas, are not associated
4298 with regular c code, and so are not to be considered statements
4299 syntactically. This ensures that the user doesn't put them
4300 places that would turn into syntax errors if the directive
4302 if (c_parser_pragma (parser
, pragma_compound
))
4303 last_label
= false, last_stmt
= true;
4305 else if (c_parser_next_token_is (parser
, CPP_EOF
))
4307 mark_valid_location_for_stdc_pragma (save_valid_for_pragma
);
4308 c_parser_error (parser
, "expected declaration or statement");
4311 else if (c_parser_next_token_is_keyword (parser
, RID_ELSE
))
4313 if (parser
->in_if_block
)
4315 mark_valid_location_for_stdc_pragma (save_valid_for_pragma
);
4316 error_at (loc
, """expected %<}%> before %<else%>");
4321 error_at (loc
, "%<else%> without a previous %<if%>");
4322 c_parser_consume_token (parser
);
4331 mark_valid_location_for_stdc_pragma (false);
4332 c_parser_statement_after_labels (parser
);
4335 parser
->error
= false;
4338 error_at (label_loc
, "label at end of compound statement");
4339 c_parser_consume_token (parser
);
4340 /* Restore the value we started with. */
4341 mark_valid_location_for_stdc_pragma (save_valid_for_pragma
);
4344 /* Parse a label (C90 6.6.1, C99 6.8.1).
4347 identifier : attributes[opt]
4348 case constant-expression :
4354 case constant-expression ... constant-expression :
4356 The use of attributes on labels is a GNU extension. The syntax in
4357 GNU C accepts any expressions without commas, non-constant
4358 expressions being rejected later. */
4361 c_parser_label (c_parser
*parser
)
4363 location_t loc1
= c_parser_peek_token (parser
)->location
;
4364 tree label
= NULL_TREE
;
4365 if (c_parser_next_token_is_keyword (parser
, RID_CASE
))
4368 c_parser_consume_token (parser
);
4369 exp1
= c_parser_expr_no_commas (parser
, NULL
).value
;
4370 if (c_parser_next_token_is (parser
, CPP_COLON
))
4372 c_parser_consume_token (parser
);
4373 label
= do_case (loc1
, exp1
, NULL_TREE
);
4375 else if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
))
4377 c_parser_consume_token (parser
);
4378 exp2
= c_parser_expr_no_commas (parser
, NULL
).value
;
4379 if (c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
4380 label
= do_case (loc1
, exp1
, exp2
);
4383 c_parser_error (parser
, "expected %<:%> or %<...%>");
4385 else if (c_parser_next_token_is_keyword (parser
, RID_DEFAULT
))
4387 c_parser_consume_token (parser
);
4388 if (c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
4389 label
= do_case (loc1
, NULL_TREE
, NULL_TREE
);
4393 tree name
= c_parser_peek_token (parser
)->value
;
4396 location_t loc2
= c_parser_peek_token (parser
)->location
;
4397 gcc_assert (c_parser_next_token_is (parser
, CPP_NAME
));
4398 c_parser_consume_token (parser
);
4399 gcc_assert (c_parser_next_token_is (parser
, CPP_COLON
));
4400 c_parser_consume_token (parser
);
4401 attrs
= c_parser_attributes (parser
);
4402 tlab
= define_label (loc2
, name
);
4405 decl_attributes (&tlab
, attrs
, 0);
4406 label
= add_stmt (build_stmt (loc1
, LABEL_EXPR
, tlab
));
4411 if (c_parser_next_tokens_start_declaration (parser
))
4413 error_at (c_parser_peek_token (parser
)->location
,
4414 "a label can only be part of a statement and "
4415 "a declaration is not a statement");
4416 c_parser_declaration_or_fndef (parser
, /*fndef_ok*/ false,
4417 /*static_assert_ok*/ true,
4418 /*empty_ok*/ true, /*nested*/ true,
4419 /*start_attr_ok*/ true, NULL
,
4425 /* Parse a statement (C90 6.6, C99 6.8).
4430 expression-statement
4438 expression-statement:
4441 selection-statement:
4445 iteration-statement:
4454 return expression[opt] ;
4467 objc-throw-statement
4468 objc-try-catch-statement
4469 objc-synchronized-statement
4471 objc-throw-statement:
4487 parallel-for-construct
4488 parallel-for-simd-construct
4489 parallel-sections-construct
4496 parallel-directive structured-block
4499 for-directive iteration-statement
4502 simd-directive iteration-statements
4505 for-simd-directive iteration-statements
4508 sections-directive section-scope
4511 single-directive structured-block
4513 parallel-for-construct:
4514 parallel-for-directive iteration-statement
4516 parallel-for-simd-construct:
4517 parallel-for-simd-directive iteration-statement
4519 parallel-sections-construct:
4520 parallel-sections-directive section-scope
4523 master-directive structured-block
4526 critical-directive structured-block
4529 atomic-directive expression-statement
4532 ordered-directive structured-block
4534 Transactional Memory:
4537 transaction-statement
4538 transaction-cancel-statement
4542 c_parser_statement (c_parser
*parser
)
4544 while (c_parser_next_token_is_keyword (parser
, RID_CASE
)
4545 || c_parser_next_token_is_keyword (parser
, RID_DEFAULT
)
4546 || (c_parser_next_token_is (parser
, CPP_NAME
)
4547 && c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
))
4548 c_parser_label (parser
);
4549 c_parser_statement_after_labels (parser
);
4552 /* Parse a statement, other than a labeled statement. */
4555 c_parser_statement_after_labels (c_parser
*parser
)
4557 location_t loc
= c_parser_peek_token (parser
)->location
;
4558 tree stmt
= NULL_TREE
;
4559 bool in_if_block
= parser
->in_if_block
;
4560 parser
->in_if_block
= false;
4561 switch (c_parser_peek_token (parser
)->type
)
4563 case CPP_OPEN_BRACE
:
4564 add_stmt (c_parser_compound_statement (parser
));
4567 switch (c_parser_peek_token (parser
)->keyword
)
4570 c_parser_if_statement (parser
);
4573 c_parser_switch_statement (parser
);
4576 c_parser_while_statement (parser
);
4579 c_parser_do_statement (parser
);
4582 c_parser_for_statement (parser
);
4585 c_parser_consume_token (parser
);
4586 if (c_parser_next_token_is (parser
, CPP_NAME
))
4588 stmt
= c_finish_goto_label (loc
,
4589 c_parser_peek_token (parser
)->value
);
4590 c_parser_consume_token (parser
);
4592 else if (c_parser_next_token_is (parser
, CPP_MULT
))
4596 c_parser_consume_token (parser
);
4597 val
= c_parser_expression (parser
).value
;
4598 mark_exp_read (val
);
4599 stmt
= c_finish_goto_ptr (loc
, val
);
4602 c_parser_error (parser
, "expected identifier or %<*%>");
4603 goto expect_semicolon
;
4605 c_parser_consume_token (parser
);
4606 stmt
= c_finish_bc_stmt (loc
, &c_cont_label
, false);
4607 goto expect_semicolon
;
4609 c_parser_consume_token (parser
);
4610 stmt
= c_finish_bc_stmt (loc
, &c_break_label
, true);
4611 goto expect_semicolon
;
4613 c_parser_consume_token (parser
);
4614 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
4616 stmt
= c_finish_return (loc
, NULL_TREE
, NULL_TREE
);
4617 c_parser_consume_token (parser
);
4621 struct c_expr expr
= c_parser_expression_conv (parser
);
4622 mark_exp_read (expr
.value
);
4623 stmt
= c_finish_return (loc
, expr
.value
, expr
.original_type
);
4624 goto expect_semicolon
;
4628 stmt
= c_parser_asm_statement (parser
);
4630 case RID_TRANSACTION_ATOMIC
:
4631 case RID_TRANSACTION_RELAXED
:
4632 stmt
= c_parser_transaction (parser
,
4633 c_parser_peek_token (parser
)->keyword
);
4635 case RID_TRANSACTION_CANCEL
:
4636 stmt
= c_parser_transaction_cancel (parser
);
4637 goto expect_semicolon
;
4639 gcc_assert (c_dialect_objc ());
4640 c_parser_consume_token (parser
);
4641 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
4643 stmt
= objc_build_throw_stmt (loc
, NULL_TREE
);
4644 c_parser_consume_token (parser
);
4648 tree expr
= c_parser_expression (parser
).value
;
4649 expr
= c_fully_fold (expr
, false, NULL
);
4650 stmt
= objc_build_throw_stmt (loc
, expr
);
4651 goto expect_semicolon
;
4655 gcc_assert (c_dialect_objc ());
4656 c_parser_objc_try_catch_finally_statement (parser
);
4658 case RID_AT_SYNCHRONIZED
:
4659 gcc_assert (c_dialect_objc ());
4660 c_parser_objc_synchronized_statement (parser
);
4667 c_parser_consume_token (parser
);
4669 case CPP_CLOSE_PAREN
:
4670 case CPP_CLOSE_SQUARE
:
4671 /* Avoid infinite loop in error recovery:
4672 c_parser_skip_until_found stops at a closing nesting
4673 delimiter without consuming it, but here we need to consume
4674 it to proceed further. */
4675 c_parser_error (parser
, "expected statement");
4676 c_parser_consume_token (parser
);
4679 c_parser_pragma (parser
, pragma_stmt
);
4683 stmt
= c_finish_expr_stmt (loc
, c_parser_expression_conv (parser
).value
);
4685 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
4688 /* Two cases cannot and do not have line numbers associated: If stmt
4689 is degenerate, such as "2;", then stmt is an INTEGER_CST, which
4690 cannot hold line numbers. But that's OK because the statement
4691 will either be changed to a MODIFY_EXPR during gimplification of
4692 the statement expr, or discarded. If stmt was compound, but
4693 without new variables, we will have skipped the creation of a
4694 BIND and will have a bare STATEMENT_LIST. But that's OK because
4695 (recursively) all of the component statements should already have
4696 line numbers assigned. ??? Can we discard no-op statements
4698 if (CAN_HAVE_LOCATION_P (stmt
)
4699 && EXPR_LOCATION (stmt
) == UNKNOWN_LOCATION
)
4700 SET_EXPR_LOCATION (stmt
, loc
);
4702 parser
->in_if_block
= in_if_block
;
4705 /* Parse the condition from an if, do, while or for statements. */
4708 c_parser_condition (c_parser
*parser
)
4710 location_t loc
= c_parser_peek_token (parser
)->location
;
4712 cond
= c_parser_expression_conv (parser
).value
;
4713 cond
= c_objc_common_truthvalue_conversion (loc
, cond
);
4714 cond
= c_fully_fold (cond
, false, NULL
);
4715 if (warn_sequence_point
)
4716 verify_sequence_points (cond
);
4720 /* Parse a parenthesized condition from an if, do or while statement.
4726 c_parser_paren_condition (c_parser
*parser
)
4729 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
4730 return error_mark_node
;
4731 cond
= c_parser_condition (parser
);
4732 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
4736 /* Parse a statement which is a block in C99. */
4739 c_parser_c99_block_statement (c_parser
*parser
)
4741 tree block
= c_begin_compound_stmt (flag_isoc99
);
4742 location_t loc
= c_parser_peek_token (parser
)->location
;
4743 c_parser_statement (parser
);
4744 return c_end_compound_stmt (loc
, block
, flag_isoc99
);
4747 /* Parse the body of an if statement. This is just parsing a
4748 statement but (a) it is a block in C99, (b) we track whether the
4749 body is an if statement for the sake of -Wparentheses warnings, (c)
4750 we handle an empty body specially for the sake of -Wempty-body
4751 warnings, and (d) we call parser_compound_statement directly
4752 because c_parser_statement_after_labels resets
4753 parser->in_if_block. */
4756 c_parser_if_body (c_parser
*parser
, bool *if_p
)
4758 tree block
= c_begin_compound_stmt (flag_isoc99
);
4759 location_t body_loc
= c_parser_peek_token (parser
)->location
;
4760 while (c_parser_next_token_is_keyword (parser
, RID_CASE
)
4761 || c_parser_next_token_is_keyword (parser
, RID_DEFAULT
)
4762 || (c_parser_next_token_is (parser
, CPP_NAME
)
4763 && c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
))
4764 c_parser_label (parser
);
4765 *if_p
= c_parser_next_token_is_keyword (parser
, RID_IF
);
4766 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
4768 location_t loc
= c_parser_peek_token (parser
)->location
;
4769 add_stmt (build_empty_stmt (loc
));
4770 c_parser_consume_token (parser
);
4771 if (!c_parser_next_token_is_keyword (parser
, RID_ELSE
))
4772 warning_at (loc
, OPT_Wempty_body
,
4773 "suggest braces around empty body in an %<if%> statement");
4775 else if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
4776 add_stmt (c_parser_compound_statement (parser
));
4778 c_parser_statement_after_labels (parser
);
4779 return c_end_compound_stmt (body_loc
, block
, flag_isoc99
);
4782 /* Parse the else body of an if statement. This is just parsing a
4783 statement but (a) it is a block in C99, (b) we handle an empty body
4784 specially for the sake of -Wempty-body warnings. */
4787 c_parser_else_body (c_parser
*parser
)
4789 location_t else_loc
= c_parser_peek_token (parser
)->location
;
4790 tree block
= c_begin_compound_stmt (flag_isoc99
);
4791 while (c_parser_next_token_is_keyword (parser
, RID_CASE
)
4792 || c_parser_next_token_is_keyword (parser
, RID_DEFAULT
)
4793 || (c_parser_next_token_is (parser
, CPP_NAME
)
4794 && c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
))
4795 c_parser_label (parser
);
4796 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
4798 location_t loc
= c_parser_peek_token (parser
)->location
;
4801 "suggest braces around empty body in an %<else%> statement");
4802 add_stmt (build_empty_stmt (loc
));
4803 c_parser_consume_token (parser
);
4806 c_parser_statement_after_labels (parser
);
4807 return c_end_compound_stmt (else_loc
, block
, flag_isoc99
);
4810 /* Parse an if statement (C90 6.6.4, C99 6.8.4).
4813 if ( expression ) statement
4814 if ( expression ) statement else statement
4818 c_parser_if_statement (c_parser
*parser
)
4823 bool first_if
= false;
4824 tree first_body
, second_body
;
4828 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_IF
));
4829 c_parser_consume_token (parser
);
4830 block
= c_begin_compound_stmt (flag_isoc99
);
4831 loc
= c_parser_peek_token (parser
)->location
;
4832 cond
= c_parser_paren_condition (parser
);
4833 in_if_block
= parser
->in_if_block
;
4834 parser
->in_if_block
= true;
4835 first_body
= c_parser_if_body (parser
, &first_if
);
4836 parser
->in_if_block
= in_if_block
;
4837 if (c_parser_next_token_is_keyword (parser
, RID_ELSE
))
4839 c_parser_consume_token (parser
);
4840 second_body
= c_parser_else_body (parser
);
4843 second_body
= NULL_TREE
;
4844 c_finish_if_stmt (loc
, cond
, first_body
, second_body
, first_if
);
4845 if_stmt
= c_end_compound_stmt (loc
, block
, flag_isoc99
);
4847 /* If the if statement contains array notations, then we expand them. */
4848 if (flag_enable_cilkplus
&& contains_array_notation_expr (if_stmt
))
4849 if_stmt
= fix_conditional_array_notations (if_stmt
);
4853 /* Parse a switch statement (C90 6.6.4, C99 6.8.4).
4856 switch (expression) statement
4860 c_parser_switch_statement (c_parser
*parser
)
4862 tree block
, expr
, body
, save_break
;
4863 location_t switch_loc
= c_parser_peek_token (parser
)->location
;
4864 location_t switch_cond_loc
;
4865 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_SWITCH
));
4866 c_parser_consume_token (parser
);
4867 block
= c_begin_compound_stmt (flag_isoc99
);
4868 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
4870 switch_cond_loc
= c_parser_peek_token (parser
)->location
;
4871 expr
= c_parser_expression (parser
).value
;
4872 if (flag_enable_cilkplus
&& contains_array_notation_expr (expr
))
4874 error_at (switch_cond_loc
,
4875 "array notations cannot be used as a condition for switch "
4877 expr
= error_mark_node
;
4879 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
4883 switch_cond_loc
= UNKNOWN_LOCATION
;
4884 expr
= error_mark_node
;
4886 c_start_case (switch_loc
, switch_cond_loc
, expr
);
4887 save_break
= c_break_label
;
4888 c_break_label
= NULL_TREE
;
4889 body
= c_parser_c99_block_statement (parser
);
4890 c_finish_case (body
);
4893 location_t here
= c_parser_peek_token (parser
)->location
;
4894 tree t
= build1 (LABEL_EXPR
, void_type_node
, c_break_label
);
4895 SET_EXPR_LOCATION (t
, here
);
4898 c_break_label
= save_break
;
4899 add_stmt (c_end_compound_stmt (switch_loc
, block
, flag_isoc99
));
4902 /* Parse a while statement (C90 6.6.5, C99 6.8.5).
4905 while (expression) statement
4909 c_parser_while_statement (c_parser
*parser
)
4911 tree block
, cond
, body
, save_break
, save_cont
;
4913 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_WHILE
));
4914 c_parser_consume_token (parser
);
4915 block
= c_begin_compound_stmt (flag_isoc99
);
4916 loc
= c_parser_peek_token (parser
)->location
;
4917 cond
= c_parser_paren_condition (parser
);
4918 if (flag_enable_cilkplus
&& contains_array_notation_expr (cond
))
4920 error_at (loc
, "array notations cannot be used as a condition for while "
4922 cond
= error_mark_node
;
4924 save_break
= c_break_label
;
4925 c_break_label
= NULL_TREE
;
4926 save_cont
= c_cont_label
;
4927 c_cont_label
= NULL_TREE
;
4928 body
= c_parser_c99_block_statement (parser
);
4929 c_finish_loop (loc
, cond
, NULL
, body
, c_break_label
, c_cont_label
, true);
4930 add_stmt (c_end_compound_stmt (loc
, block
, flag_isoc99
));
4931 c_break_label
= save_break
;
4932 c_cont_label
= save_cont
;
4935 /* Parse a do statement (C90 6.6.5, C99 6.8.5).
4938 do statement while ( expression ) ;
4942 c_parser_do_statement (c_parser
*parser
)
4944 tree block
, cond
, body
, save_break
, save_cont
, new_break
, new_cont
;
4946 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_DO
));
4947 c_parser_consume_token (parser
);
4948 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
4949 warning_at (c_parser_peek_token (parser
)->location
,
4951 "suggest braces around empty body in %<do%> statement");
4952 block
= c_begin_compound_stmt (flag_isoc99
);
4953 loc
= c_parser_peek_token (parser
)->location
;
4954 save_break
= c_break_label
;
4955 c_break_label
= NULL_TREE
;
4956 save_cont
= c_cont_label
;
4957 c_cont_label
= NULL_TREE
;
4958 body
= c_parser_c99_block_statement (parser
);
4959 c_parser_require_keyword (parser
, RID_WHILE
, "expected %<while%>");
4960 new_break
= c_break_label
;
4961 c_break_label
= save_break
;
4962 new_cont
= c_cont_label
;
4963 c_cont_label
= save_cont
;
4964 cond
= c_parser_paren_condition (parser
);
4965 if (flag_enable_cilkplus
&& contains_array_notation_expr (cond
))
4967 error_at (loc
, "array notations cannot be used as a condition for a "
4968 "do-while statement");
4969 cond
= error_mark_node
;
4972 if (!c_parser_require (parser
, CPP_SEMICOLON
, "expected %<;%>"))
4973 c_parser_skip_to_end_of_block_or_statement (parser
);
4974 c_finish_loop (loc
, cond
, NULL
, body
, new_break
, new_cont
, false);
4975 add_stmt (c_end_compound_stmt (loc
, block
, flag_isoc99
));
4978 /* Parse a for statement (C90 6.6.5, C99 6.8.5).
4981 for ( expression[opt] ; expression[opt] ; expression[opt] ) statement
4982 for ( nested-declaration expression[opt] ; expression[opt] ) statement
4984 The form with a declaration is new in C99.
4986 ??? In accordance with the old parser, the declaration may be a
4987 nested function, which is then rejected in check_for_loop_decls,
4988 but does it make any sense for this to be included in the grammar?
4989 Note in particular that the nested function does not include a
4990 trailing ';', whereas the "declaration" production includes one.
4991 Also, can we reject bad declarations earlier and cheaper than
4992 check_for_loop_decls?
4994 In Objective-C, there are two additional variants:
4997 for ( expression in expresssion ) statement
4998 for ( declaration in expression ) statement
5000 This is inconsistent with C, because the second variant is allowed
5001 even if c99 is not enabled.
5003 The rest of the comment documents these Objective-C foreach-statement.
5005 Here is the canonical example of the first variant:
5006 for (object in array) { do something with object }
5007 we call the first expression ("object") the "object_expression" and
5008 the second expression ("array") the "collection_expression".
5009 object_expression must be an lvalue of type "id" (a generic Objective-C
5010 object) because the loop works by assigning to object_expression the
5011 various objects from the collection_expression. collection_expression
5012 must evaluate to something of type "id" which responds to the method
5013 countByEnumeratingWithState:objects:count:.
5015 The canonical example of the second variant is:
5016 for (id object in array) { do something with object }
5017 which is completely equivalent to
5020 for (object in array) { do something with object }
5022 Note that initizializing 'object' in some way (eg, "for ((object =
5023 xxx) in array) { do something with object }") is possibly
5024 technically valid, but completely pointless as 'object' will be
5025 assigned to something else as soon as the loop starts. We should
5026 most likely reject it (TODO).
5028 The beginning of the Objective-C foreach-statement looks exactly
5029 like the beginning of the for-statement, and we can tell it is a
5030 foreach-statement only because the initial declaration or
5031 expression is terminated by 'in' instead of ';'.
5035 c_parser_for_statement (c_parser
*parser
)
5037 tree block
, cond
, incr
, save_break
, save_cont
, body
;
5038 /* The following are only used when parsing an ObjC foreach statement. */
5039 tree object_expression
;
5040 /* Silence the bogus uninitialized warning. */
5041 tree collection_expression
= NULL
;
5042 location_t loc
= c_parser_peek_token (parser
)->location
;
5043 location_t for_loc
= c_parser_peek_token (parser
)->location
;
5044 bool is_foreach_statement
= false;
5045 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_FOR
));
5046 c_parser_consume_token (parser
);
5047 /* Open a compound statement in Objective-C as well, just in case this is
5048 as foreach expression. */
5049 block
= c_begin_compound_stmt (flag_isoc99
|| c_dialect_objc ());
5050 cond
= error_mark_node
;
5051 incr
= error_mark_node
;
5052 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
5054 /* Parse the initialization declaration or expression. */
5055 object_expression
= error_mark_node
;
5056 parser
->objc_could_be_foreach_context
= c_dialect_objc ();
5057 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
5059 parser
->objc_could_be_foreach_context
= false;
5060 c_parser_consume_token (parser
);
5061 c_finish_expr_stmt (loc
, NULL_TREE
);
5063 else if (c_parser_next_tokens_start_declaration (parser
))
5065 c_parser_declaration_or_fndef (parser
, true, true, true, true, true,
5066 &object_expression
, vNULL
);
5067 parser
->objc_could_be_foreach_context
= false;
5069 if (c_parser_next_token_is_keyword (parser
, RID_IN
))
5071 c_parser_consume_token (parser
);
5072 is_foreach_statement
= true;
5073 if (check_for_loop_decls (for_loc
, true) == NULL_TREE
)
5074 c_parser_error (parser
, "multiple iterating variables in fast enumeration");
5077 check_for_loop_decls (for_loc
, flag_isoc99
);
5079 else if (c_parser_next_token_is_keyword (parser
, RID_EXTENSION
))
5081 /* __extension__ can start a declaration, but is also an
5082 unary operator that can start an expression. Consume all
5083 but the last of a possible series of __extension__ to
5085 while (c_parser_peek_2nd_token (parser
)->type
== CPP_KEYWORD
5086 && (c_parser_peek_2nd_token (parser
)->keyword
5088 c_parser_consume_token (parser
);
5089 if (c_token_starts_declaration (c_parser_peek_2nd_token (parser
)))
5092 ext
= disable_extension_diagnostics ();
5093 c_parser_consume_token (parser
);
5094 c_parser_declaration_or_fndef (parser
, true, true, true, true,
5095 true, &object_expression
, vNULL
);
5096 parser
->objc_could_be_foreach_context
= false;
5098 restore_extension_diagnostics (ext
);
5099 if (c_parser_next_token_is_keyword (parser
, RID_IN
))
5101 c_parser_consume_token (parser
);
5102 is_foreach_statement
= true;
5103 if (check_for_loop_decls (for_loc
, true) == NULL_TREE
)
5104 c_parser_error (parser
, "multiple iterating variables in fast enumeration");
5107 check_for_loop_decls (for_loc
, flag_isoc99
);
5116 tree init_expression
;
5117 init_expression
= c_parser_expression (parser
).value
;
5118 parser
->objc_could_be_foreach_context
= false;
5119 if (c_parser_next_token_is_keyword (parser
, RID_IN
))
5121 c_parser_consume_token (parser
);
5122 is_foreach_statement
= true;
5123 if (! lvalue_p (init_expression
))
5124 c_parser_error (parser
, "invalid iterating variable in fast enumeration");
5125 object_expression
= c_fully_fold (init_expression
, false, NULL
);
5129 c_finish_expr_stmt (loc
, init_expression
);
5130 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
5134 /* Parse the loop condition. In the case of a foreach
5135 statement, there is no loop condition. */
5136 gcc_assert (!parser
->objc_could_be_foreach_context
);
5137 if (!is_foreach_statement
)
5139 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
5141 c_parser_consume_token (parser
);
5146 cond
= c_parser_condition (parser
);
5147 if (flag_enable_cilkplus
&& contains_array_notation_expr (cond
))
5149 error_at (loc
, "array notations cannot be used in a "
5150 "condition for a for-loop");
5151 cond
= error_mark_node
;
5153 c_parser_skip_until_found (parser
, CPP_SEMICOLON
,
5157 /* Parse the increment expression (the third expression in a
5158 for-statement). In the case of a foreach-statement, this is
5159 the expression that follows the 'in'. */
5160 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
5162 if (is_foreach_statement
)
5164 c_parser_error (parser
, "missing collection in fast enumeration");
5165 collection_expression
= error_mark_node
;
5168 incr
= c_process_expr_stmt (loc
, NULL_TREE
);
5172 if (is_foreach_statement
)
5173 collection_expression
= c_fully_fold (c_parser_expression (parser
).value
,
5176 incr
= c_process_expr_stmt (loc
, c_parser_expression (parser
).value
);
5178 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
5180 save_break
= c_break_label
;
5181 c_break_label
= NULL_TREE
;
5182 save_cont
= c_cont_label
;
5183 c_cont_label
= NULL_TREE
;
5184 body
= c_parser_c99_block_statement (parser
);
5185 if (is_foreach_statement
)
5186 objc_finish_foreach_loop (loc
, object_expression
, collection_expression
, body
, c_break_label
, c_cont_label
);
5188 c_finish_loop (loc
, cond
, incr
, body
, c_break_label
, c_cont_label
, true);
5189 add_stmt (c_end_compound_stmt (loc
, block
, flag_isoc99
|| c_dialect_objc ()));
5190 c_break_label
= save_break
;
5191 c_cont_label
= save_cont
;
5194 /* Parse an asm statement, a GNU extension. This is a full-blown asm
5195 statement with inputs, outputs, clobbers, and volatile tag
5199 asm type-qualifier[opt] ( asm-argument ) ;
5200 asm type-qualifier[opt] goto ( asm-goto-argument ) ;
5204 asm-string-literal : asm-operands[opt]
5205 asm-string-literal : asm-operands[opt] : asm-operands[opt]
5206 asm-string-literal : asm-operands[opt] : asm-operands[opt] : asm-clobbers[opt]
5209 asm-string-literal : : asm-operands[opt] : asm-clobbers[opt] \
5212 Qualifiers other than volatile are accepted in the syntax but
5216 c_parser_asm_statement (c_parser
*parser
)
5218 tree quals
, str
, outputs
, inputs
, clobbers
, labels
, ret
;
5219 bool simple
, is_goto
;
5220 location_t asm_loc
= c_parser_peek_token (parser
)->location
;
5221 int section
, nsections
;
5223 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_ASM
));
5224 c_parser_consume_token (parser
);
5225 if (c_parser_next_token_is_keyword (parser
, RID_VOLATILE
))
5227 quals
= c_parser_peek_token (parser
)->value
;
5228 c_parser_consume_token (parser
);
5230 else if (c_parser_next_token_is_keyword (parser
, RID_CONST
)
5231 || c_parser_next_token_is_keyword (parser
, RID_RESTRICT
))
5233 warning_at (c_parser_peek_token (parser
)->location
,
5235 "%E qualifier ignored on asm",
5236 c_parser_peek_token (parser
)->value
);
5238 c_parser_consume_token (parser
);
5244 if (c_parser_next_token_is_keyword (parser
, RID_GOTO
))
5246 c_parser_consume_token (parser
);
5250 /* ??? Follow the C++ parser rather than using the
5251 lex_untranslated_string kludge. */
5252 parser
->lex_untranslated_string
= true;
5255 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
5258 str
= c_parser_asm_string_literal (parser
);
5259 if (str
== NULL_TREE
)
5260 goto error_close_paren
;
5263 outputs
= NULL_TREE
;
5265 clobbers
= NULL_TREE
;
5268 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
) && !is_goto
)
5271 /* Parse each colon-delimited section of operands. */
5272 nsections
= 3 + is_goto
;
5273 for (section
= 0; section
< nsections
; ++section
)
5275 if (!c_parser_require (parser
, CPP_COLON
,
5278 : "expected %<:%> or %<)%>"))
5279 goto error_close_paren
;
5281 /* Once past any colon, we're no longer a simple asm. */
5284 if ((!c_parser_next_token_is (parser
, CPP_COLON
)
5285 && !c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
5290 /* For asm goto, we don't allow output operands, but reserve
5291 the slot for a future extension that does allow them. */
5293 outputs
= c_parser_asm_operands (parser
);
5296 inputs
= c_parser_asm_operands (parser
);
5299 clobbers
= c_parser_asm_clobbers (parser
);
5302 labels
= c_parser_asm_goto_operands (parser
);
5308 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
) && !is_goto
)
5313 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
5315 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5319 if (!c_parser_require (parser
, CPP_SEMICOLON
, "expected %<;%>"))
5320 c_parser_skip_to_end_of_block_or_statement (parser
);
5322 ret
= build_asm_stmt (quals
, build_asm_expr (asm_loc
, str
, outputs
, inputs
,
5323 clobbers
, labels
, simple
));
5326 parser
->lex_untranslated_string
= false;
5330 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5334 /* Parse asm operands, a GNU extension.
5338 asm-operands , asm-operand
5341 asm-string-literal ( expression )
5342 [ identifier ] asm-string-literal ( expression )
5346 c_parser_asm_operands (c_parser
*parser
)
5348 tree list
= NULL_TREE
;
5353 if (c_parser_next_token_is (parser
, CPP_OPEN_SQUARE
))
5355 c_parser_consume_token (parser
);
5356 if (c_parser_next_token_is (parser
, CPP_NAME
))
5358 tree id
= c_parser_peek_token (parser
)->value
;
5359 c_parser_consume_token (parser
);
5360 name
= build_string (IDENTIFIER_LENGTH (id
),
5361 IDENTIFIER_POINTER (id
));
5365 c_parser_error (parser
, "expected identifier");
5366 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
, NULL
);
5369 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
5374 str
= c_parser_asm_string_literal (parser
);
5375 if (str
== NULL_TREE
)
5377 parser
->lex_untranslated_string
= false;
5378 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
5380 parser
->lex_untranslated_string
= true;
5383 expr
= c_parser_expression (parser
);
5384 mark_exp_read (expr
.value
);
5385 parser
->lex_untranslated_string
= true;
5386 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
5388 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5391 list
= chainon (list
, build_tree_list (build_tree_list (name
, str
),
5393 if (c_parser_next_token_is (parser
, CPP_COMMA
))
5394 c_parser_consume_token (parser
);
5401 /* Parse asm clobbers, a GNU extension.
5405 asm-clobbers , asm-string-literal
5409 c_parser_asm_clobbers (c_parser
*parser
)
5411 tree list
= NULL_TREE
;
5414 tree str
= c_parser_asm_string_literal (parser
);
5416 list
= tree_cons (NULL_TREE
, str
, list
);
5419 if (c_parser_next_token_is (parser
, CPP_COMMA
))
5420 c_parser_consume_token (parser
);
5427 /* Parse asm goto labels, a GNU extension.
5431 asm-goto-operands , identifier
5435 c_parser_asm_goto_operands (c_parser
*parser
)
5437 tree list
= NULL_TREE
;
5442 if (c_parser_next_token_is (parser
, CPP_NAME
))
5444 c_token
*tok
= c_parser_peek_token (parser
);
5446 label
= lookup_label_for_goto (tok
->location
, name
);
5447 c_parser_consume_token (parser
);
5448 TREE_USED (label
) = 1;
5452 c_parser_error (parser
, "expected identifier");
5456 name
= build_string (IDENTIFIER_LENGTH (name
),
5457 IDENTIFIER_POINTER (name
));
5458 list
= tree_cons (name
, label
, list
);
5459 if (c_parser_next_token_is (parser
, CPP_COMMA
))
5460 c_parser_consume_token (parser
);
5462 return nreverse (list
);
5466 /* Parse an expression other than a compound expression; that is, an
5467 assignment expression (C90 6.3.16, C99 6.5.16). If AFTER is not
5468 NULL then it is an Objective-C message expression which is the
5469 primary-expression starting the expression as an initializer.
5471 assignment-expression:
5472 conditional-expression
5473 unary-expression assignment-operator assignment-expression
5475 assignment-operator: one of
5476 = *= /= %= += -= <<= >>= &= ^= |=
5478 In GNU C we accept any conditional expression on the LHS and
5479 diagnose the invalid lvalue rather than producing a syntax
5482 static struct c_expr
5483 c_parser_expr_no_commas (c_parser
*parser
, struct c_expr
*after
,
5484 tree omp_atomic_lhs
)
5486 struct c_expr lhs
, rhs
, ret
;
5487 enum tree_code code
;
5488 location_t op_location
, exp_location
;
5489 gcc_assert (!after
|| c_dialect_objc ());
5490 lhs
= c_parser_conditional_expression (parser
, after
, omp_atomic_lhs
);
5491 op_location
= c_parser_peek_token (parser
)->location
;
5492 switch (c_parser_peek_token (parser
)->type
)
5501 code
= TRUNC_DIV_EXPR
;
5504 code
= TRUNC_MOD_EXPR
;
5519 code
= BIT_AND_EXPR
;
5522 code
= BIT_XOR_EXPR
;
5525 code
= BIT_IOR_EXPR
;
5530 c_parser_consume_token (parser
);
5531 exp_location
= c_parser_peek_token (parser
)->location
;
5532 rhs
= c_parser_expr_no_commas (parser
, NULL
);
5533 rhs
= default_function_array_read_conversion (exp_location
, rhs
);
5535 ret
.value
= build_modify_expr (op_location
, lhs
.value
, lhs
.original_type
,
5536 code
, exp_location
, rhs
.value
,
5538 if (code
== NOP_EXPR
)
5539 ret
.original_code
= MODIFY_EXPR
;
5542 TREE_NO_WARNING (ret
.value
) = 1;
5543 ret
.original_code
= ERROR_MARK
;
5545 ret
.original_type
= NULL
;
5549 /* Parse a conditional expression (C90 6.3.15, C99 6.5.15). If AFTER
5550 is not NULL then it is an Objective-C message expression which is
5551 the primary-expression starting the expression as an initializer.
5553 conditional-expression:
5554 logical-OR-expression
5555 logical-OR-expression ? expression : conditional-expression
5559 conditional-expression:
5560 logical-OR-expression ? : conditional-expression
5563 static struct c_expr
5564 c_parser_conditional_expression (c_parser
*parser
, struct c_expr
*after
,
5565 tree omp_atomic_lhs
)
5567 struct c_expr cond
, exp1
, exp2
, ret
;
5568 location_t cond_loc
, colon_loc
, middle_loc
;
5570 gcc_assert (!after
|| c_dialect_objc ());
5572 cond
= c_parser_binary_expression (parser
, after
, omp_atomic_lhs
);
5574 if (c_parser_next_token_is_not (parser
, CPP_QUERY
))
5576 cond_loc
= c_parser_peek_token (parser
)->location
;
5577 cond
= default_function_array_read_conversion (cond_loc
, cond
);
5578 c_parser_consume_token (parser
);
5579 if (c_parser_next_token_is (parser
, CPP_COLON
))
5581 tree eptype
= NULL_TREE
;
5583 middle_loc
= c_parser_peek_token (parser
)->location
;
5584 pedwarn (middle_loc
, OPT_Wpedantic
,
5585 "ISO C forbids omitting the middle term of a ?: expression");
5586 warn_for_omitted_condop (middle_loc
, cond
.value
);
5587 if (TREE_CODE (cond
.value
) == EXCESS_PRECISION_EXPR
)
5589 eptype
= TREE_TYPE (cond
.value
);
5590 cond
.value
= TREE_OPERAND (cond
.value
, 0);
5592 /* Make sure first operand is calculated only once. */
5593 exp1
.value
= c_save_expr (default_conversion (cond
.value
));
5595 exp1
.value
= build1 (EXCESS_PRECISION_EXPR
, eptype
, exp1
.value
);
5596 exp1
.original_type
= NULL
;
5597 cond
.value
= c_objc_common_truthvalue_conversion (cond_loc
, exp1
.value
);
5598 c_inhibit_evaluation_warnings
+= cond
.value
== truthvalue_true_node
;
5603 = c_objc_common_truthvalue_conversion
5604 (cond_loc
, default_conversion (cond
.value
));
5605 c_inhibit_evaluation_warnings
+= cond
.value
== truthvalue_false_node
;
5606 exp1
= c_parser_expression_conv (parser
);
5607 mark_exp_read (exp1
.value
);
5608 c_inhibit_evaluation_warnings
+=
5609 ((cond
.value
== truthvalue_true_node
)
5610 - (cond
.value
== truthvalue_false_node
));
5613 colon_loc
= c_parser_peek_token (parser
)->location
;
5614 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
5616 c_inhibit_evaluation_warnings
-= cond
.value
== truthvalue_true_node
;
5617 ret
.value
= error_mark_node
;
5618 ret
.original_code
= ERROR_MARK
;
5619 ret
.original_type
= NULL
;
5623 location_t exp2_loc
= c_parser_peek_token (parser
)->location
;
5624 exp2
= c_parser_conditional_expression (parser
, NULL
, NULL_TREE
);
5625 exp2
= default_function_array_read_conversion (exp2_loc
, exp2
);
5627 c_inhibit_evaluation_warnings
-= cond
.value
== truthvalue_true_node
;
5628 ret
.value
= build_conditional_expr (colon_loc
, cond
.value
,
5629 cond
.original_code
== C_MAYBE_CONST_EXPR
,
5630 exp1
.value
, exp1
.original_type
,
5631 exp2
.value
, exp2
.original_type
);
5632 ret
.original_code
= ERROR_MARK
;
5633 if (exp1
.value
== error_mark_node
|| exp2
.value
== error_mark_node
)
5634 ret
.original_type
= NULL
;
5639 /* If both sides are enum type, the default conversion will have
5640 made the type of the result be an integer type. We want to
5641 remember the enum types we started with. */
5642 t1
= exp1
.original_type
? exp1
.original_type
: TREE_TYPE (exp1
.value
);
5643 t2
= exp2
.original_type
? exp2
.original_type
: TREE_TYPE (exp2
.value
);
5644 ret
.original_type
= ((t1
!= error_mark_node
5645 && t2
!= error_mark_node
5646 && (TYPE_MAIN_VARIANT (t1
)
5647 == TYPE_MAIN_VARIANT (t2
)))
5654 /* Parse a binary expression; that is, a logical-OR-expression (C90
5655 6.3.5-6.3.14, C99 6.5.5-6.5.14). If AFTER is not NULL then it is
5656 an Objective-C message expression which is the primary-expression
5657 starting the expression as an initializer.
5659 OMP_ATOMIC_LHS is NULL, unless parsing OpenMP #pragma omp atomic,
5660 when it should be the unfolded lhs. In a valid OpenMP source,
5661 one of the operands of the toplevel binary expression must be equal
5662 to it. In that case, just return a build2 created binary operation
5663 rather than result of parser_build_binary_op.
5665 multiplicative-expression:
5667 multiplicative-expression * cast-expression
5668 multiplicative-expression / cast-expression
5669 multiplicative-expression % cast-expression
5671 additive-expression:
5672 multiplicative-expression
5673 additive-expression + multiplicative-expression
5674 additive-expression - multiplicative-expression
5678 shift-expression << additive-expression
5679 shift-expression >> additive-expression
5681 relational-expression:
5683 relational-expression < shift-expression
5684 relational-expression > shift-expression
5685 relational-expression <= shift-expression
5686 relational-expression >= shift-expression
5688 equality-expression:
5689 relational-expression
5690 equality-expression == relational-expression
5691 equality-expression != relational-expression
5695 AND-expression & equality-expression
5697 exclusive-OR-expression:
5699 exclusive-OR-expression ^ AND-expression
5701 inclusive-OR-expression:
5702 exclusive-OR-expression
5703 inclusive-OR-expression | exclusive-OR-expression
5705 logical-AND-expression:
5706 inclusive-OR-expression
5707 logical-AND-expression && inclusive-OR-expression
5709 logical-OR-expression:
5710 logical-AND-expression
5711 logical-OR-expression || logical-AND-expression
5714 static struct c_expr
5715 c_parser_binary_expression (c_parser
*parser
, struct c_expr
*after
,
5716 tree omp_atomic_lhs
)
5718 /* A binary expression is parsed using operator-precedence parsing,
5719 with the operands being cast expressions. All the binary
5720 operators are left-associative. Thus a binary expression is of
5723 E0 op1 E1 op2 E2 ...
5725 which we represent on a stack. On the stack, the precedence
5726 levels are strictly increasing. When a new operator is
5727 encountered of higher precedence than that at the top of the
5728 stack, it is pushed; its LHS is the top expression, and its RHS
5729 is everything parsed until it is popped. When a new operator is
5730 encountered with precedence less than or equal to that at the top
5731 of the stack, triples E[i-1] op[i] E[i] are popped and replaced
5732 by the result of the operation until the operator at the top of
5733 the stack has lower precedence than the new operator or there is
5734 only one element on the stack; then the top expression is the LHS
5735 of the new operator. In the case of logical AND and OR
5736 expressions, we also need to adjust c_inhibit_evaluation_warnings
5737 as appropriate when the operators are pushed and popped. */
5740 /* The expression at this stack level. */
5742 /* The precedence of the operator on its left, PREC_NONE at the
5743 bottom of the stack. */
5744 enum c_parser_prec prec
;
5745 /* The operation on its left. */
5747 /* The source location of this operation. */
5751 /* Location of the binary operator. */
5752 location_t binary_loc
= UNKNOWN_LOCATION
; /* Quiet warning. */
5755 switch (stack[sp].op) \
5757 case TRUTH_ANDIF_EXPR: \
5758 c_inhibit_evaluation_warnings -= (stack[sp - 1].expr.value \
5759 == truthvalue_false_node); \
5761 case TRUTH_ORIF_EXPR: \
5762 c_inhibit_evaluation_warnings -= (stack[sp - 1].expr.value \
5763 == truthvalue_true_node); \
5768 stack[sp - 1].expr \
5769 = default_function_array_read_conversion (stack[sp - 1].loc, \
5770 stack[sp - 1].expr); \
5772 = default_function_array_read_conversion (stack[sp].loc, \
5774 if (__builtin_expect (omp_atomic_lhs != NULL_TREE, 0) && sp == 1 \
5775 && c_parser_peek_token (parser)->type == CPP_SEMICOLON \
5776 && ((1 << stack[sp].prec) \
5777 & (1 << (PREC_BITOR | PREC_BITXOR | PREC_BITAND | PREC_SHIFT \
5778 | PREC_ADD | PREC_MULT))) \
5779 && stack[sp].op != TRUNC_MOD_EXPR \
5780 && stack[0].expr.value != error_mark_node \
5781 && stack[1].expr.value != error_mark_node \
5782 && (c_tree_equal (stack[0].expr.value, omp_atomic_lhs) \
5783 || c_tree_equal (stack[1].expr.value, omp_atomic_lhs))) \
5784 stack[0].expr.value \
5785 = build2 (stack[1].op, TREE_TYPE (stack[0].expr.value), \
5786 stack[0].expr.value, stack[1].expr.value); \
5788 stack[sp - 1].expr = parser_build_binary_op (stack[sp].loc, \
5790 stack[sp - 1].expr, \
5794 gcc_assert (!after
|| c_dialect_objc ());
5795 stack
[0].loc
= c_parser_peek_token (parser
)->location
;
5796 stack
[0].expr
= c_parser_cast_expression (parser
, after
);
5797 stack
[0].prec
= PREC_NONE
;
5801 enum c_parser_prec oprec
;
5802 enum tree_code ocode
;
5805 switch (c_parser_peek_token (parser
)->type
)
5813 ocode
= TRUNC_DIV_EXPR
;
5817 ocode
= TRUNC_MOD_EXPR
;
5829 ocode
= LSHIFT_EXPR
;
5833 ocode
= RSHIFT_EXPR
;
5847 case CPP_GREATER_EQ
:
5860 oprec
= PREC_BITAND
;
5861 ocode
= BIT_AND_EXPR
;
5864 oprec
= PREC_BITXOR
;
5865 ocode
= BIT_XOR_EXPR
;
5869 ocode
= BIT_IOR_EXPR
;
5872 oprec
= PREC_LOGAND
;
5873 ocode
= TRUTH_ANDIF_EXPR
;
5877 ocode
= TRUTH_ORIF_EXPR
;
5880 /* Not a binary operator, so end of the binary
5884 binary_loc
= c_parser_peek_token (parser
)->location
;
5885 while (oprec
<= stack
[sp
].prec
)
5887 c_parser_consume_token (parser
);
5890 case TRUTH_ANDIF_EXPR
:
5892 = default_function_array_read_conversion (stack
[sp
].loc
,
5894 stack
[sp
].expr
.value
= c_objc_common_truthvalue_conversion
5895 (stack
[sp
].loc
, default_conversion (stack
[sp
].expr
.value
));
5896 c_inhibit_evaluation_warnings
+= (stack
[sp
].expr
.value
5897 == truthvalue_false_node
);
5899 case TRUTH_ORIF_EXPR
:
5901 = default_function_array_read_conversion (stack
[sp
].loc
,
5903 stack
[sp
].expr
.value
= c_objc_common_truthvalue_conversion
5904 (stack
[sp
].loc
, default_conversion (stack
[sp
].expr
.value
));
5905 c_inhibit_evaluation_warnings
+= (stack
[sp
].expr
.value
5906 == truthvalue_true_node
);
5912 stack
[sp
].loc
= binary_loc
;
5913 stack
[sp
].expr
= c_parser_cast_expression (parser
, NULL
);
5914 stack
[sp
].prec
= oprec
;
5915 stack
[sp
].op
= ocode
;
5916 stack
[sp
].loc
= binary_loc
;
5921 return stack
[0].expr
;
5925 /* Parse a cast expression (C90 6.3.4, C99 6.5.4). If AFTER is not
5926 NULL then it is an Objective-C message expression which is the
5927 primary-expression starting the expression as an initializer.
5931 ( type-name ) unary-expression
5934 static struct c_expr
5935 c_parser_cast_expression (c_parser
*parser
, struct c_expr
*after
)
5937 location_t cast_loc
= c_parser_peek_token (parser
)->location
;
5938 gcc_assert (!after
|| c_dialect_objc ());
5940 return c_parser_postfix_expression_after_primary (parser
,
5942 /* If the expression begins with a parenthesized type name, it may
5943 be either a cast or a compound literal; we need to see whether
5944 the next character is '{' to tell the difference. If not, it is
5945 an unary expression. Full detection of unknown typenames here
5946 would require a 3-token lookahead. */
5947 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
)
5948 && c_token_starts_typename (c_parser_peek_2nd_token (parser
)))
5950 struct c_type_name
*type_name
;
5953 c_parser_consume_token (parser
);
5954 type_name
= c_parser_type_name (parser
);
5955 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
5956 if (type_name
== NULL
)
5958 ret
.value
= error_mark_node
;
5959 ret
.original_code
= ERROR_MARK
;
5960 ret
.original_type
= NULL
;
5964 /* Save casted types in the function's used types hash table. */
5965 used_types_insert (type_name
->specs
->type
);
5967 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
5968 return c_parser_postfix_expression_after_paren_type (parser
, type_name
,
5971 location_t expr_loc
= c_parser_peek_token (parser
)->location
;
5972 expr
= c_parser_cast_expression (parser
, NULL
);
5973 expr
= default_function_array_read_conversion (expr_loc
, expr
);
5975 ret
.value
= c_cast_expr (cast_loc
, type_name
, expr
.value
);
5976 ret
.original_code
= ERROR_MARK
;
5977 ret
.original_type
= NULL
;
5981 return c_parser_unary_expression (parser
);
5984 /* Parse an unary expression (C90 6.3.3, C99 6.5.3).
5990 unary-operator cast-expression
5991 sizeof unary-expression
5992 sizeof ( type-name )
5994 unary-operator: one of
6000 __alignof__ unary-expression
6001 __alignof__ ( type-name )
6004 (C11 permits _Alignof with type names only.)
6006 unary-operator: one of
6007 __extension__ __real__ __imag__
6009 Transactional Memory:
6012 transaction-expression
6014 In addition, the GNU syntax treats ++ and -- as unary operators, so
6015 they may be applied to cast expressions with errors for non-lvalues
6018 static struct c_expr
6019 c_parser_unary_expression (c_parser
*parser
)
6022 struct c_expr ret
, op
;
6023 location_t op_loc
= c_parser_peek_token (parser
)->location
;
6025 ret
.original_code
= ERROR_MARK
;
6026 ret
.original_type
= NULL
;
6027 switch (c_parser_peek_token (parser
)->type
)
6030 c_parser_consume_token (parser
);
6031 exp_loc
= c_parser_peek_token (parser
)->location
;
6032 op
= c_parser_cast_expression (parser
, NULL
);
6034 /* If there is array notations in op, we expand them. */
6035 if (flag_enable_cilkplus
&& TREE_CODE (op
.value
) == ARRAY_NOTATION_REF
)
6036 return fix_array_notation_expr (exp_loc
, PREINCREMENT_EXPR
, op
);
6039 op
= default_function_array_read_conversion (exp_loc
, op
);
6040 return parser_build_unary_op (op_loc
, PREINCREMENT_EXPR
, op
);
6042 case CPP_MINUS_MINUS
:
6043 c_parser_consume_token (parser
);
6044 exp_loc
= c_parser_peek_token (parser
)->location
;
6045 op
= c_parser_cast_expression (parser
, NULL
);
6047 /* If there is array notations in op, we expand them. */
6048 if (flag_enable_cilkplus
&& TREE_CODE (op
.value
) == ARRAY_NOTATION_REF
)
6049 return fix_array_notation_expr (exp_loc
, PREDECREMENT_EXPR
, op
);
6052 op
= default_function_array_read_conversion (exp_loc
, op
);
6053 return parser_build_unary_op (op_loc
, PREDECREMENT_EXPR
, op
);
6056 c_parser_consume_token (parser
);
6057 op
= c_parser_cast_expression (parser
, NULL
);
6058 mark_exp_read (op
.value
);
6059 return parser_build_unary_op (op_loc
, ADDR_EXPR
, op
);
6061 c_parser_consume_token (parser
);
6062 exp_loc
= c_parser_peek_token (parser
)->location
;
6063 op
= c_parser_cast_expression (parser
, NULL
);
6064 op
= default_function_array_read_conversion (exp_loc
, op
);
6065 ret
.value
= build_indirect_ref (op_loc
, op
.value
, RO_UNARY_STAR
);
6068 if (!c_dialect_objc () && !in_system_header
)
6071 "traditional C rejects the unary plus operator");
6072 c_parser_consume_token (parser
);
6073 exp_loc
= c_parser_peek_token (parser
)->location
;
6074 op
= c_parser_cast_expression (parser
, NULL
);
6075 op
= default_function_array_read_conversion (exp_loc
, op
);
6076 return parser_build_unary_op (op_loc
, CONVERT_EXPR
, op
);
6078 c_parser_consume_token (parser
);
6079 exp_loc
= c_parser_peek_token (parser
)->location
;
6080 op
= c_parser_cast_expression (parser
, NULL
);
6081 op
= default_function_array_read_conversion (exp_loc
, op
);
6082 return parser_build_unary_op (op_loc
, NEGATE_EXPR
, op
);
6084 c_parser_consume_token (parser
);
6085 exp_loc
= c_parser_peek_token (parser
)->location
;
6086 op
= c_parser_cast_expression (parser
, NULL
);
6087 op
= default_function_array_read_conversion (exp_loc
, op
);
6088 return parser_build_unary_op (op_loc
, BIT_NOT_EXPR
, op
);
6090 c_parser_consume_token (parser
);
6091 exp_loc
= c_parser_peek_token (parser
)->location
;
6092 op
= c_parser_cast_expression (parser
, NULL
);
6093 op
= default_function_array_read_conversion (exp_loc
, op
);
6094 return parser_build_unary_op (op_loc
, TRUTH_NOT_EXPR
, op
);
6096 /* Refer to the address of a label as a pointer. */
6097 c_parser_consume_token (parser
);
6098 if (c_parser_next_token_is (parser
, CPP_NAME
))
6100 ret
.value
= finish_label_address_expr
6101 (c_parser_peek_token (parser
)->value
, op_loc
);
6102 c_parser_consume_token (parser
);
6106 c_parser_error (parser
, "expected identifier");
6107 ret
.value
= error_mark_node
;
6111 switch (c_parser_peek_token (parser
)->keyword
)
6114 return c_parser_sizeof_expression (parser
);
6116 return c_parser_alignof_expression (parser
);
6118 c_parser_consume_token (parser
);
6119 ext
= disable_extension_diagnostics ();
6120 ret
= c_parser_cast_expression (parser
, NULL
);
6121 restore_extension_diagnostics (ext
);
6124 c_parser_consume_token (parser
);
6125 exp_loc
= c_parser_peek_token (parser
)->location
;
6126 op
= c_parser_cast_expression (parser
, NULL
);
6127 op
= default_function_array_conversion (exp_loc
, op
);
6128 return parser_build_unary_op (op_loc
, REALPART_EXPR
, op
);
6130 c_parser_consume_token (parser
);
6131 exp_loc
= c_parser_peek_token (parser
)->location
;
6132 op
= c_parser_cast_expression (parser
, NULL
);
6133 op
= default_function_array_conversion (exp_loc
, op
);
6134 return parser_build_unary_op (op_loc
, IMAGPART_EXPR
, op
);
6135 case RID_TRANSACTION_ATOMIC
:
6136 case RID_TRANSACTION_RELAXED
:
6137 return c_parser_transaction_expression (parser
,
6138 c_parser_peek_token (parser
)->keyword
);
6140 return c_parser_postfix_expression (parser
);
6143 return c_parser_postfix_expression (parser
);
6147 /* Parse a sizeof expression. */
6149 static struct c_expr
6150 c_parser_sizeof_expression (c_parser
*parser
)
6153 location_t expr_loc
;
6154 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_SIZEOF
));
6155 c_parser_consume_token (parser
);
6156 c_inhibit_evaluation_warnings
++;
6158 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
)
6159 && c_token_starts_typename (c_parser_peek_2nd_token (parser
)))
6161 /* Either sizeof ( type-name ) or sizeof unary-expression
6162 starting with a compound literal. */
6163 struct c_type_name
*type_name
;
6164 c_parser_consume_token (parser
);
6165 expr_loc
= c_parser_peek_token (parser
)->location
;
6166 type_name
= c_parser_type_name (parser
);
6167 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
6168 if (type_name
== NULL
)
6171 c_inhibit_evaluation_warnings
--;
6173 ret
.value
= error_mark_node
;
6174 ret
.original_code
= ERROR_MARK
;
6175 ret
.original_type
= NULL
;
6178 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
6180 expr
= c_parser_postfix_expression_after_paren_type (parser
,
6185 /* sizeof ( type-name ). */
6186 c_inhibit_evaluation_warnings
--;
6188 return c_expr_sizeof_type (expr_loc
, type_name
);
6192 expr_loc
= c_parser_peek_token (parser
)->location
;
6193 expr
= c_parser_unary_expression (parser
);
6195 c_inhibit_evaluation_warnings
--;
6197 mark_exp_read (expr
.value
);
6198 if (TREE_CODE (expr
.value
) == COMPONENT_REF
6199 && DECL_C_BIT_FIELD (TREE_OPERAND (expr
.value
, 1)))
6200 error_at (expr_loc
, "%<sizeof%> applied to a bit-field");
6201 return c_expr_sizeof_expr (expr_loc
, expr
);
6205 /* Parse an alignof expression. */
6207 static struct c_expr
6208 c_parser_alignof_expression (c_parser
*parser
)
6211 location_t loc
= c_parser_peek_token (parser
)->location
;
6212 tree alignof_spelling
= c_parser_peek_token (parser
)->value
;
6213 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_ALIGNOF
));
6214 /* A diagnostic is not required for the use of this identifier in
6215 the implementation namespace; only diagnose it for the C11
6216 spelling because of existing code using the other spellings. */
6218 && strcmp (IDENTIFIER_POINTER (alignof_spelling
), "_Alignof") == 0)
6221 pedwarn (loc
, OPT_Wpedantic
, "ISO C99 does not support %qE",
6224 pedwarn (loc
, OPT_Wpedantic
, "ISO C90 does not support %qE",
6227 c_parser_consume_token (parser
);
6228 c_inhibit_evaluation_warnings
++;
6230 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
)
6231 && c_token_starts_typename (c_parser_peek_2nd_token (parser
)))
6233 /* Either __alignof__ ( type-name ) or __alignof__
6234 unary-expression starting with a compound literal. */
6236 struct c_type_name
*type_name
;
6238 c_parser_consume_token (parser
);
6239 loc
= c_parser_peek_token (parser
)->location
;
6240 type_name
= c_parser_type_name (parser
);
6241 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
6242 if (type_name
== NULL
)
6245 c_inhibit_evaluation_warnings
--;
6247 ret
.value
= error_mark_node
;
6248 ret
.original_code
= ERROR_MARK
;
6249 ret
.original_type
= NULL
;
6252 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
6254 expr
= c_parser_postfix_expression_after_paren_type (parser
,
6259 /* alignof ( type-name ). */
6260 c_inhibit_evaluation_warnings
--;
6262 ret
.value
= c_alignof (loc
, groktypename (type_name
, NULL
, NULL
));
6263 ret
.original_code
= ERROR_MARK
;
6264 ret
.original_type
= NULL
;
6270 expr
= c_parser_unary_expression (parser
);
6272 mark_exp_read (expr
.value
);
6273 c_inhibit_evaluation_warnings
--;
6275 pedwarn (loc
, OPT_Wpedantic
, "ISO C does not allow %<%E (expression)%>",
6277 ret
.value
= c_alignof_expr (loc
, expr
.value
);
6278 ret
.original_code
= ERROR_MARK
;
6279 ret
.original_type
= NULL
;
6284 /* Helper function to read arguments of builtins which are interfaces
6285 for the middle-end nodes like COMPLEX_EXPR, VEC_PERM_EXPR and
6286 others. The name of the builtin is passed using BNAME parameter.
6287 Function returns true if there were no errors while parsing and
6288 stores the arguments in CEXPR_LIST. */
6290 c_parser_get_builtin_args (c_parser
*parser
, const char *bname
,
6291 vec
<c_expr_t
, va_gc
> **ret_cexpr_list
,
6294 location_t loc
= c_parser_peek_token (parser
)->location
;
6295 vec
<c_expr_t
, va_gc
> *cexpr_list
;
6297 bool saved_force_folding_builtin_constant_p
;
6299 *ret_cexpr_list
= NULL
;
6300 if (c_parser_next_token_is_not (parser
, CPP_OPEN_PAREN
))
6302 error_at (loc
, "cannot take address of %qs", bname
);
6306 c_parser_consume_token (parser
);
6308 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
6310 c_parser_consume_token (parser
);
6314 saved_force_folding_builtin_constant_p
6315 = force_folding_builtin_constant_p
;
6316 force_folding_builtin_constant_p
|= choose_expr_p
;
6317 expr
= c_parser_expr_no_commas (parser
, NULL
);
6318 force_folding_builtin_constant_p
6319 = saved_force_folding_builtin_constant_p
;
6320 vec_alloc (cexpr_list
, 1);
6321 C_EXPR_APPEND (cexpr_list
, expr
);
6322 while (c_parser_next_token_is (parser
, CPP_COMMA
))
6324 c_parser_consume_token (parser
);
6325 expr
= c_parser_expr_no_commas (parser
, NULL
);
6326 C_EXPR_APPEND (cexpr_list
, expr
);
6329 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
6332 *ret_cexpr_list
= cexpr_list
;
6336 /* This represents a single generic-association. */
6338 struct c_generic_association
6340 /* The location of the starting token of the type. */
6341 location_t type_location
;
6342 /* The association's type, or NULL_TREE for 'default'. */
6344 /* The association's expression. */
6345 struct c_expr expression
;
6348 /* Parse a generic-selection. (C11 6.5.1.1).
6351 _Generic ( assignment-expression , generic-assoc-list )
6355 generic-assoc-list , generic-association
6357 generic-association:
6358 type-name : assignment-expression
6359 default : assignment-expression
6362 static struct c_expr
6363 c_parser_generic_selection (c_parser
*parser
)
6365 vec
<c_generic_association
> associations
= vNULL
;
6366 struct c_expr selector
, error_expr
;
6368 struct c_generic_association matched_assoc
;
6369 bool match_found
= false;
6370 location_t generic_loc
, selector_loc
;
6372 error_expr
.original_code
= ERROR_MARK
;
6373 error_expr
.original_type
= NULL
;
6374 error_expr
.value
= error_mark_node
;
6375 matched_assoc
.type_location
= UNKNOWN_LOCATION
;
6376 matched_assoc
.type
= NULL_TREE
;
6377 matched_assoc
.expression
= error_expr
;
6379 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_GENERIC
));
6380 generic_loc
= c_parser_peek_token (parser
)->location
;
6381 c_parser_consume_token (parser
);
6385 pedwarn (generic_loc
, OPT_Wpedantic
,
6386 "ISO C99 does not support %<_Generic%>");
6388 pedwarn (generic_loc
, OPT_Wpedantic
,
6389 "ISO C90 does not support %<_Generic%>");
6392 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
6395 c_inhibit_evaluation_warnings
++;
6396 selector_loc
= c_parser_peek_token (parser
)->location
;
6397 selector
= c_parser_expr_no_commas (parser
, NULL
);
6398 selector
= default_function_array_conversion (selector_loc
, selector
);
6399 c_inhibit_evaluation_warnings
--;
6401 if (selector
.value
== error_mark_node
)
6403 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
6406 selector_type
= TREE_TYPE (selector
.value
);
6407 /* In ISO C terms, rvalues (including the controlling expression of
6408 _Generic) do not have qualified types. */
6409 if (TREE_CODE (selector_type
) != ARRAY_TYPE
)
6410 selector_type
= TYPE_MAIN_VARIANT (selector_type
);
6411 /* In ISO C terms, _Noreturn is not part of the type of expressions
6412 such as &abort, but in GCC it is represented internally as a type
6414 if (FUNCTION_POINTER_TYPE_P (selector_type
)
6415 && TYPE_QUALS (TREE_TYPE (selector_type
)) != TYPE_UNQUALIFIED
)
6417 = build_pointer_type (TYPE_MAIN_VARIANT (TREE_TYPE (selector_type
)));
6419 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
6421 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
6427 struct c_generic_association assoc
, *iter
;
6429 c_token
*token
= c_parser_peek_token (parser
);
6431 assoc
.type_location
= token
->location
;
6432 if (token
->type
== CPP_KEYWORD
&& token
->keyword
== RID_DEFAULT
)
6434 c_parser_consume_token (parser
);
6435 assoc
.type
= NULL_TREE
;
6439 struct c_type_name
*type_name
;
6441 type_name
= c_parser_type_name (parser
);
6442 if (type_name
== NULL
)
6444 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
6447 assoc
.type
= groktypename (type_name
, NULL
, NULL
);
6448 if (assoc
.type
== error_mark_node
)
6450 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
6454 if (TREE_CODE (assoc
.type
) == FUNCTION_TYPE
)
6455 error_at (assoc
.type_location
,
6456 "%<_Generic%> association has function type");
6457 else if (!COMPLETE_TYPE_P (assoc
.type
))
6458 error_at (assoc
.type_location
,
6459 "%<_Generic%> association has incomplete type");
6461 if (variably_modified_type_p (assoc
.type
, NULL_TREE
))
6462 error_at (assoc
.type_location
,
6463 "%<_Generic%> association has "
6464 "variable length type");
6467 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
6469 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
6473 assoc
.expression
= c_parser_expr_no_commas (parser
, NULL
);
6474 if (assoc
.expression
.value
== error_mark_node
)
6476 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
6480 for (ix
= 0; associations
.iterate (ix
, &iter
); ++ix
)
6482 if (assoc
.type
== NULL_TREE
)
6484 if (iter
->type
== NULL_TREE
)
6486 error_at (assoc
.type_location
,
6487 "duplicate %<default%> case in %<_Generic%>");
6488 inform (iter
->type_location
, "original %<default%> is here");
6491 else if (iter
->type
!= NULL_TREE
)
6493 if (comptypes (assoc
.type
, iter
->type
))
6495 error_at (assoc
.type_location
,
6496 "%<_Generic%> specifies two compatible types");
6497 inform (iter
->type_location
, "compatible type is here");
6502 if (assoc
.type
== NULL_TREE
)
6506 matched_assoc
= assoc
;
6510 else if (comptypes (assoc
.type
, selector_type
))
6512 if (!match_found
|| matched_assoc
.type
== NULL_TREE
)
6514 matched_assoc
= assoc
;
6519 error_at (assoc
.type_location
,
6520 "%<_Generic> selector matches multiple associations");
6521 inform (matched_assoc
.type_location
,
6522 "other match is here");
6526 associations
.safe_push (assoc
);
6528 if (c_parser_peek_token (parser
)->type
!= CPP_COMMA
)
6530 c_parser_consume_token (parser
);
6533 associations
.release ();
6535 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
6537 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
6543 error_at (selector_loc
, "%<_Generic%> selector of type %qT is not "
6544 "compatible with any association",
6549 return matched_assoc
.expression
;
6552 associations
.release ();
6556 /* Parse a postfix expression (C90 6.3.1-6.3.2, C99 6.5.1-6.5.2).
6560 postfix-expression [ expression ]
6561 postfix-expression ( argument-expression-list[opt] )
6562 postfix-expression . identifier
6563 postfix-expression -> identifier
6564 postfix-expression ++
6565 postfix-expression --
6566 ( type-name ) { initializer-list }
6567 ( type-name ) { initializer-list , }
6569 argument-expression-list:
6571 argument-expression-list , argument-expression
6584 (treated as a keyword in GNU C)
6587 ( compound-statement )
6588 __builtin_va_arg ( assignment-expression , type-name )
6589 __builtin_offsetof ( type-name , offsetof-member-designator )
6590 __builtin_choose_expr ( assignment-expression ,
6591 assignment-expression ,
6592 assignment-expression )
6593 __builtin_types_compatible_p ( type-name , type-name )
6594 __builtin_complex ( assignment-expression , assignment-expression )
6595 __builtin_shuffle ( assignment-expression , assignment-expression )
6596 __builtin_shuffle ( assignment-expression ,
6597 assignment-expression ,
6598 assignment-expression, )
6600 offsetof-member-designator:
6602 offsetof-member-designator . identifier
6603 offsetof-member-designator [ expression ]
6608 [ objc-receiver objc-message-args ]
6609 @selector ( objc-selector-arg )
6610 @protocol ( identifier )
6611 @encode ( type-name )
6613 Classname . identifier
6616 static struct c_expr
6617 c_parser_postfix_expression (c_parser
*parser
)
6619 struct c_expr expr
, e1
;
6620 struct c_type_name
*t1
, *t2
;
6621 location_t loc
= c_parser_peek_token (parser
)->location
;;
6622 expr
.original_code
= ERROR_MARK
;
6623 expr
.original_type
= NULL
;
6624 switch (c_parser_peek_token (parser
)->type
)
6627 expr
.value
= c_parser_peek_token (parser
)->value
;
6628 loc
= c_parser_peek_token (parser
)->location
;
6629 c_parser_consume_token (parser
);
6630 if (TREE_CODE (expr
.value
) == FIXED_CST
6631 && !targetm
.fixed_point_supported_p ())
6633 error_at (loc
, "fixed-point types not supported for this target");
6634 expr
.value
= error_mark_node
;
6641 expr
.value
= c_parser_peek_token (parser
)->value
;
6642 c_parser_consume_token (parser
);
6648 case CPP_UTF8STRING
:
6649 expr
.value
= c_parser_peek_token (parser
)->value
;
6650 expr
.original_code
= STRING_CST
;
6651 c_parser_consume_token (parser
);
6653 case CPP_OBJC_STRING
:
6654 gcc_assert (c_dialect_objc ());
6656 = objc_build_string_object (c_parser_peek_token (parser
)->value
);
6657 c_parser_consume_token (parser
);
6660 switch (c_parser_peek_token (parser
)->id_kind
)
6664 tree id
= c_parser_peek_token (parser
)->value
;
6665 c_parser_consume_token (parser
);
6666 expr
.value
= build_external_ref (loc
, id
,
6667 (c_parser_peek_token (parser
)->type
6669 &expr
.original_type
);
6672 case C_ID_CLASSNAME
:
6674 /* Here we parse the Objective-C 2.0 Class.name dot
6676 tree class_name
= c_parser_peek_token (parser
)->value
;
6678 c_parser_consume_token (parser
);
6679 gcc_assert (c_dialect_objc ());
6680 if (!c_parser_require (parser
, CPP_DOT
, "expected %<.%>"))
6682 expr
.value
= error_mark_node
;
6685 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
6687 c_parser_error (parser
, "expected identifier");
6688 expr
.value
= error_mark_node
;
6691 component
= c_parser_peek_token (parser
)->value
;
6692 c_parser_consume_token (parser
);
6693 expr
.value
= objc_build_class_component_ref (class_name
,
6698 c_parser_error (parser
, "expected expression");
6699 expr
.value
= error_mark_node
;
6703 case CPP_OPEN_PAREN
:
6704 /* A parenthesized expression, statement expression or compound
6706 if (c_parser_peek_2nd_token (parser
)->type
== CPP_OPEN_BRACE
)
6708 /* A statement expression. */
6710 location_t brace_loc
;
6711 c_parser_consume_token (parser
);
6712 brace_loc
= c_parser_peek_token (parser
)->location
;
6713 c_parser_consume_token (parser
);
6714 if (!building_stmt_list_p ())
6716 error_at (loc
, "braced-group within expression allowed "
6717 "only inside a function");
6718 parser
->error
= true;
6719 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
, NULL
);
6720 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
6721 expr
.value
= error_mark_node
;
6724 stmt
= c_begin_stmt_expr ();
6725 c_parser_compound_statement_nostart (parser
);
6726 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
6728 pedwarn (loc
, OPT_Wpedantic
,
6729 "ISO C forbids braced-groups within expressions");
6730 expr
.value
= c_finish_stmt_expr (brace_loc
, stmt
);
6731 mark_exp_read (expr
.value
);
6733 else if (c_token_starts_typename (c_parser_peek_2nd_token (parser
)))
6735 /* A compound literal. ??? Can we actually get here rather
6736 than going directly to
6737 c_parser_postfix_expression_after_paren_type from
6740 struct c_type_name
*type_name
;
6741 c_parser_consume_token (parser
);
6742 loc
= c_parser_peek_token (parser
)->location
;
6743 type_name
= c_parser_type_name (parser
);
6744 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
6746 if (type_name
== NULL
)
6748 expr
.value
= error_mark_node
;
6751 expr
= c_parser_postfix_expression_after_paren_type (parser
,
6757 /* A parenthesized expression. */
6758 c_parser_consume_token (parser
);
6759 expr
= c_parser_expression (parser
);
6760 if (TREE_CODE (expr
.value
) == MODIFY_EXPR
)
6761 TREE_NO_WARNING (expr
.value
) = 1;
6762 if (expr
.original_code
!= C_MAYBE_CONST_EXPR
)
6763 expr
.original_code
= ERROR_MARK
;
6764 /* Don't change EXPR.ORIGINAL_TYPE. */
6765 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
6770 switch (c_parser_peek_token (parser
)->keyword
)
6772 case RID_FUNCTION_NAME
:
6773 case RID_PRETTY_FUNCTION_NAME
:
6774 case RID_C99_FUNCTION_NAME
:
6775 expr
.value
= fname_decl (loc
,
6776 c_parser_peek_token (parser
)->keyword
,
6777 c_parser_peek_token (parser
)->value
);
6778 c_parser_consume_token (parser
);
6781 c_parser_consume_token (parser
);
6782 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
6784 expr
.value
= error_mark_node
;
6787 e1
= c_parser_expr_no_commas (parser
, NULL
);
6788 mark_exp_read (e1
.value
);
6789 e1
.value
= c_fully_fold (e1
.value
, false, NULL
);
6790 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
6792 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
6793 expr
.value
= error_mark_node
;
6796 loc
= c_parser_peek_token (parser
)->location
;
6797 t1
= c_parser_type_name (parser
);
6798 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
6802 expr
.value
= error_mark_node
;
6806 tree type_expr
= NULL_TREE
;
6807 expr
.value
= c_build_va_arg (loc
, e1
.value
,
6808 groktypename (t1
, &type_expr
, NULL
));
6811 expr
.value
= build2 (C_MAYBE_CONST_EXPR
,
6812 TREE_TYPE (expr
.value
), type_expr
,
6814 C_MAYBE_CONST_EXPR_NON_CONST (expr
.value
) = true;
6819 c_parser_consume_token (parser
);
6820 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
6822 expr
.value
= error_mark_node
;
6825 t1
= c_parser_type_name (parser
);
6827 parser
->error
= true;
6828 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
6829 gcc_assert (parser
->error
);
6832 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
6833 expr
.value
= error_mark_node
;
6838 tree type
= groktypename (t1
, NULL
, NULL
);
6840 if (type
== error_mark_node
)
6841 offsetof_ref
= error_mark_node
;
6844 offsetof_ref
= build1 (INDIRECT_REF
, type
, null_pointer_node
);
6845 SET_EXPR_LOCATION (offsetof_ref
, loc
);
6847 /* Parse the second argument to __builtin_offsetof. We
6848 must have one identifier, and beyond that we want to
6849 accept sub structure and sub array references. */
6850 if (c_parser_next_token_is (parser
, CPP_NAME
))
6852 offsetof_ref
= build_component_ref
6853 (loc
, offsetof_ref
, c_parser_peek_token (parser
)->value
);
6854 c_parser_consume_token (parser
);
6855 while (c_parser_next_token_is (parser
, CPP_DOT
)
6856 || c_parser_next_token_is (parser
,
6858 || c_parser_next_token_is (parser
,
6861 if (c_parser_next_token_is (parser
, CPP_DEREF
))
6863 loc
= c_parser_peek_token (parser
)->location
;
6864 offsetof_ref
= build_array_ref (loc
,
6869 else if (c_parser_next_token_is (parser
, CPP_DOT
))
6872 c_parser_consume_token (parser
);
6873 if (c_parser_next_token_is_not (parser
,
6876 c_parser_error (parser
, "expected identifier");
6879 offsetof_ref
= build_component_ref
6881 c_parser_peek_token (parser
)->value
);
6882 c_parser_consume_token (parser
);
6887 loc
= c_parser_peek_token (parser
)->location
;
6888 c_parser_consume_token (parser
);
6889 idx
= c_parser_expression (parser
).value
;
6890 idx
= c_fully_fold (idx
, false, NULL
);
6891 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
6893 offsetof_ref
= build_array_ref (loc
, offsetof_ref
, idx
);
6898 c_parser_error (parser
, "expected identifier");
6899 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
6901 expr
.value
= fold_offsetof (offsetof_ref
);
6904 case RID_CHOOSE_EXPR
:
6906 vec
<c_expr_t
, va_gc
> *cexpr_list
;
6907 c_expr_t
*e1_p
, *e2_p
, *e3_p
;
6910 c_parser_consume_token (parser
);
6911 if (!c_parser_get_builtin_args (parser
,
6912 "__builtin_choose_expr",
6915 expr
.value
= error_mark_node
;
6919 if (vec_safe_length (cexpr_list
) != 3)
6921 error_at (loc
, "wrong number of arguments to "
6922 "%<__builtin_choose_expr%>");
6923 expr
.value
= error_mark_node
;
6927 e1_p
= &(*cexpr_list
)[0];
6928 e2_p
= &(*cexpr_list
)[1];
6929 e3_p
= &(*cexpr_list
)[2];
6932 mark_exp_read (e2_p
->value
);
6933 mark_exp_read (e3_p
->value
);
6934 if (TREE_CODE (c
) != INTEGER_CST
6935 || !INTEGRAL_TYPE_P (TREE_TYPE (c
)))
6937 "first argument to %<__builtin_choose_expr%> not"
6939 constant_expression_warning (c
);
6940 expr
= integer_zerop (c
) ? *e3_p
: *e2_p
;
6943 case RID_TYPES_COMPATIBLE_P
:
6944 c_parser_consume_token (parser
);
6945 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
6947 expr
.value
= error_mark_node
;
6950 t1
= c_parser_type_name (parser
);
6953 expr
.value
= error_mark_node
;
6956 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
6958 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
6959 expr
.value
= error_mark_node
;
6962 t2
= c_parser_type_name (parser
);
6965 expr
.value
= error_mark_node
;
6968 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
6972 e1
= groktypename (t1
, NULL
, NULL
);
6973 e2
= groktypename (t2
, NULL
, NULL
);
6974 if (e1
== error_mark_node
|| e2
== error_mark_node
)
6976 expr
.value
= error_mark_node
;
6980 e1
= TYPE_MAIN_VARIANT (e1
);
6981 e2
= TYPE_MAIN_VARIANT (e2
);
6984 = comptypes (e1
, e2
) ? integer_one_node
: integer_zero_node
;
6987 case RID_BUILTIN_COMPLEX
:
6989 vec
<c_expr_t
, va_gc
> *cexpr_list
;
6990 c_expr_t
*e1_p
, *e2_p
;
6992 c_parser_consume_token (parser
);
6993 if (!c_parser_get_builtin_args (parser
,
6994 "__builtin_complex",
6995 &cexpr_list
, false))
6997 expr
.value
= error_mark_node
;
7001 if (vec_safe_length (cexpr_list
) != 2)
7003 error_at (loc
, "wrong number of arguments to "
7004 "%<__builtin_complex%>");
7005 expr
.value
= error_mark_node
;
7009 e1_p
= &(*cexpr_list
)[0];
7010 e2_p
= &(*cexpr_list
)[1];
7012 mark_exp_read (e1_p
->value
);
7013 if (TREE_CODE (e1_p
->value
) == EXCESS_PRECISION_EXPR
)
7014 e1_p
->value
= convert (TREE_TYPE (e1_p
->value
),
7015 TREE_OPERAND (e1_p
->value
, 0));
7016 mark_exp_read (e2_p
->value
);
7017 if (TREE_CODE (e2_p
->value
) == EXCESS_PRECISION_EXPR
)
7018 e2_p
->value
= convert (TREE_TYPE (e2_p
->value
),
7019 TREE_OPERAND (e2_p
->value
, 0));
7020 if (!SCALAR_FLOAT_TYPE_P (TREE_TYPE (e1_p
->value
))
7021 || DECIMAL_FLOAT_TYPE_P (TREE_TYPE (e1_p
->value
))
7022 || !SCALAR_FLOAT_TYPE_P (TREE_TYPE (e2_p
->value
))
7023 || DECIMAL_FLOAT_TYPE_P (TREE_TYPE (e2_p
->value
)))
7025 error_at (loc
, "%<__builtin_complex%> operand "
7026 "not of real binary floating-point type");
7027 expr
.value
= error_mark_node
;
7030 if (TYPE_MAIN_VARIANT (TREE_TYPE (e1_p
->value
))
7031 != TYPE_MAIN_VARIANT (TREE_TYPE (e2_p
->value
)))
7034 "%<__builtin_complex%> operands of different types");
7035 expr
.value
= error_mark_node
;
7039 pedwarn (loc
, OPT_Wpedantic
,
7040 "ISO C90 does not support complex types");
7041 expr
.value
= build2 (COMPLEX_EXPR
,
7044 (TREE_TYPE (e1_p
->value
))),
7045 e1_p
->value
, e2_p
->value
);
7048 case RID_BUILTIN_SHUFFLE
:
7050 vec
<c_expr_t
, va_gc
> *cexpr_list
;
7054 c_parser_consume_token (parser
);
7055 if (!c_parser_get_builtin_args (parser
,
7056 "__builtin_shuffle",
7057 &cexpr_list
, false))
7059 expr
.value
= error_mark_node
;
7063 FOR_EACH_VEC_SAFE_ELT (cexpr_list
, i
, p
)
7064 mark_exp_read (p
->value
);
7066 if (vec_safe_length (cexpr_list
) == 2)
7068 c_build_vec_perm_expr
7069 (loc
, (*cexpr_list
)[0].value
,
7070 NULL_TREE
, (*cexpr_list
)[1].value
);
7072 else if (vec_safe_length (cexpr_list
) == 3)
7074 c_build_vec_perm_expr
7075 (loc
, (*cexpr_list
)[0].value
,
7076 (*cexpr_list
)[1].value
,
7077 (*cexpr_list
)[2].value
);
7080 error_at (loc
, "wrong number of arguments to "
7081 "%<__builtin_shuffle%>");
7082 expr
.value
= error_mark_node
;
7086 case RID_AT_SELECTOR
:
7087 gcc_assert (c_dialect_objc ());
7088 c_parser_consume_token (parser
);
7089 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
7091 expr
.value
= error_mark_node
;
7095 tree sel
= c_parser_objc_selector_arg (parser
);
7096 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
7098 expr
.value
= objc_build_selector_expr (loc
, sel
);
7101 case RID_AT_PROTOCOL
:
7102 gcc_assert (c_dialect_objc ());
7103 c_parser_consume_token (parser
);
7104 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
7106 expr
.value
= error_mark_node
;
7109 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
7111 c_parser_error (parser
, "expected identifier");
7112 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
7113 expr
.value
= error_mark_node
;
7117 tree id
= c_parser_peek_token (parser
)->value
;
7118 c_parser_consume_token (parser
);
7119 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
7121 expr
.value
= objc_build_protocol_expr (id
);
7125 /* Extension to support C-structures in the archiver. */
7126 gcc_assert (c_dialect_objc ());
7127 c_parser_consume_token (parser
);
7128 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
7130 expr
.value
= error_mark_node
;
7133 t1
= c_parser_type_name (parser
);
7136 expr
.value
= error_mark_node
;
7137 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
7140 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
7143 tree type
= groktypename (t1
, NULL
, NULL
);
7144 expr
.value
= objc_build_encode_expr (type
);
7148 expr
= c_parser_generic_selection (parser
);
7151 c_parser_error (parser
, "expected expression");
7152 expr
.value
= error_mark_node
;
7156 case CPP_OPEN_SQUARE
:
7157 if (c_dialect_objc ())
7159 tree receiver
, args
;
7160 c_parser_consume_token (parser
);
7161 receiver
= c_parser_objc_receiver (parser
);
7162 args
= c_parser_objc_message_args (parser
);
7163 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
7165 expr
.value
= objc_build_message_expr (receiver
, args
);
7168 /* Else fall through to report error. */
7170 c_parser_error (parser
, "expected expression");
7171 expr
.value
= error_mark_node
;
7174 return c_parser_postfix_expression_after_primary (parser
, loc
, expr
);
7177 /* Parse a postfix expression after a parenthesized type name: the
7178 brace-enclosed initializer of a compound literal, possibly followed
7179 by some postfix operators. This is separate because it is not
7180 possible to tell until after the type name whether a cast
7181 expression has a cast or a compound literal, or whether the operand
7182 of sizeof is a parenthesized type name or starts with a compound
7183 literal. TYPE_LOC is the location where TYPE_NAME starts--the
7184 location of the first token after the parentheses around the type
7187 static struct c_expr
7188 c_parser_postfix_expression_after_paren_type (c_parser
*parser
,
7189 struct c_type_name
*type_name
,
7190 location_t type_loc
)
7196 location_t start_loc
;
7197 tree type_expr
= NULL_TREE
;
7198 bool type_expr_const
= true;
7199 check_compound_literal_type (type_loc
, type_name
);
7200 start_init (NULL_TREE
, NULL
, 0);
7201 type
= groktypename (type_name
, &type_expr
, &type_expr_const
);
7202 start_loc
= c_parser_peek_token (parser
)->location
;
7203 if (type
!= error_mark_node
&& C_TYPE_VARIABLE_SIZE (type
))
7205 error_at (type_loc
, "compound literal has variable size");
7206 type
= error_mark_node
;
7208 init
= c_parser_braced_init (parser
, type
, false);
7210 maybe_warn_string_init (type
, init
);
7212 if (type
!= error_mark_node
7213 && !ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (type
))
7214 && current_function_decl
)
7216 error ("compound literal qualified by address-space qualifier");
7217 type
= error_mark_node
;
7221 pedwarn (start_loc
, OPT_Wpedantic
, "ISO C90 forbids compound literals");
7222 non_const
= ((init
.value
&& TREE_CODE (init
.value
) == CONSTRUCTOR
)
7223 ? CONSTRUCTOR_NON_CONST (init
.value
)
7224 : init
.original_code
== C_MAYBE_CONST_EXPR
);
7225 non_const
|= !type_expr_const
;
7226 expr
.value
= build_compound_literal (start_loc
, type
, init
.value
, non_const
);
7227 expr
.original_code
= ERROR_MARK
;
7228 expr
.original_type
= NULL
;
7231 if (TREE_CODE (expr
.value
) == C_MAYBE_CONST_EXPR
)
7233 gcc_assert (C_MAYBE_CONST_EXPR_PRE (expr
.value
) == NULL_TREE
);
7234 C_MAYBE_CONST_EXPR_PRE (expr
.value
) = type_expr
;
7238 gcc_assert (!non_const
);
7239 expr
.value
= build2 (C_MAYBE_CONST_EXPR
, type
,
7240 type_expr
, expr
.value
);
7243 return c_parser_postfix_expression_after_primary (parser
, start_loc
, expr
);
7246 /* Callback function for sizeof_pointer_memaccess_warning to compare
7250 sizeof_ptr_memacc_comptypes (tree type1
, tree type2
)
7252 return comptypes (type1
, type2
) == 1;
7255 /* Parse a postfix expression after the initial primary or compound
7256 literal; that is, parse a series of postfix operators.
7258 EXPR_LOC is the location of the primary expression. */
7260 static struct c_expr
7261 c_parser_postfix_expression_after_primary (c_parser
*parser
,
7262 location_t expr_loc
,
7265 struct c_expr orig_expr
;
7267 location_t sizeof_arg_loc
[3];
7270 vec
<tree
, va_gc
> *exprlist
;
7271 vec
<tree
, va_gc
> *origtypes
= NULL
;
7274 location_t op_loc
= c_parser_peek_token (parser
)->location
;
7275 switch (c_parser_peek_token (parser
)->type
)
7277 case CPP_OPEN_SQUARE
:
7278 /* Array reference. */
7279 c_parser_consume_token (parser
);
7280 if (flag_enable_cilkplus
7281 && c_parser_peek_token (parser
)->type
== CPP_COLON
)
7282 /* If we are here, then we have something like this:
7285 expr
.value
= c_parser_array_notation (expr_loc
, parser
, NULL_TREE
,
7289 idx
= c_parser_expression (parser
).value
;
7290 /* Here we have 3 options:
7291 1. Array [EXPR] -- Normal Array call.
7292 2. Array [EXPR : EXPR] -- Array notation without stride.
7293 3. Array [EXPR : EXPR : EXPR] -- Array notation with stride.
7295 For 1, we just handle it just like a normal array expression.
7296 For 2 and 3 we handle it like we handle array notations. The
7297 idx value we have above becomes the initial/start index.
7299 if (flag_enable_cilkplus
7300 && c_parser_peek_token (parser
)->type
== CPP_COLON
)
7301 expr
.value
= c_parser_array_notation (expr_loc
, parser
, idx
,
7305 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
7307 expr
.value
= build_array_ref (op_loc
, expr
.value
, idx
);
7310 expr
.original_code
= ERROR_MARK
;
7311 expr
.original_type
= NULL
;
7313 case CPP_OPEN_PAREN
:
7314 /* Function call. */
7315 c_parser_consume_token (parser
);
7316 for (i
= 0; i
< 3; i
++)
7318 sizeof_arg
[i
] = NULL_TREE
;
7319 sizeof_arg_loc
[i
] = UNKNOWN_LOCATION
;
7321 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
7324 exprlist
= c_parser_expr_list (parser
, true, false, &origtypes
,
7325 sizeof_arg_loc
, sizeof_arg
);
7326 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
7329 mark_exp_read (expr
.value
);
7330 if (warn_sizeof_pointer_memaccess
)
7331 sizeof_pointer_memaccess_warning (sizeof_arg_loc
,
7332 expr
.value
, exprlist
,
7334 sizeof_ptr_memacc_comptypes
);
7335 /* FIXME diagnostics: Ideally we want the FUNCNAME, not the
7336 "(" after the FUNCNAME, which is what we have now. */
7337 expr
.value
= build_function_call_vec (op_loc
, expr
.value
, exprlist
,
7339 expr
.original_code
= ERROR_MARK
;
7340 if (TREE_CODE (expr
.value
) == INTEGER_CST
7341 && TREE_CODE (orig_expr
.value
) == FUNCTION_DECL
7342 && DECL_BUILT_IN_CLASS (orig_expr
.value
) == BUILT_IN_NORMAL
7343 && DECL_FUNCTION_CODE (orig_expr
.value
) == BUILT_IN_CONSTANT_P
)
7344 expr
.original_code
= C_MAYBE_CONST_EXPR
;
7345 expr
.original_type
= NULL
;
7348 release_tree_vector (exprlist
);
7349 release_tree_vector (origtypes
);
7353 /* Structure element reference. */
7354 c_parser_consume_token (parser
);
7355 expr
= default_function_array_conversion (expr_loc
, expr
);
7356 if (c_parser_next_token_is (parser
, CPP_NAME
))
7357 ident
= c_parser_peek_token (parser
)->value
;
7360 c_parser_error (parser
, "expected identifier");
7361 expr
.value
= error_mark_node
;
7362 expr
.original_code
= ERROR_MARK
;
7363 expr
.original_type
= NULL
;
7366 c_parser_consume_token (parser
);
7367 expr
.value
= build_component_ref (op_loc
, expr
.value
, ident
);
7368 expr
.original_code
= ERROR_MARK
;
7369 if (TREE_CODE (expr
.value
) != COMPONENT_REF
)
7370 expr
.original_type
= NULL
;
7373 /* Remember the original type of a bitfield. */
7374 tree field
= TREE_OPERAND (expr
.value
, 1);
7375 if (TREE_CODE (field
) != FIELD_DECL
)
7376 expr
.original_type
= NULL
;
7378 expr
.original_type
= DECL_BIT_FIELD_TYPE (field
);
7382 /* Structure element reference. */
7383 c_parser_consume_token (parser
);
7384 expr
= default_function_array_conversion (expr_loc
, expr
);
7385 if (c_parser_next_token_is (parser
, CPP_NAME
))
7386 ident
= c_parser_peek_token (parser
)->value
;
7389 c_parser_error (parser
, "expected identifier");
7390 expr
.value
= error_mark_node
;
7391 expr
.original_code
= ERROR_MARK
;
7392 expr
.original_type
= NULL
;
7395 c_parser_consume_token (parser
);
7396 expr
.value
= build_component_ref (op_loc
,
7397 build_indirect_ref (op_loc
,
7401 expr
.original_code
= ERROR_MARK
;
7402 if (TREE_CODE (expr
.value
) != COMPONENT_REF
)
7403 expr
.original_type
= NULL
;
7406 /* Remember the original type of a bitfield. */
7407 tree field
= TREE_OPERAND (expr
.value
, 1);
7408 if (TREE_CODE (field
) != FIELD_DECL
)
7409 expr
.original_type
= NULL
;
7411 expr
.original_type
= DECL_BIT_FIELD_TYPE (field
);
7415 /* Postincrement. */
7416 c_parser_consume_token (parser
);
7417 /* If the expressions have array notations, we expand them. */
7418 if (flag_enable_cilkplus
7419 && TREE_CODE (expr
.value
) == ARRAY_NOTATION_REF
)
7420 expr
= fix_array_notation_expr (expr_loc
, POSTINCREMENT_EXPR
, expr
);
7423 expr
= default_function_array_read_conversion (expr_loc
, expr
);
7424 expr
.value
= build_unary_op (op_loc
,
7425 POSTINCREMENT_EXPR
, expr
.value
, 0);
7427 expr
.original_code
= ERROR_MARK
;
7428 expr
.original_type
= NULL
;
7430 case CPP_MINUS_MINUS
:
7431 /* Postdecrement. */
7432 c_parser_consume_token (parser
);
7433 /* If the expressions have array notations, we expand them. */
7434 if (flag_enable_cilkplus
7435 && TREE_CODE (expr
.value
) == ARRAY_NOTATION_REF
)
7436 expr
= fix_array_notation_expr (expr_loc
, POSTDECREMENT_EXPR
, expr
);
7439 expr
= default_function_array_read_conversion (expr_loc
, expr
);
7440 expr
.value
= build_unary_op (op_loc
,
7441 POSTDECREMENT_EXPR
, expr
.value
, 0);
7443 expr
.original_code
= ERROR_MARK
;
7444 expr
.original_type
= NULL
;
7452 /* Parse an expression (C90 6.3.17, C99 6.5.17).
7455 assignment-expression
7456 expression , assignment-expression
7459 static struct c_expr
7460 c_parser_expression (c_parser
*parser
)
7463 expr
= c_parser_expr_no_commas (parser
, NULL
);
7464 while (c_parser_next_token_is (parser
, CPP_COMMA
))
7468 location_t loc
= c_parser_peek_token (parser
)->location
;
7469 location_t expr_loc
;
7470 c_parser_consume_token (parser
);
7471 expr_loc
= c_parser_peek_token (parser
)->location
;
7472 lhsval
= expr
.value
;
7473 while (TREE_CODE (lhsval
) == COMPOUND_EXPR
)
7474 lhsval
= TREE_OPERAND (lhsval
, 1);
7475 if (DECL_P (lhsval
) || handled_component_p (lhsval
))
7476 mark_exp_read (lhsval
);
7477 next
= c_parser_expr_no_commas (parser
, NULL
);
7478 next
= default_function_array_conversion (expr_loc
, next
);
7479 expr
.value
= build_compound_expr (loc
, expr
.value
, next
.value
);
7480 expr
.original_code
= COMPOUND_EXPR
;
7481 expr
.original_type
= next
.original_type
;
7486 /* Parse an expression and convert functions or arrays to
7489 static struct c_expr
7490 c_parser_expression_conv (c_parser
*parser
)
7493 location_t loc
= c_parser_peek_token (parser
)->location
;
7494 expr
= c_parser_expression (parser
);
7495 expr
= default_function_array_conversion (loc
, expr
);
7499 /* Parse a non-empty list of expressions. If CONVERT_P, convert
7500 functions and arrays to pointers. If FOLD_P, fold the expressions.
7503 assignment-expression
7504 nonempty-expr-list , assignment-expression
7507 static vec
<tree
, va_gc
> *
7508 c_parser_expr_list (c_parser
*parser
, bool convert_p
, bool fold_p
,
7509 vec
<tree
, va_gc
> **p_orig_types
,
7510 location_t
*sizeof_arg_loc
, tree
*sizeof_arg
)
7512 vec
<tree
, va_gc
> *ret
;
7513 vec
<tree
, va_gc
> *orig_types
;
7515 location_t loc
= c_parser_peek_token (parser
)->location
;
7516 location_t cur_sizeof_arg_loc
= UNKNOWN_LOCATION
;
7517 unsigned int idx
= 0;
7519 ret
= make_tree_vector ();
7520 if (p_orig_types
== NULL
)
7523 orig_types
= make_tree_vector ();
7525 if (sizeof_arg
!= NULL
7526 && c_parser_next_token_is_keyword (parser
, RID_SIZEOF
))
7527 cur_sizeof_arg_loc
= c_parser_peek_2nd_token (parser
)->location
;
7528 expr
= c_parser_expr_no_commas (parser
, NULL
);
7530 expr
= default_function_array_read_conversion (loc
, expr
);
7532 expr
.value
= c_fully_fold (expr
.value
, false, NULL
);
7533 ret
->quick_push (expr
.value
);
7535 orig_types
->quick_push (expr
.original_type
);
7536 if (sizeof_arg
!= NULL
7537 && cur_sizeof_arg_loc
!= UNKNOWN_LOCATION
7538 && expr
.original_code
== SIZEOF_EXPR
)
7540 sizeof_arg
[0] = c_last_sizeof_arg
;
7541 sizeof_arg_loc
[0] = cur_sizeof_arg_loc
;
7543 while (c_parser_next_token_is (parser
, CPP_COMMA
))
7545 c_parser_consume_token (parser
);
7546 loc
= c_parser_peek_token (parser
)->location
;
7547 if (sizeof_arg
!= NULL
7548 && c_parser_next_token_is_keyword (parser
, RID_SIZEOF
))
7549 cur_sizeof_arg_loc
= c_parser_peek_2nd_token (parser
)->location
;
7551 cur_sizeof_arg_loc
= UNKNOWN_LOCATION
;
7552 expr
= c_parser_expr_no_commas (parser
, NULL
);
7554 expr
= default_function_array_read_conversion (loc
, expr
);
7556 expr
.value
= c_fully_fold (expr
.value
, false, NULL
);
7557 vec_safe_push (ret
, expr
.value
);
7559 vec_safe_push (orig_types
, expr
.original_type
);
7561 && sizeof_arg
!= NULL
7562 && cur_sizeof_arg_loc
!= UNKNOWN_LOCATION
7563 && expr
.original_code
== SIZEOF_EXPR
)
7565 sizeof_arg
[idx
] = c_last_sizeof_arg
;
7566 sizeof_arg_loc
[idx
] = cur_sizeof_arg_loc
;
7570 *p_orig_types
= orig_types
;
7574 /* Parse Objective-C-specific constructs. */
7576 /* Parse an objc-class-definition.
7578 objc-class-definition:
7579 @interface identifier objc-superclass[opt] objc-protocol-refs[opt]
7580 objc-class-instance-variables[opt] objc-methodprotolist @end
7581 @implementation identifier objc-superclass[opt]
7582 objc-class-instance-variables[opt]
7583 @interface identifier ( identifier ) objc-protocol-refs[opt]
7584 objc-methodprotolist @end
7585 @interface identifier ( ) objc-protocol-refs[opt]
7586 objc-methodprotolist @end
7587 @implementation identifier ( identifier )
7592 "@interface identifier (" must start "@interface identifier (
7593 identifier ) ...": objc-methodprotolist in the first production may
7594 not start with a parenthesized identifier as a declarator of a data
7595 definition with no declaration specifiers if the objc-superclass,
7596 objc-protocol-refs and objc-class-instance-variables are omitted. */
7599 c_parser_objc_class_definition (c_parser
*parser
, tree attributes
)
7604 if (c_parser_next_token_is_keyword (parser
, RID_AT_INTERFACE
))
7606 else if (c_parser_next_token_is_keyword (parser
, RID_AT_IMPLEMENTATION
))
7611 c_parser_consume_token (parser
);
7612 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
7614 c_parser_error (parser
, "expected identifier");
7617 id1
= c_parser_peek_token (parser
)->value
;
7618 c_parser_consume_token (parser
);
7619 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
7621 /* We have a category or class extension. */
7623 tree proto
= NULL_TREE
;
7624 c_parser_consume_token (parser
);
7625 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
7627 if (iface_p
&& c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
7629 /* We have a class extension. */
7634 c_parser_error (parser
, "expected identifier or %<)%>");
7635 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
7641 id2
= c_parser_peek_token (parser
)->value
;
7642 c_parser_consume_token (parser
);
7644 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
7647 objc_start_category_implementation (id1
, id2
);
7650 if (c_parser_next_token_is (parser
, CPP_LESS
))
7651 proto
= c_parser_objc_protocol_refs (parser
);
7652 objc_start_category_interface (id1
, id2
, proto
, attributes
);
7653 c_parser_objc_methodprotolist (parser
);
7654 c_parser_require_keyword (parser
, RID_AT_END
, "expected %<@end%>");
7655 objc_finish_interface ();
7658 if (c_parser_next_token_is (parser
, CPP_COLON
))
7660 c_parser_consume_token (parser
);
7661 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
7663 c_parser_error (parser
, "expected identifier");
7666 superclass
= c_parser_peek_token (parser
)->value
;
7667 c_parser_consume_token (parser
);
7670 superclass
= NULL_TREE
;
7673 tree proto
= NULL_TREE
;
7674 if (c_parser_next_token_is (parser
, CPP_LESS
))
7675 proto
= c_parser_objc_protocol_refs (parser
);
7676 objc_start_class_interface (id1
, superclass
, proto
, attributes
);
7679 objc_start_class_implementation (id1
, superclass
);
7680 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
7681 c_parser_objc_class_instance_variables (parser
);
7684 objc_continue_interface ();
7685 c_parser_objc_methodprotolist (parser
);
7686 c_parser_require_keyword (parser
, RID_AT_END
, "expected %<@end%>");
7687 objc_finish_interface ();
7691 objc_continue_implementation ();
7696 /* Parse objc-class-instance-variables.
7698 objc-class-instance-variables:
7699 { objc-instance-variable-decl-list[opt] }
7701 objc-instance-variable-decl-list:
7702 objc-visibility-spec
7703 objc-instance-variable-decl ;
7705 objc-instance-variable-decl-list objc-visibility-spec
7706 objc-instance-variable-decl-list objc-instance-variable-decl ;
7707 objc-instance-variable-decl-list ;
7709 objc-visibility-spec:
7714 objc-instance-variable-decl:
7719 c_parser_objc_class_instance_variables (c_parser
*parser
)
7721 gcc_assert (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
));
7722 c_parser_consume_token (parser
);
7723 while (c_parser_next_token_is_not (parser
, CPP_EOF
))
7726 /* Parse any stray semicolon. */
7727 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
7729 pedwarn (c_parser_peek_token (parser
)->location
, OPT_Wpedantic
,
7731 c_parser_consume_token (parser
);
7734 /* Stop if at the end of the instance variables. */
7735 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
7737 c_parser_consume_token (parser
);
7740 /* Parse any objc-visibility-spec. */
7741 if (c_parser_next_token_is_keyword (parser
, RID_AT_PRIVATE
))
7743 c_parser_consume_token (parser
);
7744 objc_set_visibility (OBJC_IVAR_VIS_PRIVATE
);
7747 else if (c_parser_next_token_is_keyword (parser
, RID_AT_PROTECTED
))
7749 c_parser_consume_token (parser
);
7750 objc_set_visibility (OBJC_IVAR_VIS_PROTECTED
);
7753 else if (c_parser_next_token_is_keyword (parser
, RID_AT_PUBLIC
))
7755 c_parser_consume_token (parser
);
7756 objc_set_visibility (OBJC_IVAR_VIS_PUBLIC
);
7759 else if (c_parser_next_token_is_keyword (parser
, RID_AT_PACKAGE
))
7761 c_parser_consume_token (parser
);
7762 objc_set_visibility (OBJC_IVAR_VIS_PACKAGE
);
7765 else if (c_parser_next_token_is (parser
, CPP_PRAGMA
))
7767 c_parser_pragma (parser
, pragma_external
);
7771 /* Parse some comma-separated declarations. */
7772 decls
= c_parser_struct_declaration (parser
);
7775 /* There is a syntax error. We want to skip the offending
7776 tokens up to the next ';' (included) or '}'
7779 /* First, skip manually a ')' or ']'. This is because they
7780 reduce the nesting level, so c_parser_skip_until_found()
7781 wouldn't be able to skip past them. */
7782 c_token
*token
= c_parser_peek_token (parser
);
7783 if (token
->type
== CPP_CLOSE_PAREN
|| token
->type
== CPP_CLOSE_SQUARE
)
7784 c_parser_consume_token (parser
);
7786 /* Then, do the standard skipping. */
7787 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, NULL
);
7789 /* We hopefully recovered. Start normal parsing again. */
7790 parser
->error
= false;
7795 /* Comma-separated instance variables are chained together
7796 in reverse order; add them one by one. */
7797 tree ivar
= nreverse (decls
);
7798 for (; ivar
; ivar
= DECL_CHAIN (ivar
))
7799 objc_add_instance_variable (copy_node (ivar
));
7801 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
7805 /* Parse an objc-class-declaration.
7807 objc-class-declaration:
7808 @class identifier-list ;
7812 c_parser_objc_class_declaration (c_parser
*parser
)
7814 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_AT_CLASS
));
7815 c_parser_consume_token (parser
);
7816 /* Any identifiers, including those declared as type names, are OK
7821 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
7823 c_parser_error (parser
, "expected identifier");
7824 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, NULL
);
7825 parser
->error
= false;
7828 id
= c_parser_peek_token (parser
)->value
;
7829 objc_declare_class (id
);
7830 c_parser_consume_token (parser
);
7831 if (c_parser_next_token_is (parser
, CPP_COMMA
))
7832 c_parser_consume_token (parser
);
7836 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
7839 /* Parse an objc-alias-declaration.
7841 objc-alias-declaration:
7842 @compatibility_alias identifier identifier ;
7846 c_parser_objc_alias_declaration (c_parser
*parser
)
7849 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_AT_ALIAS
));
7850 c_parser_consume_token (parser
);
7851 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
7853 c_parser_error (parser
, "expected identifier");
7854 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, NULL
);
7857 id1
= c_parser_peek_token (parser
)->value
;
7858 c_parser_consume_token (parser
);
7859 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
7861 c_parser_error (parser
, "expected identifier");
7862 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, NULL
);
7865 id2
= c_parser_peek_token (parser
)->value
;
7866 c_parser_consume_token (parser
);
7867 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
7868 objc_declare_alias (id1
, id2
);
7871 /* Parse an objc-protocol-definition.
7873 objc-protocol-definition:
7874 @protocol identifier objc-protocol-refs[opt] objc-methodprotolist @end
7875 @protocol identifier-list ;
7877 "@protocol identifier ;" should be resolved as "@protocol
7878 identifier-list ;": objc-methodprotolist may not start with a
7879 semicolon in the first alternative if objc-protocol-refs are
7883 c_parser_objc_protocol_definition (c_parser
*parser
, tree attributes
)
7885 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_AT_PROTOCOL
));
7887 c_parser_consume_token (parser
);
7888 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
7890 c_parser_error (parser
, "expected identifier");
7893 if (c_parser_peek_2nd_token (parser
)->type
== CPP_COMMA
7894 || c_parser_peek_2nd_token (parser
)->type
== CPP_SEMICOLON
)
7896 /* Any identifiers, including those declared as type names, are
7901 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
7903 c_parser_error (parser
, "expected identifier");
7906 id
= c_parser_peek_token (parser
)->value
;
7907 objc_declare_protocol (id
, attributes
);
7908 c_parser_consume_token (parser
);
7909 if (c_parser_next_token_is (parser
, CPP_COMMA
))
7910 c_parser_consume_token (parser
);
7914 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
7918 tree id
= c_parser_peek_token (parser
)->value
;
7919 tree proto
= NULL_TREE
;
7920 c_parser_consume_token (parser
);
7921 if (c_parser_next_token_is (parser
, CPP_LESS
))
7922 proto
= c_parser_objc_protocol_refs (parser
);
7923 parser
->objc_pq_context
= true;
7924 objc_start_protocol (id
, proto
, attributes
);
7925 c_parser_objc_methodprotolist (parser
);
7926 c_parser_require_keyword (parser
, RID_AT_END
, "expected %<@end%>");
7927 parser
->objc_pq_context
= false;
7928 objc_finish_interface ();
7932 /* Parse an objc-method-type.
7938 Return true if it is a class method (+) and false if it is
7939 an instance method (-).
7942 c_parser_objc_method_type (c_parser
*parser
)
7944 switch (c_parser_peek_token (parser
)->type
)
7947 c_parser_consume_token (parser
);
7950 c_parser_consume_token (parser
);
7957 /* Parse an objc-method-definition.
7959 objc-method-definition:
7960 objc-method-type objc-method-decl ;[opt] compound-statement
7964 c_parser_objc_method_definition (c_parser
*parser
)
7966 bool is_class_method
= c_parser_objc_method_type (parser
);
7967 tree decl
, attributes
= NULL_TREE
, expr
= NULL_TREE
;
7968 parser
->objc_pq_context
= true;
7969 decl
= c_parser_objc_method_decl (parser
, is_class_method
, &attributes
,
7971 if (decl
== error_mark_node
)
7972 return; /* Bail here. */
7974 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
7976 c_parser_consume_token (parser
);
7977 pedwarn (c_parser_peek_token (parser
)->location
, OPT_Wpedantic
,
7978 "extra semicolon in method definition specified");
7981 if (!c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
7983 c_parser_error (parser
, "expected %<{%>");
7987 parser
->objc_pq_context
= false;
7988 if (objc_start_method_definition (is_class_method
, decl
, attributes
, expr
))
7990 add_stmt (c_parser_compound_statement (parser
));
7991 objc_finish_method_definition (current_function_decl
);
7995 /* This code is executed when we find a method definition
7996 outside of an @implementation context (or invalid for other
7997 reasons). Parse the method (to keep going) but do not emit
8000 c_parser_compound_statement (parser
);
8004 /* Parse an objc-methodprotolist.
8006 objc-methodprotolist:
8008 objc-methodprotolist objc-methodproto
8009 objc-methodprotolist declaration
8010 objc-methodprotolist ;
8014 The declaration is a data definition, which may be missing
8015 declaration specifiers under the same rules and diagnostics as
8016 other data definitions outside functions, and the stray semicolon
8017 is diagnosed the same way as a stray semicolon outside a
8021 c_parser_objc_methodprotolist (c_parser
*parser
)
8025 /* The list is terminated by @end. */
8026 switch (c_parser_peek_token (parser
)->type
)
8029 pedwarn (c_parser_peek_token (parser
)->location
, OPT_Wpedantic
,
8030 "ISO C does not allow extra %<;%> outside of a function");
8031 c_parser_consume_token (parser
);
8035 c_parser_objc_methodproto (parser
);
8038 c_parser_pragma (parser
, pragma_external
);
8043 if (c_parser_next_token_is_keyword (parser
, RID_AT_END
))
8045 else if (c_parser_next_token_is_keyword (parser
, RID_AT_PROPERTY
))
8046 c_parser_objc_at_property_declaration (parser
);
8047 else if (c_parser_next_token_is_keyword (parser
, RID_AT_OPTIONAL
))
8049 objc_set_method_opt (true);
8050 c_parser_consume_token (parser
);
8052 else if (c_parser_next_token_is_keyword (parser
, RID_AT_REQUIRED
))
8054 objc_set_method_opt (false);
8055 c_parser_consume_token (parser
);
8058 c_parser_declaration_or_fndef (parser
, false, false, true,
8059 false, true, NULL
, vNULL
);
8065 /* Parse an objc-methodproto.
8068 objc-method-type objc-method-decl ;
8072 c_parser_objc_methodproto (c_parser
*parser
)
8074 bool is_class_method
= c_parser_objc_method_type (parser
);
8075 tree decl
, attributes
= NULL_TREE
;
8077 /* Remember protocol qualifiers in prototypes. */
8078 parser
->objc_pq_context
= true;
8079 decl
= c_parser_objc_method_decl (parser
, is_class_method
, &attributes
,
8081 /* Forget protocol qualifiers now. */
8082 parser
->objc_pq_context
= false;
8084 /* Do not allow the presence of attributes to hide an erroneous
8085 method implementation in the interface section. */
8086 if (!c_parser_next_token_is (parser
, CPP_SEMICOLON
))
8088 c_parser_error (parser
, "expected %<;%>");
8092 if (decl
!= error_mark_node
)
8093 objc_add_method_declaration (is_class_method
, decl
, attributes
);
8095 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
8098 /* If we are at a position that method attributes may be present, check that
8099 there are not any parsed already (a syntax error) and then collect any
8100 specified at the current location. Finally, if new attributes were present,
8101 check that the next token is legal ( ';' for decls and '{' for defs). */
8104 c_parser_objc_maybe_method_attributes (c_parser
* parser
, tree
* attributes
)
8109 c_parser_error (parser
,
8110 "method attributes must be specified at the end only");
8111 *attributes
= NULL_TREE
;
8115 if (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
8116 *attributes
= c_parser_attributes (parser
);
8118 /* If there were no attributes here, just report any earlier error. */
8119 if (*attributes
== NULL_TREE
|| bad
)
8122 /* If the attributes are followed by a ; or {, then just report any earlier
8124 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
)
8125 || c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
8128 /* We've got attributes, but not at the end. */
8129 c_parser_error (parser
,
8130 "expected %<;%> or %<{%> after method attribute definition");
8134 /* Parse an objc-method-decl.
8137 ( objc-type-name ) objc-selector
8139 ( objc-type-name ) objc-keyword-selector objc-optparmlist
8140 objc-keyword-selector objc-optparmlist
8143 objc-keyword-selector:
8145 objc-keyword-selector objc-keyword-decl
8148 objc-selector : ( objc-type-name ) identifier
8149 objc-selector : identifier
8150 : ( objc-type-name ) identifier
8154 objc-optparms objc-optellipsis
8158 objc-opt-parms , parameter-declaration
8166 c_parser_objc_method_decl (c_parser
*parser
, bool is_class_method
,
8167 tree
*attributes
, tree
*expr
)
8169 tree type
= NULL_TREE
;
8171 tree parms
= NULL_TREE
;
8172 bool ellipsis
= false;
8173 bool attr_err
= false;
8175 *attributes
= NULL_TREE
;
8176 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
8178 c_parser_consume_token (parser
);
8179 type
= c_parser_objc_type_name (parser
);
8180 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
8182 sel
= c_parser_objc_selector (parser
);
8183 /* If there is no selector, or a colon follows, we have an
8184 objc-keyword-selector. If there is a selector, and a colon does
8185 not follow, that selector ends the objc-method-decl. */
8186 if (!sel
|| c_parser_next_token_is (parser
, CPP_COLON
))
8189 tree list
= NULL_TREE
;
8192 tree atype
= NULL_TREE
, id
, keyworddecl
;
8193 tree param_attr
= NULL_TREE
;
8194 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
8196 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
8198 c_parser_consume_token (parser
);
8199 atype
= c_parser_objc_type_name (parser
);
8200 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
8203 /* New ObjC allows attributes on method parameters. */
8204 if (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
8205 param_attr
= c_parser_attributes (parser
);
8206 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
8208 c_parser_error (parser
, "expected identifier");
8209 return error_mark_node
;
8211 id
= c_parser_peek_token (parser
)->value
;
8212 c_parser_consume_token (parser
);
8213 keyworddecl
= objc_build_keyword_decl (tsel
, atype
, id
, param_attr
);
8214 list
= chainon (list
, keyworddecl
);
8215 tsel
= c_parser_objc_selector (parser
);
8216 if (!tsel
&& c_parser_next_token_is_not (parser
, CPP_COLON
))
8220 attr_err
|= c_parser_objc_maybe_method_attributes (parser
, attributes
) ;
8222 /* Parse the optional parameter list. Optional Objective-C
8223 method parameters follow the C syntax, and may include '...'
8224 to denote a variable number of arguments. */
8225 parms
= make_node (TREE_LIST
);
8226 while (c_parser_next_token_is (parser
, CPP_COMMA
))
8228 struct c_parm
*parm
;
8229 c_parser_consume_token (parser
);
8230 if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
))
8233 c_parser_consume_token (parser
);
8234 attr_err
|= c_parser_objc_maybe_method_attributes
8235 (parser
, attributes
) ;
8238 parm
= c_parser_parameter_declaration (parser
, NULL_TREE
);
8241 parms
= chainon (parms
,
8242 build_tree_list (NULL_TREE
, grokparm (parm
, expr
)));
8247 attr_err
|= c_parser_objc_maybe_method_attributes (parser
, attributes
) ;
8251 c_parser_error (parser
, "objective-c method declaration is expected");
8252 return error_mark_node
;
8256 return error_mark_node
;
8258 return objc_build_method_signature (is_class_method
, type
, sel
, parms
, ellipsis
);
8261 /* Parse an objc-type-name.
8264 objc-type-qualifiers[opt] type-name
8265 objc-type-qualifiers[opt]
8267 objc-type-qualifiers:
8269 objc-type-qualifiers objc-type-qualifier
8271 objc-type-qualifier: one of
8272 in out inout bycopy byref oneway
8276 c_parser_objc_type_name (c_parser
*parser
)
8278 tree quals
= NULL_TREE
;
8279 struct c_type_name
*type_name
= NULL
;
8280 tree type
= NULL_TREE
;
8283 c_token
*token
= c_parser_peek_token (parser
);
8284 if (token
->type
== CPP_KEYWORD
8285 && (token
->keyword
== RID_IN
8286 || token
->keyword
== RID_OUT
8287 || token
->keyword
== RID_INOUT
8288 || token
->keyword
== RID_BYCOPY
8289 || token
->keyword
== RID_BYREF
8290 || token
->keyword
== RID_ONEWAY
))
8292 quals
= chainon (build_tree_list (NULL_TREE
, token
->value
), quals
);
8293 c_parser_consume_token (parser
);
8298 if (c_parser_next_tokens_start_typename (parser
, cla_prefer_type
))
8299 type_name
= c_parser_type_name (parser
);
8301 type
= groktypename (type_name
, NULL
, NULL
);
8303 /* If the type is unknown, and error has already been produced and
8304 we need to recover from the error. In that case, use NULL_TREE
8305 for the type, as if no type had been specified; this will use the
8306 default type ('id') which is good for error recovery. */
8307 if (type
== error_mark_node
)
8310 return build_tree_list (quals
, type
);
8313 /* Parse objc-protocol-refs.
8320 c_parser_objc_protocol_refs (c_parser
*parser
)
8322 tree list
= NULL_TREE
;
8323 gcc_assert (c_parser_next_token_is (parser
, CPP_LESS
));
8324 c_parser_consume_token (parser
);
8325 /* Any identifiers, including those declared as type names, are OK
8330 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
8332 c_parser_error (parser
, "expected identifier");
8335 id
= c_parser_peek_token (parser
)->value
;
8336 list
= chainon (list
, build_tree_list (NULL_TREE
, id
));
8337 c_parser_consume_token (parser
);
8338 if (c_parser_next_token_is (parser
, CPP_COMMA
))
8339 c_parser_consume_token (parser
);
8343 c_parser_require (parser
, CPP_GREATER
, "expected %<>%>");
8347 /* Parse an objc-try-catch-finally-statement.
8349 objc-try-catch-finally-statement:
8350 @try compound-statement objc-catch-list[opt]
8351 @try compound-statement objc-catch-list[opt] @finally compound-statement
8354 @catch ( objc-catch-parameter-declaration ) compound-statement
8355 objc-catch-list @catch ( objc-catch-parameter-declaration ) compound-statement
8357 objc-catch-parameter-declaration:
8358 parameter-declaration
8361 where '...' is to be interpreted literally, that is, it means CPP_ELLIPSIS.
8363 PS: This function is identical to cp_parser_objc_try_catch_finally_statement
8364 for C++. Keep them in sync. */
8367 c_parser_objc_try_catch_finally_statement (c_parser
*parser
)
8369 location_t location
;
8372 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_AT_TRY
));
8373 c_parser_consume_token (parser
);
8374 location
= c_parser_peek_token (parser
)->location
;
8375 objc_maybe_warn_exceptions (location
);
8376 stmt
= c_parser_compound_statement (parser
);
8377 objc_begin_try_stmt (location
, stmt
);
8379 while (c_parser_next_token_is_keyword (parser
, RID_AT_CATCH
))
8381 struct c_parm
*parm
;
8382 tree parameter_declaration
= error_mark_node
;
8383 bool seen_open_paren
= false;
8385 c_parser_consume_token (parser
);
8386 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
8387 seen_open_paren
= true;
8388 if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
))
8390 /* We have "@catch (...)" (where the '...' are literally
8391 what is in the code). Skip the '...'.
8392 parameter_declaration is set to NULL_TREE, and
8393 objc_being_catch_clauses() knows that that means
8395 c_parser_consume_token (parser
);
8396 parameter_declaration
= NULL_TREE
;
8400 /* We have "@catch (NSException *exception)" or something
8401 like that. Parse the parameter declaration. */
8402 parm
= c_parser_parameter_declaration (parser
, NULL_TREE
);
8404 parameter_declaration
= error_mark_node
;
8406 parameter_declaration
= grokparm (parm
, NULL
);
8408 if (seen_open_paren
)
8409 c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
8412 /* If there was no open parenthesis, we are recovering from
8413 an error, and we are trying to figure out what mistake
8414 the user has made. */
8416 /* If there is an immediate closing parenthesis, the user
8417 probably forgot the opening one (ie, they typed "@catch
8418 NSException *e)". Parse the closing parenthesis and keep
8420 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
8421 c_parser_consume_token (parser
);
8423 /* If these is no immediate closing parenthesis, the user
8424 probably doesn't know that parenthesis are required at
8425 all (ie, they typed "@catch NSException *e"). So, just
8426 forget about the closing parenthesis and keep going. */
8428 objc_begin_catch_clause (parameter_declaration
);
8429 if (c_parser_require (parser
, CPP_OPEN_BRACE
, "expected %<{%>"))
8430 c_parser_compound_statement_nostart (parser
);
8431 objc_finish_catch_clause ();
8433 if (c_parser_next_token_is_keyword (parser
, RID_AT_FINALLY
))
8435 c_parser_consume_token (parser
);
8436 location
= c_parser_peek_token (parser
)->location
;
8437 stmt
= c_parser_compound_statement (parser
);
8438 objc_build_finally_clause (location
, stmt
);
8440 objc_finish_try_stmt ();
8443 /* Parse an objc-synchronized-statement.
8445 objc-synchronized-statement:
8446 @synchronized ( expression ) compound-statement
8450 c_parser_objc_synchronized_statement (c_parser
*parser
)
8454 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_AT_SYNCHRONIZED
));
8455 c_parser_consume_token (parser
);
8456 loc
= c_parser_peek_token (parser
)->location
;
8457 objc_maybe_warn_exceptions (loc
);
8458 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
8460 expr
= c_parser_expression (parser
).value
;
8461 expr
= c_fully_fold (expr
, false, NULL
);
8462 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
8465 expr
= error_mark_node
;
8466 stmt
= c_parser_compound_statement (parser
);
8467 objc_build_synchronized (loc
, expr
, stmt
);
8470 /* Parse an objc-selector; return NULL_TREE without an error if the
8471 next token is not an objc-selector.
8476 enum struct union if else while do for switch case default
8477 break continue return goto asm sizeof typeof __alignof
8478 unsigned long const short volatile signed restrict _Complex
8479 in out inout bycopy byref oneway int char float double void _Bool
8481 ??? Why this selection of keywords but not, for example, storage
8482 class specifiers? */
8485 c_parser_objc_selector (c_parser
*parser
)
8487 c_token
*token
= c_parser_peek_token (parser
);
8488 tree value
= token
->value
;
8489 if (token
->type
== CPP_NAME
)
8491 c_parser_consume_token (parser
);
8494 if (token
->type
!= CPP_KEYWORD
)
8496 switch (token
->keyword
)
8538 c_parser_consume_token (parser
);
8545 /* Parse an objc-selector-arg.
8549 objc-keywordname-list
8551 objc-keywordname-list:
8553 objc-keywordname-list objc-keywordname
8561 c_parser_objc_selector_arg (c_parser
*parser
)
8563 tree sel
= c_parser_objc_selector (parser
);
8564 tree list
= NULL_TREE
;
8565 if (sel
&& c_parser_next_token_is_not (parser
, CPP_COLON
))
8569 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
8571 list
= chainon (list
, build_tree_list (sel
, NULL_TREE
));
8572 sel
= c_parser_objc_selector (parser
);
8573 if (!sel
&& c_parser_next_token_is_not (parser
, CPP_COLON
))
8579 /* Parse an objc-receiver.
8588 c_parser_objc_receiver (c_parser
*parser
)
8590 if (c_parser_peek_token (parser
)->type
== CPP_NAME
8591 && (c_parser_peek_token (parser
)->id_kind
== C_ID_TYPENAME
8592 || c_parser_peek_token (parser
)->id_kind
== C_ID_CLASSNAME
))
8594 tree id
= c_parser_peek_token (parser
)->value
;
8595 c_parser_consume_token (parser
);
8596 return objc_get_class_reference (id
);
8598 return c_fully_fold (c_parser_expression (parser
).value
, false, NULL
);
8601 /* Parse objc-message-args.
8605 objc-keywordarg-list
8607 objc-keywordarg-list:
8609 objc-keywordarg-list objc-keywordarg
8612 objc-selector : objc-keywordexpr
8617 c_parser_objc_message_args (c_parser
*parser
)
8619 tree sel
= c_parser_objc_selector (parser
);
8620 tree list
= NULL_TREE
;
8621 if (sel
&& c_parser_next_token_is_not (parser
, CPP_COLON
))
8626 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
8627 return error_mark_node
;
8628 keywordexpr
= c_parser_objc_keywordexpr (parser
);
8629 list
= chainon (list
, build_tree_list (sel
, keywordexpr
));
8630 sel
= c_parser_objc_selector (parser
);
8631 if (!sel
&& c_parser_next_token_is_not (parser
, CPP_COLON
))
8637 /* Parse an objc-keywordexpr.
8644 c_parser_objc_keywordexpr (c_parser
*parser
)
8647 vec
<tree
, va_gc
> *expr_list
= c_parser_expr_list (parser
, true, true,
8649 if (vec_safe_length (expr_list
) == 1)
8651 /* Just return the expression, remove a level of
8653 ret
= (*expr_list
)[0];
8657 /* We have a comma expression, we will collapse later. */
8658 ret
= build_tree_list_vec (expr_list
);
8660 release_tree_vector (expr_list
);
8664 /* A check, needed in several places, that ObjC interface, implementation or
8665 method definitions are not prefixed by incorrect items. */
8667 c_parser_objc_diagnose_bad_element_prefix (c_parser
*parser
,
8668 struct c_declspecs
*specs
)
8670 if (!specs
->declspecs_seen_p
|| specs
->non_sc_seen_p
8671 || specs
->typespec_kind
!= ctsk_none
)
8673 c_parser_error (parser
,
8674 "no type or storage class may be specified here,");
8675 c_parser_skip_to_end_of_block_or_statement (parser
);
8681 /* Parse an Objective-C @property declaration. The syntax is:
8683 objc-property-declaration:
8684 '@property' objc-property-attributes[opt] struct-declaration ;
8686 objc-property-attributes:
8687 '(' objc-property-attribute-list ')'
8689 objc-property-attribute-list:
8690 objc-property-attribute
8691 objc-property-attribute-list, objc-property-attribute
8693 objc-property-attribute
8694 'getter' = identifier
8695 'setter' = identifier
8704 @property NSString *name;
8705 @property (readonly) id object;
8706 @property (retain, nonatomic, getter=getTheName) id name;
8707 @property int a, b, c;
8709 PS: This function is identical to cp_parser_objc_at_propery_declaration
8710 for C++. Keep them in sync. */
8712 c_parser_objc_at_property_declaration (c_parser
*parser
)
8714 /* The following variables hold the attributes of the properties as
8715 parsed. They are 'false' or 'NULL_TREE' if the attribute was not
8716 seen. When we see an attribute, we set them to 'true' (if they
8717 are boolean properties) or to the identifier (if they have an
8718 argument, ie, for getter and setter). Note that here we only
8719 parse the list of attributes, check the syntax and accumulate the
8720 attributes that we find. objc_add_property_declaration() will
8721 then process the information. */
8722 bool property_assign
= false;
8723 bool property_copy
= false;
8724 tree property_getter_ident
= NULL_TREE
;
8725 bool property_nonatomic
= false;
8726 bool property_readonly
= false;
8727 bool property_readwrite
= false;
8728 bool property_retain
= false;
8729 tree property_setter_ident
= NULL_TREE
;
8731 /* 'properties' is the list of properties that we read. Usually a
8732 single one, but maybe more (eg, in "@property int a, b, c;" there
8737 loc
= c_parser_peek_token (parser
)->location
;
8738 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_AT_PROPERTY
));
8740 c_parser_consume_token (parser
); /* Eat '@property'. */
8742 /* Parse the optional attribute list... */
8743 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
8746 c_parser_consume_token (parser
);
8748 /* Property attribute keywords are valid now. */
8749 parser
->objc_property_attr_context
= true;
8753 bool syntax_error
= false;
8754 c_token
*token
= c_parser_peek_token (parser
);
8757 if (token
->type
!= CPP_KEYWORD
)
8759 if (token
->type
== CPP_CLOSE_PAREN
)
8760 c_parser_error (parser
, "expected identifier");
8763 c_parser_consume_token (parser
);
8764 c_parser_error (parser
, "unknown property attribute");
8768 keyword
= token
->keyword
;
8769 c_parser_consume_token (parser
);
8772 case RID_ASSIGN
: property_assign
= true; break;
8773 case RID_COPY
: property_copy
= true; break;
8774 case RID_NONATOMIC
: property_nonatomic
= true; break;
8775 case RID_READONLY
: property_readonly
= true; break;
8776 case RID_READWRITE
: property_readwrite
= true; break;
8777 case RID_RETAIN
: property_retain
= true; break;
8781 if (c_parser_next_token_is_not (parser
, CPP_EQ
))
8783 if (keyword
== RID_GETTER
)
8784 c_parser_error (parser
,
8785 "missing %<=%> (after %<getter%> attribute)");
8787 c_parser_error (parser
,
8788 "missing %<=%> (after %<setter%> attribute)");
8789 syntax_error
= true;
8792 c_parser_consume_token (parser
); /* eat the = */
8793 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
8795 c_parser_error (parser
, "expected identifier");
8796 syntax_error
= true;
8799 if (keyword
== RID_SETTER
)
8801 if (property_setter_ident
!= NULL_TREE
)
8802 c_parser_error (parser
, "the %<setter%> attribute may only be specified once");
8804 property_setter_ident
= c_parser_peek_token (parser
)->value
;
8805 c_parser_consume_token (parser
);
8806 if (c_parser_next_token_is_not (parser
, CPP_COLON
))
8807 c_parser_error (parser
, "setter name must terminate with %<:%>");
8809 c_parser_consume_token (parser
);
8813 if (property_getter_ident
!= NULL_TREE
)
8814 c_parser_error (parser
, "the %<getter%> attribute may only be specified once");
8816 property_getter_ident
= c_parser_peek_token (parser
)->value
;
8817 c_parser_consume_token (parser
);
8821 c_parser_error (parser
, "unknown property attribute");
8822 syntax_error
= true;
8829 if (c_parser_next_token_is (parser
, CPP_COMMA
))
8830 c_parser_consume_token (parser
);
8834 parser
->objc_property_attr_context
= false;
8835 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
8837 /* ... and the property declaration(s). */
8838 properties
= c_parser_struct_declaration (parser
);
8840 if (properties
== error_mark_node
)
8842 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, NULL
);
8843 parser
->error
= false;
8847 if (properties
== NULL_TREE
)
8848 c_parser_error (parser
, "expected identifier");
8851 /* Comma-separated properties are chained together in
8852 reverse order; add them one by one. */
8853 properties
= nreverse (properties
);
8855 for (; properties
; properties
= TREE_CHAIN (properties
))
8856 objc_add_property_declaration (loc
, copy_node (properties
),
8857 property_readonly
, property_readwrite
,
8858 property_assign
, property_retain
,
8859 property_copy
, property_nonatomic
,
8860 property_getter_ident
, property_setter_ident
);
8863 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
8864 parser
->error
= false;
8867 /* Parse an Objective-C @synthesize declaration. The syntax is:
8869 objc-synthesize-declaration:
8870 @synthesize objc-synthesize-identifier-list ;
8872 objc-synthesize-identifier-list:
8873 objc-synthesize-identifier
8874 objc-synthesize-identifier-list, objc-synthesize-identifier
8876 objc-synthesize-identifier
8878 identifier = identifier
8881 @synthesize MyProperty;
8882 @synthesize OneProperty, AnotherProperty=MyIvar, YetAnotherProperty;
8884 PS: This function is identical to cp_parser_objc_at_synthesize_declaration
8885 for C++. Keep them in sync.
8888 c_parser_objc_at_synthesize_declaration (c_parser
*parser
)
8890 tree list
= NULL_TREE
;
8892 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_AT_SYNTHESIZE
));
8893 loc
= c_parser_peek_token (parser
)->location
;
8895 c_parser_consume_token (parser
);
8898 tree property
, ivar
;
8899 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
8901 c_parser_error (parser
, "expected identifier");
8902 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, NULL
);
8903 /* Once we find the semicolon, we can resume normal parsing.
8904 We have to reset parser->error manually because
8905 c_parser_skip_until_found() won't reset it for us if the
8906 next token is precisely a semicolon. */
8907 parser
->error
= false;
8910 property
= c_parser_peek_token (parser
)->value
;
8911 c_parser_consume_token (parser
);
8912 if (c_parser_next_token_is (parser
, CPP_EQ
))
8914 c_parser_consume_token (parser
);
8915 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
8917 c_parser_error (parser
, "expected identifier");
8918 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, NULL
);
8919 parser
->error
= false;
8922 ivar
= c_parser_peek_token (parser
)->value
;
8923 c_parser_consume_token (parser
);
8927 list
= chainon (list
, build_tree_list (ivar
, property
));
8928 if (c_parser_next_token_is (parser
, CPP_COMMA
))
8929 c_parser_consume_token (parser
);
8933 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
8934 objc_add_synthesize_declaration (loc
, list
);
8937 /* Parse an Objective-C @dynamic declaration. The syntax is:
8939 objc-dynamic-declaration:
8940 @dynamic identifier-list ;
8943 @dynamic MyProperty;
8944 @dynamic MyProperty, AnotherProperty;
8946 PS: This function is identical to cp_parser_objc_at_dynamic_declaration
8947 for C++. Keep them in sync.
8950 c_parser_objc_at_dynamic_declaration (c_parser
*parser
)
8952 tree list
= NULL_TREE
;
8954 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_AT_DYNAMIC
));
8955 loc
= c_parser_peek_token (parser
)->location
;
8957 c_parser_consume_token (parser
);
8961 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
8963 c_parser_error (parser
, "expected identifier");
8964 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, NULL
);
8965 parser
->error
= false;
8968 property
= c_parser_peek_token (parser
)->value
;
8969 list
= chainon (list
, build_tree_list (NULL_TREE
, property
));
8970 c_parser_consume_token (parser
);
8971 if (c_parser_next_token_is (parser
, CPP_COMMA
))
8972 c_parser_consume_token (parser
);
8976 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
8977 objc_add_dynamic_declaration (loc
, list
);
8981 /* Handle pragmas. Some OpenMP pragmas are associated with, and therefore
8982 should be considered, statements. ALLOW_STMT is true if we're within
8983 the context of a function and such pragmas are to be allowed. Returns
8984 true if we actually parsed such a pragma. */
8987 c_parser_pragma (c_parser
*parser
, enum pragma_context context
)
8991 id
= c_parser_peek_token (parser
)->pragma_kind
;
8992 gcc_assert (id
!= PRAGMA_NONE
);
8996 case PRAGMA_OMP_BARRIER
:
8997 if (context
!= pragma_compound
)
8999 if (context
== pragma_stmt
)
9000 c_parser_error (parser
, "%<#pragma omp barrier%> may only be "
9001 "used in compound statements");
9004 c_parser_omp_barrier (parser
);
9007 case PRAGMA_OMP_FLUSH
:
9008 if (context
!= pragma_compound
)
9010 if (context
== pragma_stmt
)
9011 c_parser_error (parser
, "%<#pragma omp flush%> may only be "
9012 "used in compound statements");
9015 c_parser_omp_flush (parser
);
9018 case PRAGMA_OMP_TASKWAIT
:
9019 if (context
!= pragma_compound
)
9021 if (context
== pragma_stmt
)
9022 c_parser_error (parser
, "%<#pragma omp taskwait%> may only be "
9023 "used in compound statements");
9026 c_parser_omp_taskwait (parser
);
9029 case PRAGMA_OMP_TASKYIELD
:
9030 if (context
!= pragma_compound
)
9032 if (context
== pragma_stmt
)
9033 c_parser_error (parser
, "%<#pragma omp taskyield%> may only be "
9034 "used in compound statements");
9037 c_parser_omp_taskyield (parser
);
9040 case PRAGMA_OMP_CANCEL
:
9041 if (context
!= pragma_compound
)
9043 if (context
== pragma_stmt
)
9044 c_parser_error (parser
, "%<#pragma omp cancel%> may only be "
9045 "used in compound statements");
9048 c_parser_omp_cancel (parser
);
9051 case PRAGMA_OMP_CANCELLATION_POINT
:
9052 if (context
!= pragma_compound
)
9054 if (context
== pragma_stmt
)
9055 c_parser_error (parser
, "%<#pragma omp cancellation point%> may "
9056 "only be used in compound statements");
9059 c_parser_omp_cancellation_point (parser
);
9062 case PRAGMA_OMP_THREADPRIVATE
:
9063 c_parser_omp_threadprivate (parser
);
9066 case PRAGMA_OMP_TARGET
:
9067 return c_parser_omp_target (parser
, context
);
9069 case PRAGMA_OMP_END_DECLARE_TARGET
:
9070 c_parser_omp_end_declare_target (parser
);
9073 case PRAGMA_OMP_SECTION
:
9074 error_at (c_parser_peek_token (parser
)->location
,
9075 "%<#pragma omp section%> may only be used in "
9076 "%<#pragma omp sections%> construct");
9077 c_parser_skip_until_found (parser
, CPP_PRAGMA_EOL
, NULL
);
9080 case PRAGMA_OMP_DECLARE_REDUCTION
:
9081 c_parser_omp_declare (parser
, context
);
9084 case PRAGMA_GCC_PCH_PREPROCESS
:
9085 c_parser_error (parser
, "%<#pragma GCC pch_preprocess%> must be first");
9086 c_parser_skip_until_found (parser
, CPP_PRAGMA_EOL
, NULL
);
9090 if (id
< PRAGMA_FIRST_EXTERNAL
)
9092 if (context
!= pragma_stmt
&& context
!= pragma_compound
)
9095 c_parser_error (parser
, "expected declaration specifiers");
9096 c_parser_skip_until_found (parser
, CPP_PRAGMA_EOL
, NULL
);
9099 c_parser_omp_construct (parser
);
9105 c_parser_consume_pragma (parser
);
9106 c_invoke_pragma_handler (id
);
9108 /* Skip to EOL, but suppress any error message. Those will have been
9109 generated by the handler routine through calling error, as opposed
9110 to calling c_parser_error. */
9111 parser
->error
= true;
9112 c_parser_skip_to_pragma_eol (parser
);
9117 /* The interface the pragma parsers have to the lexer. */
9120 pragma_lex (tree
*value
)
9122 c_token
*tok
= c_parser_peek_token (the_parser
);
9123 enum cpp_ttype ret
= tok
->type
;
9125 *value
= tok
->value
;
9126 if (ret
== CPP_PRAGMA_EOL
|| ret
== CPP_EOF
)
9130 if (ret
== CPP_KEYWORD
)
9132 c_parser_consume_token (the_parser
);
9139 c_parser_pragma_pch_preprocess (c_parser
*parser
)
9143 c_parser_consume_pragma (parser
);
9144 if (c_parser_next_token_is (parser
, CPP_STRING
))
9146 name
= c_parser_peek_token (parser
)->value
;
9147 c_parser_consume_token (parser
);
9150 c_parser_error (parser
, "expected string literal");
9151 c_parser_skip_to_pragma_eol (parser
);
9154 c_common_pch_pragma (parse_in
, TREE_STRING_POINTER (name
));
9157 /* OpenMP 2.5 / 3.0 / 3.1 / 4.0 parsing routines. */
9159 /* Returns name of the next clause.
9160 If the clause is not recognized PRAGMA_OMP_CLAUSE_NONE is returned and
9161 the token is not consumed. Otherwise appropriate pragma_omp_clause is
9162 returned and the token is consumed. */
9164 static pragma_omp_clause
9165 c_parser_omp_clause_name (c_parser
*parser
)
9167 pragma_omp_clause result
= PRAGMA_OMP_CLAUSE_NONE
;
9169 if (c_parser_next_token_is_keyword (parser
, RID_IF
))
9170 result
= PRAGMA_OMP_CLAUSE_IF
;
9171 else if (c_parser_next_token_is_keyword (parser
, RID_DEFAULT
))
9172 result
= PRAGMA_OMP_CLAUSE_DEFAULT
;
9173 else if (c_parser_next_token_is_keyword (parser
, RID_FOR
))
9174 result
= PRAGMA_OMP_CLAUSE_FOR
;
9175 else if (c_parser_next_token_is (parser
, CPP_NAME
))
9177 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
9182 if (!strcmp ("aligned", p
))
9183 result
= PRAGMA_OMP_CLAUSE_ALIGNED
;
9186 if (!strcmp ("collapse", p
))
9187 result
= PRAGMA_OMP_CLAUSE_COLLAPSE
;
9188 else if (!strcmp ("copyin", p
))
9189 result
= PRAGMA_OMP_CLAUSE_COPYIN
;
9190 else if (!strcmp ("copyprivate", p
))
9191 result
= PRAGMA_OMP_CLAUSE_COPYPRIVATE
;
9194 if (!strcmp ("depend", p
))
9195 result
= PRAGMA_OMP_CLAUSE_DEPEND
;
9196 else if (!strcmp ("device", p
))
9197 result
= PRAGMA_OMP_CLAUSE_DEVICE
;
9198 else if (!strcmp ("dist_schedule", p
))
9199 result
= PRAGMA_OMP_CLAUSE_DIST_SCHEDULE
;
9202 if (!strcmp ("final", p
))
9203 result
= PRAGMA_OMP_CLAUSE_FINAL
;
9204 else if (!strcmp ("firstprivate", p
))
9205 result
= PRAGMA_OMP_CLAUSE_FIRSTPRIVATE
;
9206 else if (!strcmp ("from", p
))
9207 result
= PRAGMA_OMP_CLAUSE_FROM
;
9210 if (!strcmp ("inbranch", p
))
9211 result
= PRAGMA_OMP_CLAUSE_INBRANCH
;
9214 if (!strcmp ("lastprivate", p
))
9215 result
= PRAGMA_OMP_CLAUSE_LASTPRIVATE
;
9216 else if (!strcmp ("linear", p
))
9217 result
= PRAGMA_OMP_CLAUSE_LINEAR
;
9220 if (!strcmp ("map", p
))
9221 result
= PRAGMA_OMP_CLAUSE_MAP
;
9222 else if (!strcmp ("mergeable", p
))
9223 result
= PRAGMA_OMP_CLAUSE_MERGEABLE
;
9226 if (!strcmp ("notinbranch", p
))
9227 result
= PRAGMA_OMP_CLAUSE_NOTINBRANCH
;
9228 else if (!strcmp ("nowait", p
))
9229 result
= PRAGMA_OMP_CLAUSE_NOWAIT
;
9230 else if (!strcmp ("num_teams", p
))
9231 result
= PRAGMA_OMP_CLAUSE_NUM_TEAMS
;
9232 else if (!strcmp ("num_threads", p
))
9233 result
= PRAGMA_OMP_CLAUSE_NUM_THREADS
;
9236 if (!strcmp ("ordered", p
))
9237 result
= PRAGMA_OMP_CLAUSE_ORDERED
;
9240 if (!strcmp ("parallel", p
))
9241 result
= PRAGMA_OMP_CLAUSE_PARALLEL
;
9242 else if (!strcmp ("private", p
))
9243 result
= PRAGMA_OMP_CLAUSE_PRIVATE
;
9244 else if (!strcmp ("proc_bind", p
))
9245 result
= PRAGMA_OMP_CLAUSE_PROC_BIND
;
9248 if (!strcmp ("reduction", p
))
9249 result
= PRAGMA_OMP_CLAUSE_REDUCTION
;
9252 if (!strcmp ("safelen", p
))
9253 result
= PRAGMA_OMP_CLAUSE_SAFELEN
;
9254 else if (!strcmp ("schedule", p
))
9255 result
= PRAGMA_OMP_CLAUSE_SCHEDULE
;
9256 else if (!strcmp ("sections", p
))
9257 result
= PRAGMA_OMP_CLAUSE_SECTIONS
;
9258 else if (!strcmp ("shared", p
))
9259 result
= PRAGMA_OMP_CLAUSE_SHARED
;
9260 else if (!strcmp ("simdlen", p
))
9261 result
= PRAGMA_OMP_CLAUSE_SIMDLEN
;
9264 if (!strcmp ("taskgroup", p
))
9265 result
= PRAGMA_OMP_CLAUSE_TASKGROUP
;
9266 else if (!strcmp ("thread_limit", p
))
9267 result
= PRAGMA_OMP_CLAUSE_THREAD_LIMIT
;
9268 else if (!strcmp ("to", p
))
9269 result
= PRAGMA_OMP_CLAUSE_TO
;
9272 if (!strcmp ("uniform", p
))
9273 result
= PRAGMA_OMP_CLAUSE_UNIFORM
;
9274 else if (!strcmp ("untied", p
))
9275 result
= PRAGMA_OMP_CLAUSE_UNTIED
;
9280 if (result
!= PRAGMA_OMP_CLAUSE_NONE
)
9281 c_parser_consume_token (parser
);
9286 /* Validate that a clause of the given type does not already exist. */
9289 check_no_duplicate_clause (tree clauses
, enum omp_clause_code code
,
9294 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
9295 if (OMP_CLAUSE_CODE (c
) == code
)
9297 location_t loc
= OMP_CLAUSE_LOCATION (c
);
9298 error_at (loc
, "too many %qs clauses", name
);
9306 variable-list , identifier
9308 If KIND is nonzero, create the appropriate node and install the
9309 decl in OMP_CLAUSE_DECL and add the node to the head of the list.
9310 If KIND is nonzero, CLAUSE_LOC is the location of the clause.
9312 If KIND is zero, create a TREE_LIST with the decl in TREE_PURPOSE;
9313 return the list created. */
9316 c_parser_omp_variable_list (c_parser
*parser
,
9317 location_t clause_loc
,
9318 enum omp_clause_code kind
, tree list
)
9320 if (c_parser_next_token_is_not (parser
, CPP_NAME
)
9321 || c_parser_peek_token (parser
)->id_kind
!= C_ID_ID
)
9322 c_parser_error (parser
, "expected identifier");
9324 while (c_parser_next_token_is (parser
, CPP_NAME
)
9325 && c_parser_peek_token (parser
)->id_kind
== C_ID_ID
)
9327 tree t
= lookup_name (c_parser_peek_token (parser
)->value
);
9331 undeclared_variable (c_parser_peek_token (parser
)->location
,
9332 c_parser_peek_token (parser
)->value
);
9333 t
= error_mark_node
;
9336 c_parser_consume_token (parser
);
9338 if (t
== error_mark_node
)
9344 case OMP_CLAUSE_MAP
:
9345 case OMP_CLAUSE_FROM
:
9347 case OMP_CLAUSE_DEPEND
:
9348 while (c_parser_next_token_is (parser
, CPP_OPEN_SQUARE
))
9350 tree low_bound
= NULL_TREE
, length
= NULL_TREE
;
9352 c_parser_consume_token (parser
);
9353 if (!c_parser_next_token_is (parser
, CPP_COLON
))
9354 low_bound
= c_parser_expression (parser
).value
;
9355 if (c_parser_next_token_is (parser
, CPP_CLOSE_SQUARE
))
9356 length
= integer_one_node
;
9360 if (!c_parser_require (parser
, CPP_COLON
,
9363 t
= error_mark_node
;
9366 if (!c_parser_next_token_is (parser
, CPP_CLOSE_SQUARE
))
9367 length
= c_parser_expression (parser
).value
;
9369 /* Look for the closing `]'. */
9370 if (!c_parser_require (parser
, CPP_CLOSE_SQUARE
,
9373 t
= error_mark_node
;
9376 t
= tree_cons (low_bound
, length
, t
);
9383 if (t
!= error_mark_node
)
9385 tree u
= build_omp_clause (clause_loc
, kind
);
9386 OMP_CLAUSE_DECL (u
) = t
;
9387 OMP_CLAUSE_CHAIN (u
) = list
;
9392 list
= tree_cons (t
, NULL_TREE
, list
);
9394 if (c_parser_next_token_is_not (parser
, CPP_COMMA
))
9397 c_parser_consume_token (parser
);
9403 /* Similarly, but expect leading and trailing parenthesis. This is a very
9404 common case for omp clauses. */
9407 c_parser_omp_var_list_parens (c_parser
*parser
, enum omp_clause_code kind
,
9410 /* The clauses location. */
9411 location_t loc
= c_parser_peek_token (parser
)->location
;
9413 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
9415 list
= c_parser_omp_variable_list (parser
, loc
, kind
, list
);
9416 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
9422 collapse ( constant-expression ) */
9425 c_parser_omp_clause_collapse (c_parser
*parser
, tree list
)
9427 tree c
, num
= error_mark_node
;
9431 check_no_duplicate_clause (list
, OMP_CLAUSE_COLLAPSE
, "collapse");
9433 loc
= c_parser_peek_token (parser
)->location
;
9434 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
9436 num
= c_parser_expr_no_commas (parser
, NULL
).value
;
9437 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
9439 if (num
== error_mark_node
)
9441 mark_exp_read (num
);
9442 num
= c_fully_fold (num
, false, NULL
);
9443 if (!INTEGRAL_TYPE_P (TREE_TYPE (num
))
9444 || !host_integerp (num
, 0)
9445 || (n
= tree_low_cst (num
, 0)) <= 0
9449 "collapse argument needs positive constant integer expression");
9452 c
= build_omp_clause (loc
, OMP_CLAUSE_COLLAPSE
);
9453 OMP_CLAUSE_COLLAPSE_EXPR (c
) = num
;
9454 OMP_CLAUSE_CHAIN (c
) = list
;
9459 copyin ( variable-list ) */
9462 c_parser_omp_clause_copyin (c_parser
*parser
, tree list
)
9464 return c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_COPYIN
, list
);
9468 copyprivate ( variable-list ) */
9471 c_parser_omp_clause_copyprivate (c_parser
*parser
, tree list
)
9473 return c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_COPYPRIVATE
, list
);
9477 default ( shared | none ) */
9480 c_parser_omp_clause_default (c_parser
*parser
, tree list
)
9482 enum omp_clause_default_kind kind
= OMP_CLAUSE_DEFAULT_UNSPECIFIED
;
9483 location_t loc
= c_parser_peek_token (parser
)->location
;
9486 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
9488 if (c_parser_next_token_is (parser
, CPP_NAME
))
9490 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
9495 if (strcmp ("none", p
) != 0)
9497 kind
= OMP_CLAUSE_DEFAULT_NONE
;
9501 if (strcmp ("shared", p
) != 0)
9503 kind
= OMP_CLAUSE_DEFAULT_SHARED
;
9510 c_parser_consume_token (parser
);
9515 c_parser_error (parser
, "expected %<none%> or %<shared%>");
9517 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
9519 if (kind
== OMP_CLAUSE_DEFAULT_UNSPECIFIED
)
9522 check_no_duplicate_clause (list
, OMP_CLAUSE_DEFAULT
, "default");
9523 c
= build_omp_clause (loc
, OMP_CLAUSE_DEFAULT
);
9524 OMP_CLAUSE_CHAIN (c
) = list
;
9525 OMP_CLAUSE_DEFAULT_KIND (c
) = kind
;
9531 firstprivate ( variable-list ) */
9534 c_parser_omp_clause_firstprivate (c_parser
*parser
, tree list
)
9536 return c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_FIRSTPRIVATE
, list
);
9540 final ( expression ) */
9543 c_parser_omp_clause_final (c_parser
*parser
, tree list
)
9545 location_t loc
= c_parser_peek_token (parser
)->location
;
9546 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
9548 tree t
= c_parser_paren_condition (parser
);
9551 check_no_duplicate_clause (list
, OMP_CLAUSE_FINAL
, "final");
9553 c
= build_omp_clause (loc
, OMP_CLAUSE_FINAL
);
9554 OMP_CLAUSE_FINAL_EXPR (c
) = t
;
9555 OMP_CLAUSE_CHAIN (c
) = list
;
9559 c_parser_error (parser
, "expected %<(%>");
9565 if ( expression ) */
9568 c_parser_omp_clause_if (c_parser
*parser
, tree list
)
9570 location_t loc
= c_parser_peek_token (parser
)->location
;
9571 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
9573 tree t
= c_parser_paren_condition (parser
);
9576 check_no_duplicate_clause (list
, OMP_CLAUSE_IF
, "if");
9578 c
= build_omp_clause (loc
, OMP_CLAUSE_IF
);
9579 OMP_CLAUSE_IF_EXPR (c
) = t
;
9580 OMP_CLAUSE_CHAIN (c
) = list
;
9584 c_parser_error (parser
, "expected %<(%>");
9590 lastprivate ( variable-list ) */
9593 c_parser_omp_clause_lastprivate (c_parser
*parser
, tree list
)
9595 return c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_LASTPRIVATE
, list
);
9602 c_parser_omp_clause_mergeable (c_parser
*parser ATTRIBUTE_UNUSED
, tree list
)
9606 /* FIXME: Should we allow duplicates? */
9607 check_no_duplicate_clause (list
, OMP_CLAUSE_MERGEABLE
, "mergeable");
9609 c
= build_omp_clause (c_parser_peek_token (parser
)->location
,
9610 OMP_CLAUSE_MERGEABLE
);
9611 OMP_CLAUSE_CHAIN (c
) = list
;
9620 c_parser_omp_clause_nowait (c_parser
*parser ATTRIBUTE_UNUSED
, tree list
)
9623 location_t loc
= c_parser_peek_token (parser
)->location
;
9625 check_no_duplicate_clause (list
, OMP_CLAUSE_NOWAIT
, "nowait");
9627 c
= build_omp_clause (loc
, OMP_CLAUSE_NOWAIT
);
9628 OMP_CLAUSE_CHAIN (c
) = list
;
9633 num_threads ( expression ) */
9636 c_parser_omp_clause_num_threads (c_parser
*parser
, tree list
)
9638 location_t num_threads_loc
= c_parser_peek_token (parser
)->location
;
9639 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
9641 location_t expr_loc
= c_parser_peek_token (parser
)->location
;
9642 tree c
, t
= c_parser_expression (parser
).value
;
9644 t
= c_fully_fold (t
, false, NULL
);
9646 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
9648 if (!INTEGRAL_TYPE_P (TREE_TYPE (t
)))
9650 c_parser_error (parser
, "expected integer expression");
9654 /* Attempt to statically determine when the number isn't positive. */
9655 c
= fold_build2_loc (expr_loc
, LE_EXPR
, boolean_type_node
, t
,
9656 build_int_cst (TREE_TYPE (t
), 0));
9657 if (CAN_HAVE_LOCATION_P (c
))
9658 SET_EXPR_LOCATION (c
, expr_loc
);
9659 if (c
== boolean_true_node
)
9661 warning_at (expr_loc
, 0,
9662 "%<num_threads%> value must be positive");
9663 t
= integer_one_node
;
9666 check_no_duplicate_clause (list
, OMP_CLAUSE_NUM_THREADS
, "num_threads");
9668 c
= build_omp_clause (num_threads_loc
, OMP_CLAUSE_NUM_THREADS
);
9669 OMP_CLAUSE_NUM_THREADS_EXPR (c
) = t
;
9670 OMP_CLAUSE_CHAIN (c
) = list
;
9681 c_parser_omp_clause_ordered (c_parser
*parser
, tree list
)
9685 check_no_duplicate_clause (list
, OMP_CLAUSE_ORDERED
, "ordered");
9687 c
= build_omp_clause (c_parser_peek_token (parser
)->location
,
9688 OMP_CLAUSE_ORDERED
);
9689 OMP_CLAUSE_CHAIN (c
) = list
;
9695 private ( variable-list ) */
9698 c_parser_omp_clause_private (c_parser
*parser
, tree list
)
9700 return c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_PRIVATE
, list
);
9704 reduction ( reduction-operator : variable-list )
9707 One of: + * - & ^ | && ||
9712 One of: + * - & ^ | && || max min
9717 One of: + * - & ^ | && ||
9721 c_parser_omp_clause_reduction (c_parser
*parser
, tree list
)
9723 location_t clause_loc
= c_parser_peek_token (parser
)->location
;
9724 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
9726 enum tree_code code
= ERROR_MARK
;
9727 tree reduc_id
= NULL_TREE
;
9729 switch (c_parser_peek_token (parser
)->type
)
9741 code
= BIT_AND_EXPR
;
9744 code
= BIT_XOR_EXPR
;
9747 code
= BIT_IOR_EXPR
;
9750 code
= TRUTH_ANDIF_EXPR
;
9753 code
= TRUTH_ORIF_EXPR
;
9758 = IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
9759 if (strcmp (p
, "min") == 0)
9764 if (strcmp (p
, "max") == 0)
9769 reduc_id
= c_parser_peek_token (parser
)->value
;
9773 c_parser_error (parser
,
9774 "expected %<+%>, %<*%>, %<-%>, %<&%>, "
9775 "%<^%>, %<|%>, %<&&%>, %<||%>, %<min%> or %<max%>");
9776 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, 0);
9779 c_parser_consume_token (parser
);
9780 reduc_id
= c_omp_reduction_id (code
, reduc_id
);
9781 if (c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
9785 nl
= c_parser_omp_variable_list (parser
, clause_loc
,
9786 OMP_CLAUSE_REDUCTION
, list
);
9787 for (c
= nl
; c
!= list
; c
= OMP_CLAUSE_CHAIN (c
))
9789 tree type
= TREE_TYPE (OMP_CLAUSE_DECL (c
));
9790 OMP_CLAUSE_REDUCTION_CODE (c
) = code
;
9791 if (code
== ERROR_MARK
9792 || !(INTEGRAL_TYPE_P (type
)
9793 || TREE_CODE (type
) == REAL_TYPE
9794 || TREE_CODE (type
) == COMPLEX_TYPE
))
9795 OMP_CLAUSE_REDUCTION_PLACEHOLDER (c
)
9796 = c_omp_reduction_lookup (reduc_id
,
9797 TYPE_MAIN_VARIANT (type
));
9802 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
9808 schedule ( schedule-kind )
9809 schedule ( schedule-kind , expression )
9812 static | dynamic | guided | runtime | auto
9816 c_parser_omp_clause_schedule (c_parser
*parser
, tree list
)
9819 location_t loc
= c_parser_peek_token (parser
)->location
;
9821 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
9824 c
= build_omp_clause (loc
, OMP_CLAUSE_SCHEDULE
);
9826 if (c_parser_next_token_is (parser
, CPP_NAME
))
9828 tree kind
= c_parser_peek_token (parser
)->value
;
9829 const char *p
= IDENTIFIER_POINTER (kind
);
9834 if (strcmp ("dynamic", p
) != 0)
9836 OMP_CLAUSE_SCHEDULE_KIND (c
) = OMP_CLAUSE_SCHEDULE_DYNAMIC
;
9840 if (strcmp ("guided", p
) != 0)
9842 OMP_CLAUSE_SCHEDULE_KIND (c
) = OMP_CLAUSE_SCHEDULE_GUIDED
;
9846 if (strcmp ("runtime", p
) != 0)
9848 OMP_CLAUSE_SCHEDULE_KIND (c
) = OMP_CLAUSE_SCHEDULE_RUNTIME
;
9855 else if (c_parser_next_token_is_keyword (parser
, RID_STATIC
))
9856 OMP_CLAUSE_SCHEDULE_KIND (c
) = OMP_CLAUSE_SCHEDULE_STATIC
;
9857 else if (c_parser_next_token_is_keyword (parser
, RID_AUTO
))
9858 OMP_CLAUSE_SCHEDULE_KIND (c
) = OMP_CLAUSE_SCHEDULE_AUTO
;
9862 c_parser_consume_token (parser
);
9863 if (c_parser_next_token_is (parser
, CPP_COMMA
))
9866 c_parser_consume_token (parser
);
9868 here
= c_parser_peek_token (parser
)->location
;
9869 t
= c_parser_expr_no_commas (parser
, NULL
).value
;
9871 t
= c_fully_fold (t
, false, NULL
);
9873 if (OMP_CLAUSE_SCHEDULE_KIND (c
) == OMP_CLAUSE_SCHEDULE_RUNTIME
)
9874 error_at (here
, "schedule %<runtime%> does not take "
9875 "a %<chunk_size%> parameter");
9876 else if (OMP_CLAUSE_SCHEDULE_KIND (c
) == OMP_CLAUSE_SCHEDULE_AUTO
)
9878 "schedule %<auto%> does not take "
9879 "a %<chunk_size%> parameter");
9880 else if (TREE_CODE (TREE_TYPE (t
)) == INTEGER_TYPE
)
9881 OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c
) = t
;
9883 c_parser_error (parser
, "expected integer expression");
9885 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
9888 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
9889 "expected %<,%> or %<)%>");
9891 check_no_duplicate_clause (list
, OMP_CLAUSE_SCHEDULE
, "schedule");
9892 OMP_CLAUSE_CHAIN (c
) = list
;
9896 c_parser_error (parser
, "invalid schedule kind");
9897 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, 0);
9902 shared ( variable-list ) */
9905 c_parser_omp_clause_shared (c_parser
*parser
, tree list
)
9907 return c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_SHARED
, list
);
9914 c_parser_omp_clause_untied (c_parser
*parser ATTRIBUTE_UNUSED
, tree list
)
9918 /* FIXME: Should we allow duplicates? */
9919 check_no_duplicate_clause (list
, OMP_CLAUSE_UNTIED
, "untied");
9921 c
= build_omp_clause (c_parser_peek_token (parser
)->location
,
9923 OMP_CLAUSE_CHAIN (c
) = list
;
9933 c_parser_omp_clause_branch (c_parser
*parser ATTRIBUTE_UNUSED
,
9934 enum omp_clause_code code
, tree list
)
9936 check_no_duplicate_clause (list
, code
, omp_clause_code_name
[code
]);
9938 tree c
= build_omp_clause (c_parser_peek_token (parser
)->location
, code
);
9939 OMP_CLAUSE_CHAIN (c
) = list
;
9951 c_parser_omp_clause_cancelkind (c_parser
*parser ATTRIBUTE_UNUSED
,
9952 enum omp_clause_code code
, tree list
)
9954 tree c
= build_omp_clause (c_parser_peek_token (parser
)->location
, code
);
9955 OMP_CLAUSE_CHAIN (c
) = list
;
9961 num_teams ( expression ) */
9964 c_parser_omp_clause_num_teams (c_parser
*parser
, tree list
)
9966 location_t num_teams_loc
= c_parser_peek_token (parser
)->location
;
9967 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
9969 location_t expr_loc
= c_parser_peek_token (parser
)->location
;
9970 tree c
, t
= c_parser_expression (parser
).value
;
9972 t
= c_fully_fold (t
, false, NULL
);
9974 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
9976 if (!INTEGRAL_TYPE_P (TREE_TYPE (t
)))
9978 c_parser_error (parser
, "expected integer expression");
9982 /* Attempt to statically determine when the number isn't positive. */
9983 c
= fold_build2_loc (expr_loc
, LE_EXPR
, boolean_type_node
, t
,
9984 build_int_cst (TREE_TYPE (t
), 0));
9985 if (CAN_HAVE_LOCATION_P (c
))
9986 SET_EXPR_LOCATION (c
, expr_loc
);
9987 if (c
== boolean_true_node
)
9989 warning_at (expr_loc
, 0, "%<num_teams%> value must be positive");
9990 t
= integer_one_node
;
9993 check_no_duplicate_clause (list
, OMP_CLAUSE_NUM_TEAMS
, "num_teams");
9995 c
= build_omp_clause (num_teams_loc
, OMP_CLAUSE_NUM_TEAMS
);
9996 OMP_CLAUSE_NUM_TEAMS_EXPR (c
) = t
;
9997 OMP_CLAUSE_CHAIN (c
) = list
;
10005 thread_limit ( expression ) */
10008 c_parser_omp_clause_thread_limit (c_parser
*parser
, tree list
)
10010 location_t num_teams_loc
= c_parser_peek_token (parser
)->location
;
10011 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
10013 location_t expr_loc
= c_parser_peek_token (parser
)->location
;
10014 tree c
, t
= c_parser_expression (parser
).value
;
10016 t
= c_fully_fold (t
, false, NULL
);
10018 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
10020 if (!INTEGRAL_TYPE_P (TREE_TYPE (t
)))
10022 c_parser_error (parser
, "expected integer expression");
10026 /* Attempt to statically determine when the number isn't positive. */
10027 c
= fold_build2_loc (expr_loc
, LE_EXPR
, boolean_type_node
, t
,
10028 build_int_cst (TREE_TYPE (t
), 0));
10029 if (CAN_HAVE_LOCATION_P (c
))
10030 SET_EXPR_LOCATION (c
, expr_loc
);
10031 if (c
== boolean_true_node
)
10033 warning_at (expr_loc
, 0, "%<thread_limit%> value must be positive");
10034 t
= integer_one_node
;
10037 check_no_duplicate_clause (list
, OMP_CLAUSE_THREAD_LIMIT
,
10040 c
= build_omp_clause (num_teams_loc
, OMP_CLAUSE_THREAD_LIMIT
);
10041 OMP_CLAUSE_THREAD_LIMIT_EXPR (c
) = t
;
10042 OMP_CLAUSE_CHAIN (c
) = list
;
10050 aligned ( variable-list )
10051 aligned ( variable-list : constant-expression ) */
10054 c_parser_omp_clause_aligned (c_parser
*parser
, tree list
)
10056 location_t clause_loc
= c_parser_peek_token (parser
)->location
;
10059 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
10062 nl
= c_parser_omp_variable_list (parser
, clause_loc
,
10063 OMP_CLAUSE_ALIGNED
, list
);
10065 if (c_parser_next_token_is (parser
, CPP_COLON
))
10067 c_parser_consume_token (parser
);
10068 tree alignment
= c_parser_expr_no_commas (parser
, NULL
).value
;
10069 mark_exp_read (alignment
);
10070 alignment
= c_fully_fold (alignment
, false, NULL
);
10071 if (!INTEGRAL_TYPE_P (TREE_TYPE (alignment
))
10072 && TREE_CODE (alignment
) != INTEGER_CST
10073 && tree_int_cst_sgn (alignment
) != 1)
10075 error_at (clause_loc
, "%<aligned%> clause alignment expression must "
10076 "be positive constant integer expression");
10077 alignment
= NULL_TREE
;
10080 for (c
= nl
; c
!= list
; c
= OMP_CLAUSE_CHAIN (c
))
10081 OMP_CLAUSE_ALIGNED_ALIGNMENT (c
) = alignment
;
10084 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
10089 linear ( variable-list )
10090 linear ( variable-list : expression ) */
10093 c_parser_omp_clause_linear (c_parser
*parser
, tree list
)
10095 location_t clause_loc
= c_parser_peek_token (parser
)->location
;
10098 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
10101 nl
= c_parser_omp_variable_list (parser
, clause_loc
,
10102 OMP_CLAUSE_LINEAR
, list
);
10104 if (c_parser_next_token_is (parser
, CPP_COLON
))
10106 c_parser_consume_token (parser
);
10107 step
= c_parser_expression (parser
).value
;
10108 mark_exp_read (step
);
10109 step
= c_fully_fold (step
, false, NULL
);
10110 if (!INTEGRAL_TYPE_P (TREE_TYPE (step
)))
10112 error_at (clause_loc
, "%<linear%> clause step expression must "
10114 step
= integer_one_node
;
10119 step
= integer_one_node
;
10121 for (c
= nl
; c
!= list
; c
= OMP_CLAUSE_CHAIN (c
))
10123 OMP_CLAUSE_LINEAR_STEP (c
) = step
;
10126 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
10131 safelen ( constant-expression ) */
10134 c_parser_omp_clause_safelen (c_parser
*parser
, tree list
)
10136 location_t clause_loc
= c_parser_peek_token (parser
)->location
;
10139 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
10142 t
= c_parser_expr_no_commas (parser
, NULL
).value
;
10144 t
= c_fully_fold (t
, false, NULL
);
10145 if (!INTEGRAL_TYPE_P (TREE_TYPE (t
))
10146 && TREE_CODE (t
) != INTEGER_CST
10147 && tree_int_cst_sgn (t
) != 1)
10149 error_at (clause_loc
, "%<safelen%> clause expression must "
10150 "be positive constant integer expression");
10154 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
10155 if (t
== NULL_TREE
|| t
== error_mark_node
)
10158 check_no_duplicate_clause (list
, OMP_CLAUSE_SAFELEN
, "safelen");
10160 c
= build_omp_clause (clause_loc
, OMP_CLAUSE_SAFELEN
);
10161 OMP_CLAUSE_SAFELEN_EXPR (c
) = t
;
10162 OMP_CLAUSE_CHAIN (c
) = list
;
10167 simdlen ( constant-expression ) */
10170 c_parser_omp_clause_simdlen (c_parser
*parser
, tree list
)
10172 location_t clause_loc
= c_parser_peek_token (parser
)->location
;
10175 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
10178 t
= c_parser_expr_no_commas (parser
, NULL
).value
;
10180 t
= c_fully_fold (t
, false, NULL
);
10181 if (!INTEGRAL_TYPE_P (TREE_TYPE (t
))
10182 && TREE_CODE (t
) != INTEGER_CST
10183 && tree_int_cst_sgn (t
) != 1)
10185 error_at (clause_loc
, "%<simdlen%> clause expression must "
10186 "be positive constant integer expression");
10190 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
10191 if (t
== NULL_TREE
|| t
== error_mark_node
)
10194 check_no_duplicate_clause (list
, OMP_CLAUSE_SIMDLEN
, "simdlen");
10196 c
= build_omp_clause (clause_loc
, OMP_CLAUSE_SIMDLEN
);
10197 OMP_CLAUSE_SIMDLEN_EXPR (c
) = t
;
10198 OMP_CLAUSE_CHAIN (c
) = list
;
10203 depend ( depend-kind: variable-list )
10206 in | out | inout */
10209 c_parser_omp_clause_depend (c_parser
*parser
, tree list
)
10211 location_t clause_loc
= c_parser_peek_token (parser
)->location
;
10212 enum omp_clause_depend_kind kind
= OMP_CLAUSE_DEPEND_INOUT
;
10215 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
10218 if (c_parser_next_token_is (parser
, CPP_NAME
))
10220 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
10221 if (strcmp ("in", p
) == 0)
10222 kind
= OMP_CLAUSE_DEPEND_IN
;
10223 else if (strcmp ("inout", p
) == 0)
10224 kind
= OMP_CLAUSE_DEPEND_INOUT
;
10225 else if (strcmp ("out", p
) == 0)
10226 kind
= OMP_CLAUSE_DEPEND_OUT
;
10233 c_parser_consume_token (parser
);
10234 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
10237 nl
= c_parser_omp_variable_list (parser
, clause_loc
,
10238 OMP_CLAUSE_DEPEND
, list
);
10240 for (c
= nl
; c
!= list
; c
= OMP_CLAUSE_CHAIN (c
))
10241 OMP_CLAUSE_DEPEND_KIND (c
) = kind
;
10243 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
10247 c_parser_error (parser
, "invalid depend kind");
10249 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
10254 map ( map-kind: variable-list )
10255 map ( variable-list )
10258 alloc | to | from | tofrom */
10261 c_parser_omp_clause_map (c_parser
*parser
, tree list
)
10263 location_t clause_loc
= c_parser_peek_token (parser
)->location
;
10264 enum omp_clause_map_kind kind
= OMP_CLAUSE_MAP_TOFROM
;
10267 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
10270 if (c_parser_next_token_is (parser
, CPP_NAME
)
10271 && c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
)
10273 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
10274 if (strcmp ("alloc", p
) == 0)
10275 kind
= OMP_CLAUSE_MAP_ALLOC
;
10276 else if (strcmp ("to", p
) == 0)
10277 kind
= OMP_CLAUSE_MAP_TO
;
10278 else if (strcmp ("from", p
) == 0)
10279 kind
= OMP_CLAUSE_MAP_FROM
;
10280 else if (strcmp ("tofrom", p
) == 0)
10281 kind
= OMP_CLAUSE_MAP_TOFROM
;
10284 c_parser_error (parser
, "invalid map kind");
10285 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
10289 c_parser_consume_token (parser
);
10290 c_parser_consume_token (parser
);
10293 nl
= c_parser_omp_variable_list (parser
, clause_loc
, OMP_CLAUSE_MAP
, list
);
10295 for (c
= nl
; c
!= list
; c
= OMP_CLAUSE_CHAIN (c
))
10296 OMP_CLAUSE_MAP_KIND (c
) = kind
;
10298 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
10303 device ( expression ) */
10306 c_parser_omp_clause_device (c_parser
*parser
, tree list
)
10308 location_t clause_loc
= c_parser_peek_token (parser
)->location
;
10309 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
10311 tree c
, t
= c_parser_expr_no_commas (parser
, NULL
).value
;
10313 t
= c_fully_fold (t
, false, NULL
);
10315 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
10317 if (!INTEGRAL_TYPE_P (TREE_TYPE (t
)))
10319 c_parser_error (parser
, "expected integer expression");
10323 check_no_duplicate_clause (list
, OMP_CLAUSE_DEVICE
, "device");
10325 c
= build_omp_clause (clause_loc
, OMP_CLAUSE_DEVICE
);
10326 OMP_CLAUSE_DEVICE_ID (c
) = t
;
10327 OMP_CLAUSE_CHAIN (c
) = list
;
10335 dist_schedule ( static )
10336 dist_schedule ( static , expression ) */
10339 c_parser_omp_clause_dist_schedule (c_parser
*parser
, tree list
)
10341 tree c
, t
= NULL_TREE
;
10342 location_t loc
= c_parser_peek_token (parser
)->location
;
10344 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
10347 if (!c_parser_next_token_is_keyword (parser
, RID_STATIC
))
10349 c_parser_error (parser
, "invalid dist_schedule kind");
10350 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
10355 c_parser_consume_token (parser
);
10356 if (c_parser_next_token_is (parser
, CPP_COMMA
))
10358 c_parser_consume_token (parser
);
10360 t
= c_parser_expr_no_commas (parser
, NULL
).value
;
10362 t
= c_fully_fold (t
, false, NULL
);
10363 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
10366 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
10367 "expected %<,%> or %<)%>");
10369 check_no_duplicate_clause (list
, OMP_CLAUSE_SCHEDULE
, "schedule");
10370 if (t
== error_mark_node
)
10373 c
= build_omp_clause (loc
, OMP_CLAUSE_DIST_SCHEDULE
);
10374 OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR (c
) = t
;
10375 OMP_CLAUSE_CHAIN (c
) = list
;
10380 proc_bind ( proc-bind-kind )
10383 master | close | spread */
10386 c_parser_omp_clause_proc_bind (c_parser
*parser
, tree list
)
10388 location_t clause_loc
= c_parser_peek_token (parser
)->location
;
10389 enum omp_clause_proc_bind_kind kind
;
10392 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
10395 if (c_parser_next_token_is (parser
, CPP_NAME
))
10397 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
10398 if (strcmp ("master", p
) == 0)
10399 kind
= OMP_CLAUSE_PROC_BIND_MASTER
;
10400 else if (strcmp ("close", p
) == 0)
10401 kind
= OMP_CLAUSE_PROC_BIND_CLOSE
;
10402 else if (strcmp ("spread", p
) == 0)
10403 kind
= OMP_CLAUSE_PROC_BIND_SPREAD
;
10410 c_parser_consume_token (parser
);
10411 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
10412 c
= build_omp_clause (clause_loc
, OMP_CLAUSE_PROC_BIND
);
10413 OMP_CLAUSE_PROC_BIND_KIND (c
) = kind
;
10414 OMP_CLAUSE_CHAIN (c
) = list
;
10418 c_parser_error (parser
, "invalid proc_bind kind");
10419 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
10424 to ( variable-list ) */
10427 c_parser_omp_clause_to (c_parser
*parser
, tree list
)
10429 return c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_TO
, list
);
10433 from ( variable-list ) */
10436 c_parser_omp_clause_from (c_parser
*parser
, tree list
)
10438 return c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_FROM
, list
);
10442 uniform ( variable-list ) */
10445 c_parser_omp_clause_uniform (c_parser
*parser
, tree list
)
10447 /* The clauses location. */
10448 location_t loc
= c_parser_peek_token (parser
)->location
;
10450 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
10452 list
= c_parser_omp_variable_list (parser
, loc
, OMP_CLAUSE_UNIFORM
,
10454 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
10459 /* Parse all OpenMP clauses. The set clauses allowed by the directive
10460 is a bitmask in MASK. Return the list of clauses found; the result
10461 of clause default goes in *pdefault. */
10464 c_parser_omp_all_clauses (c_parser
*parser
, omp_clause_mask mask
,
10465 const char *where
, bool finish_p
= true)
10467 tree clauses
= NULL
;
10470 while (c_parser_next_token_is_not (parser
, CPP_PRAGMA_EOL
))
10473 pragma_omp_clause c_kind
;
10474 const char *c_name
;
10475 tree prev
= clauses
;
10477 if (!first
&& c_parser_next_token_is (parser
, CPP_COMMA
))
10478 c_parser_consume_token (parser
);
10480 here
= c_parser_peek_token (parser
)->location
;
10481 c_kind
= c_parser_omp_clause_name (parser
);
10485 case PRAGMA_OMP_CLAUSE_COLLAPSE
:
10486 clauses
= c_parser_omp_clause_collapse (parser
, clauses
);
10487 c_name
= "collapse";
10489 case PRAGMA_OMP_CLAUSE_COPYIN
:
10490 clauses
= c_parser_omp_clause_copyin (parser
, clauses
);
10493 case PRAGMA_OMP_CLAUSE_COPYPRIVATE
:
10494 clauses
= c_parser_omp_clause_copyprivate (parser
, clauses
);
10495 c_name
= "copyprivate";
10497 case PRAGMA_OMP_CLAUSE_DEFAULT
:
10498 clauses
= c_parser_omp_clause_default (parser
, clauses
);
10499 c_name
= "default";
10501 case PRAGMA_OMP_CLAUSE_FIRSTPRIVATE
:
10502 clauses
= c_parser_omp_clause_firstprivate (parser
, clauses
);
10503 c_name
= "firstprivate";
10505 case PRAGMA_OMP_CLAUSE_FINAL
:
10506 clauses
= c_parser_omp_clause_final (parser
, clauses
);
10509 case PRAGMA_OMP_CLAUSE_IF
:
10510 clauses
= c_parser_omp_clause_if (parser
, clauses
);
10513 case PRAGMA_OMP_CLAUSE_LASTPRIVATE
:
10514 clauses
= c_parser_omp_clause_lastprivate (parser
, clauses
);
10515 c_name
= "lastprivate";
10517 case PRAGMA_OMP_CLAUSE_MERGEABLE
:
10518 clauses
= c_parser_omp_clause_mergeable (parser
, clauses
);
10519 c_name
= "mergeable";
10521 case PRAGMA_OMP_CLAUSE_NOWAIT
:
10522 clauses
= c_parser_omp_clause_nowait (parser
, clauses
);
10525 case PRAGMA_OMP_CLAUSE_NUM_THREADS
:
10526 clauses
= c_parser_omp_clause_num_threads (parser
, clauses
);
10527 c_name
= "num_threads";
10529 case PRAGMA_OMP_CLAUSE_ORDERED
:
10530 clauses
= c_parser_omp_clause_ordered (parser
, clauses
);
10531 c_name
= "ordered";
10533 case PRAGMA_OMP_CLAUSE_PRIVATE
:
10534 clauses
= c_parser_omp_clause_private (parser
, clauses
);
10535 c_name
= "private";
10537 case PRAGMA_OMP_CLAUSE_REDUCTION
:
10538 clauses
= c_parser_omp_clause_reduction (parser
, clauses
);
10539 c_name
= "reduction";
10541 case PRAGMA_OMP_CLAUSE_SCHEDULE
:
10542 clauses
= c_parser_omp_clause_schedule (parser
, clauses
);
10543 c_name
= "schedule";
10545 case PRAGMA_OMP_CLAUSE_SHARED
:
10546 clauses
= c_parser_omp_clause_shared (parser
, clauses
);
10549 case PRAGMA_OMP_CLAUSE_UNTIED
:
10550 clauses
= c_parser_omp_clause_untied (parser
, clauses
);
10553 case PRAGMA_OMP_CLAUSE_INBRANCH
:
10554 clauses
= c_parser_omp_clause_branch (parser
, OMP_CLAUSE_INBRANCH
,
10556 c_name
= "inbranch";
10558 case PRAGMA_OMP_CLAUSE_NOTINBRANCH
:
10559 clauses
= c_parser_omp_clause_branch (parser
, OMP_CLAUSE_NOTINBRANCH
,
10561 c_name
= "notinbranch";
10563 case PRAGMA_OMP_CLAUSE_PARALLEL
:
10565 = c_parser_omp_clause_cancelkind (parser
, OMP_CLAUSE_PARALLEL
,
10567 c_name
= "parallel";
10571 error_at (here
, "%qs must be the first clause of %qs",
10576 case PRAGMA_OMP_CLAUSE_FOR
:
10578 = c_parser_omp_clause_cancelkind (parser
, OMP_CLAUSE_FOR
,
10582 goto clause_not_first
;
10584 case PRAGMA_OMP_CLAUSE_SECTIONS
:
10586 = c_parser_omp_clause_cancelkind (parser
, OMP_CLAUSE_SECTIONS
,
10588 c_name
= "sections";
10590 goto clause_not_first
;
10592 case PRAGMA_OMP_CLAUSE_TASKGROUP
:
10594 = c_parser_omp_clause_cancelkind (parser
, OMP_CLAUSE_TASKGROUP
,
10596 c_name
= "taskgroup";
10598 goto clause_not_first
;
10600 case PRAGMA_OMP_CLAUSE_TO
:
10601 clauses
= c_parser_omp_clause_to (parser
, clauses
);
10604 case PRAGMA_OMP_CLAUSE_FROM
:
10605 clauses
= c_parser_omp_clause_from (parser
, clauses
);
10608 case PRAGMA_OMP_CLAUSE_UNIFORM
:
10609 clauses
= c_parser_omp_clause_uniform (parser
, clauses
);
10610 c_name
= "uniform";
10612 case PRAGMA_OMP_CLAUSE_NUM_TEAMS
:
10613 clauses
= c_parser_omp_clause_num_teams (parser
, clauses
);
10614 c_name
= "num_teams";
10616 case PRAGMA_OMP_CLAUSE_THREAD_LIMIT
:
10617 clauses
= c_parser_omp_clause_thread_limit (parser
, clauses
);
10618 c_name
= "thread_limit";
10620 case PRAGMA_OMP_CLAUSE_ALIGNED
:
10621 clauses
= c_parser_omp_clause_aligned (parser
, clauses
);
10622 c_name
= "aligned";
10624 case PRAGMA_OMP_CLAUSE_LINEAR
:
10625 clauses
= c_parser_omp_clause_linear (parser
, clauses
);
10628 case PRAGMA_OMP_CLAUSE_DEPEND
:
10629 clauses
= c_parser_omp_clause_depend (parser
, clauses
);
10632 case PRAGMA_OMP_CLAUSE_MAP
:
10633 clauses
= c_parser_omp_clause_map (parser
, clauses
);
10636 case PRAGMA_OMP_CLAUSE_DEVICE
:
10637 clauses
= c_parser_omp_clause_device (parser
, clauses
);
10640 case PRAGMA_OMP_CLAUSE_DIST_SCHEDULE
:
10641 clauses
= c_parser_omp_clause_dist_schedule (parser
, clauses
);
10642 c_name
= "dist_schedule";
10644 case PRAGMA_OMP_CLAUSE_PROC_BIND
:
10645 clauses
= c_parser_omp_clause_proc_bind (parser
, clauses
);
10646 c_name
= "proc_bind";
10648 case PRAGMA_OMP_CLAUSE_SAFELEN
:
10649 clauses
= c_parser_omp_clause_safelen (parser
, clauses
);
10650 c_name
= "safelen";
10652 case PRAGMA_OMP_CLAUSE_SIMDLEN
:
10653 clauses
= c_parser_omp_clause_simdlen (parser
, clauses
);
10654 c_name
= "simdlen";
10657 c_parser_error (parser
, "expected %<#pragma omp%> clause");
10663 if (((mask
>> c_kind
) & 1) == 0 && !parser
->error
)
10665 /* Remove the invalid clause(s) from the list to avoid
10666 confusing the rest of the compiler. */
10668 error_at (here
, "%qs is not valid for %qs", c_name
, where
);
10673 c_parser_skip_to_pragma_eol (parser
);
10676 return c_finish_omp_clauses (clauses
);
10685 In practice, we're also interested in adding the statement to an
10686 outer node. So it is convenient if we work around the fact that
10687 c_parser_statement calls add_stmt. */
10690 c_parser_omp_structured_block (c_parser
*parser
)
10692 tree stmt
= push_stmt_list ();
10693 c_parser_statement (parser
);
10694 return pop_stmt_list (stmt
);
10698 # pragma omp atomic new-line
10702 x binop= expr | x++ | ++x | x-- | --x
10704 +, *, -, /, &, ^, |, <<, >>
10706 where x is an lvalue expression with scalar type.
10709 # pragma omp atomic new-line
10712 # pragma omp atomic read new-line
10715 # pragma omp atomic write new-line
10718 # pragma omp atomic update new-line
10721 # pragma omp atomic capture new-line
10724 # pragma omp atomic capture new-line
10732 expression-stmt | x = x binop expr
10734 v = expression-stmt
10736 { v = x; update-stmt; } | { update-stmt; v = x; }
10740 expression-stmt | x = x binop expr | x = expr binop x
10744 { v = x; update-stmt; } | { update-stmt; v = x; } | { v = x; x = expr; }
10746 where x and v are lvalue expressions with scalar type.
10748 LOC is the location of the #pragma token. */
10751 c_parser_omp_atomic (location_t loc
, c_parser
*parser
)
10753 tree lhs
= NULL_TREE
, rhs
= NULL_TREE
, v
= NULL_TREE
;
10754 tree lhs1
= NULL_TREE
, rhs1
= NULL_TREE
;
10755 tree stmt
, orig_lhs
, unfolded_lhs
= NULL_TREE
, unfolded_lhs1
= NULL_TREE
;
10756 enum tree_code code
= OMP_ATOMIC
, opcode
= NOP_EXPR
;
10757 struct c_expr expr
;
10759 bool structured_block
= false;
10760 bool swapped
= false;
10761 bool seq_cst
= false;
10763 if (c_parser_next_token_is (parser
, CPP_NAME
))
10765 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
10767 if (!strcmp (p
, "read"))
10768 code
= OMP_ATOMIC_READ
;
10769 else if (!strcmp (p
, "write"))
10771 else if (!strcmp (p
, "update"))
10773 else if (!strcmp (p
, "capture"))
10774 code
= OMP_ATOMIC_CAPTURE_NEW
;
10778 c_parser_consume_token (parser
);
10780 if (c_parser_next_token_is (parser
, CPP_NAME
))
10782 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
10783 if (!strcmp (p
, "seq_cst"))
10786 c_parser_consume_token (parser
);
10789 c_parser_skip_to_pragma_eol (parser
);
10793 case OMP_ATOMIC_READ
:
10794 case NOP_EXPR
: /* atomic write */
10795 v
= c_parser_unary_expression (parser
).value
;
10796 v
= c_fully_fold (v
, false, NULL
);
10797 if (v
== error_mark_node
)
10799 loc
= c_parser_peek_token (parser
)->location
;
10800 if (!c_parser_require (parser
, CPP_EQ
, "expected %<=%>"))
10802 if (code
== NOP_EXPR
)
10803 lhs
= c_parser_expression (parser
).value
;
10805 lhs
= c_parser_unary_expression (parser
).value
;
10806 lhs
= c_fully_fold (lhs
, false, NULL
);
10807 if (lhs
== error_mark_node
)
10809 if (code
== NOP_EXPR
)
10811 /* atomic write is represented by OMP_ATOMIC with NOP_EXPR
10819 case OMP_ATOMIC_CAPTURE_NEW
:
10820 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
10822 c_parser_consume_token (parser
);
10823 structured_block
= true;
10827 v
= c_parser_unary_expression (parser
).value
;
10828 v
= c_fully_fold (v
, false, NULL
);
10829 if (v
== error_mark_node
)
10831 if (!c_parser_require (parser
, CPP_EQ
, "expected %<=%>"))
10839 /* For structured_block case we don't know yet whether
10840 old or new x should be captured. */
10842 eloc
= c_parser_peek_token (parser
)->location
;
10843 expr
= c_parser_unary_expression (parser
);
10845 expr
= default_function_array_conversion (eloc
, expr
);
10846 unfolded_lhs
= expr
.value
;
10847 lhs
= c_fully_fold (lhs
, false, NULL
);
10849 switch (TREE_CODE (lhs
))
10853 c_parser_skip_to_end_of_block_or_statement (parser
);
10854 if (structured_block
)
10856 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
10857 c_parser_consume_token (parser
);
10858 else if (code
== OMP_ATOMIC_CAPTURE_NEW
)
10860 c_parser_skip_to_end_of_block_or_statement (parser
);
10861 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
10862 c_parser_consume_token (parser
);
10867 case POSTINCREMENT_EXPR
:
10868 if (code
== OMP_ATOMIC_CAPTURE_NEW
&& !structured_block
)
10869 code
= OMP_ATOMIC_CAPTURE_OLD
;
10871 case PREINCREMENT_EXPR
:
10872 lhs
= TREE_OPERAND (lhs
, 0);
10873 unfolded_lhs
= NULL_TREE
;
10874 opcode
= PLUS_EXPR
;
10875 rhs
= integer_one_node
;
10878 case POSTDECREMENT_EXPR
:
10879 if (code
== OMP_ATOMIC_CAPTURE_NEW
&& !structured_block
)
10880 code
= OMP_ATOMIC_CAPTURE_OLD
;
10882 case PREDECREMENT_EXPR
:
10883 lhs
= TREE_OPERAND (lhs
, 0);
10884 unfolded_lhs
= NULL_TREE
;
10885 opcode
= MINUS_EXPR
;
10886 rhs
= integer_one_node
;
10889 case COMPOUND_EXPR
:
10890 if (TREE_CODE (TREE_OPERAND (lhs
, 0)) == SAVE_EXPR
10891 && TREE_CODE (TREE_OPERAND (lhs
, 1)) == COMPOUND_EXPR
10892 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (lhs
, 1), 0)) == MODIFY_EXPR
10893 && TREE_OPERAND (TREE_OPERAND (lhs
, 1), 1) == TREE_OPERAND (lhs
, 0)
10894 && TREE_CODE (TREE_TYPE (TREE_OPERAND (TREE_OPERAND
10895 (TREE_OPERAND (lhs
, 1), 0), 0)))
10897 /* Undo effects of boolean_increment for post {in,de}crement. */
10898 lhs
= TREE_OPERAND (TREE_OPERAND (lhs
, 1), 0);
10901 if (TREE_CODE (lhs
) == MODIFY_EXPR
10902 && TREE_CODE (TREE_TYPE (TREE_OPERAND (lhs
, 0))) == BOOLEAN_TYPE
)
10904 /* Undo effects of boolean_increment. */
10905 if (integer_onep (TREE_OPERAND (lhs
, 1)))
10907 /* This is pre or post increment. */
10908 rhs
= TREE_OPERAND (lhs
, 1);
10909 lhs
= TREE_OPERAND (lhs
, 0);
10910 unfolded_lhs
= NULL_TREE
;
10912 if (code
== OMP_ATOMIC_CAPTURE_NEW
10913 && !structured_block
10914 && TREE_CODE (orig_lhs
) == COMPOUND_EXPR
)
10915 code
= OMP_ATOMIC_CAPTURE_OLD
;
10918 if (TREE_CODE (TREE_OPERAND (lhs
, 1)) == TRUTH_NOT_EXPR
10919 && TREE_OPERAND (lhs
, 0)
10920 == TREE_OPERAND (TREE_OPERAND (lhs
, 1), 0))
10922 /* This is pre or post decrement. */
10923 rhs
= TREE_OPERAND (lhs
, 1);
10924 lhs
= TREE_OPERAND (lhs
, 0);
10925 unfolded_lhs
= NULL_TREE
;
10927 if (code
== OMP_ATOMIC_CAPTURE_NEW
10928 && !structured_block
10929 && TREE_CODE (orig_lhs
) == COMPOUND_EXPR
)
10930 code
= OMP_ATOMIC_CAPTURE_OLD
;
10936 switch (c_parser_peek_token (parser
)->type
)
10939 opcode
= MULT_EXPR
;
10942 opcode
= TRUNC_DIV_EXPR
;
10945 opcode
= PLUS_EXPR
;
10948 opcode
= MINUS_EXPR
;
10950 case CPP_LSHIFT_EQ
:
10951 opcode
= LSHIFT_EXPR
;
10953 case CPP_RSHIFT_EQ
:
10954 opcode
= RSHIFT_EXPR
;
10957 opcode
= BIT_AND_EXPR
;
10960 opcode
= BIT_IOR_EXPR
;
10963 opcode
= BIT_XOR_EXPR
;
10966 c_parser_consume_token (parser
);
10967 eloc
= c_parser_peek_token (parser
)->location
;
10968 expr
= c_parser_expr_no_commas (parser
, NULL
, unfolded_lhs
);
10970 switch (TREE_CODE (rhs1
))
10973 case TRUNC_DIV_EXPR
:
10981 if (c_tree_equal (TREE_OPERAND (rhs1
, 0), unfolded_lhs
))
10983 opcode
= TREE_CODE (rhs1
);
10984 rhs
= c_fully_fold (TREE_OPERAND (rhs1
, 1), false, NULL
);
10985 rhs1
= c_fully_fold (TREE_OPERAND (rhs1
, 0), false, NULL
);
10988 if (c_tree_equal (TREE_OPERAND (rhs1
, 1), unfolded_lhs
))
10990 opcode
= TREE_CODE (rhs1
);
10991 rhs
= c_fully_fold (TREE_OPERAND (rhs1
, 0), false, NULL
);
10992 rhs1
= c_fully_fold (TREE_OPERAND (rhs1
, 1), false, NULL
);
10993 swapped
= !commutative_tree_code (opcode
);
11002 if (c_parser_peek_token (parser
)->type
== CPP_SEMICOLON
)
11004 if (structured_block
&& code
== OMP_ATOMIC_CAPTURE_NEW
)
11006 code
= OMP_ATOMIC_CAPTURE_OLD
;
11009 expr
= default_function_array_read_conversion (eloc
, expr
);
11010 unfolded_lhs1
= expr
.value
;
11011 lhs1
= c_fully_fold (unfolded_lhs1
, false, NULL
);
11013 c_parser_consume_token (parser
);
11016 if (structured_block
)
11019 expr
= default_function_array_read_conversion (eloc
, expr
);
11020 rhs
= c_fully_fold (expr
.value
, false, NULL
);
11025 c_parser_error (parser
, "invalid form of %<#pragma omp atomic%>");
11028 c_parser_error (parser
,
11029 "invalid operator for %<#pragma omp atomic%>");
11033 /* Arrange to pass the location of the assignment operator to
11034 c_finish_omp_atomic. */
11035 loc
= c_parser_peek_token (parser
)->location
;
11036 c_parser_consume_token (parser
);
11037 eloc
= c_parser_peek_token (parser
)->location
;
11038 expr
= c_parser_expression (parser
);
11039 expr
= default_function_array_read_conversion (eloc
, expr
);
11041 rhs
= c_fully_fold (rhs
, false, NULL
);
11045 if (structured_block
&& code
== OMP_ATOMIC_CAPTURE_NEW
)
11047 if (!c_parser_require (parser
, CPP_SEMICOLON
, "expected %<;%>"))
11049 v
= c_parser_unary_expression (parser
).value
;
11050 v
= c_fully_fold (v
, false, NULL
);
11051 if (v
== error_mark_node
)
11053 if (!c_parser_require (parser
, CPP_EQ
, "expected %<=%>"))
11055 eloc
= c_parser_peek_token (parser
)->location
;
11056 expr
= c_parser_unary_expression (parser
);
11058 expr
= default_function_array_read_conversion (eloc
, expr
);
11059 unfolded_lhs1
= expr
.value
;
11060 lhs1
= c_fully_fold (lhs1
, false, NULL
);
11061 if (lhs1
== error_mark_node
)
11064 if (structured_block
)
11066 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
11067 c_parser_require (parser
, CPP_CLOSE_BRACE
, "expected %<}%>");
11070 if (unfolded_lhs
&& unfolded_lhs1
11071 && !c_tree_equal (unfolded_lhs
, unfolded_lhs1
))
11073 error ("%<#pragma omp atomic capture%> uses two different "
11074 "expressions for memory");
11075 stmt
= error_mark_node
;
11078 stmt
= c_finish_omp_atomic (loc
, code
, opcode
, lhs
, rhs
, v
, lhs1
, rhs1
,
11080 if (stmt
!= error_mark_node
)
11083 if (!structured_block
)
11084 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
11089 # pragma omp barrier new-line
11093 c_parser_omp_barrier (c_parser
*parser
)
11095 location_t loc
= c_parser_peek_token (parser
)->location
;
11096 c_parser_consume_pragma (parser
);
11097 c_parser_skip_to_pragma_eol (parser
);
11099 c_finish_omp_barrier (loc
);
11103 # pragma omp critical [(name)] new-line
11106 LOC is the location of the #pragma itself. */
11109 c_parser_omp_critical (location_t loc
, c_parser
*parser
)
11111 tree stmt
, name
= NULL
;
11113 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
11115 c_parser_consume_token (parser
);
11116 if (c_parser_next_token_is (parser
, CPP_NAME
))
11118 name
= c_parser_peek_token (parser
)->value
;
11119 c_parser_consume_token (parser
);
11120 c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
11123 c_parser_error (parser
, "expected identifier");
11125 else if (c_parser_next_token_is_not (parser
, CPP_PRAGMA_EOL
))
11126 c_parser_error (parser
, "expected %<(%> or end of line");
11127 c_parser_skip_to_pragma_eol (parser
);
11129 stmt
= c_parser_omp_structured_block (parser
);
11130 return c_finish_omp_critical (loc
, stmt
, name
);
11134 # pragma omp flush flush-vars[opt] new-line
11137 ( variable-list ) */
11140 c_parser_omp_flush (c_parser
*parser
)
11142 location_t loc
= c_parser_peek_token (parser
)->location
;
11143 c_parser_consume_pragma (parser
);
11144 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
11145 c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_ERROR
, NULL
);
11146 else if (c_parser_next_token_is_not (parser
, CPP_PRAGMA_EOL
))
11147 c_parser_error (parser
, "expected %<(%> or end of line");
11148 c_parser_skip_to_pragma_eol (parser
);
11150 c_finish_omp_flush (loc
);
11153 /* Parse the restricted form of the for statement allowed by OpenMP.
11154 The real trick here is to determine the loop control variable early
11155 so that we can push a new decl if necessary to make it private.
11156 LOC is the location of the OMP in "#pragma omp". */
11159 c_parser_omp_for_loop (location_t loc
, c_parser
*parser
, enum tree_code code
,
11160 tree clauses
, tree
*cclauses
)
11162 tree decl
, cond
, incr
, save_break
, save_cont
, body
, init
, stmt
, cl
;
11163 tree declv
, condv
, incrv
, initv
, ret
= NULL
;
11164 bool fail
= false, open_brace_parsed
= false;
11165 int i
, collapse
= 1, nbraces
= 0;
11166 location_t for_loc
;
11167 vec
<tree
, va_gc
> *for_block
= make_tree_vector ();
11169 for (cl
= clauses
; cl
; cl
= OMP_CLAUSE_CHAIN (cl
))
11170 if (OMP_CLAUSE_CODE (cl
) == OMP_CLAUSE_COLLAPSE
)
11171 collapse
= tree_low_cst (OMP_CLAUSE_COLLAPSE_EXPR (cl
), 0);
11173 gcc_assert (collapse
>= 1);
11175 declv
= make_tree_vec (collapse
);
11176 initv
= make_tree_vec (collapse
);
11177 condv
= make_tree_vec (collapse
);
11178 incrv
= make_tree_vec (collapse
);
11180 if (!c_parser_next_token_is_keyword (parser
, RID_FOR
))
11182 c_parser_error (parser
, "for statement expected");
11185 for_loc
= c_parser_peek_token (parser
)->location
;
11186 c_parser_consume_token (parser
);
11188 for (i
= 0; i
< collapse
; i
++)
11190 int bracecount
= 0;
11192 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
11195 /* Parse the initialization declaration or expression. */
11196 if (c_parser_next_tokens_start_declaration (parser
))
11199 vec_safe_push (for_block
, c_begin_compound_stmt (true));
11200 c_parser_declaration_or_fndef (parser
, true, true, true, true, true,
11202 decl
= check_for_loop_decls (for_loc
, flag_isoc99
);
11205 if (DECL_INITIAL (decl
) == error_mark_node
)
11206 decl
= error_mark_node
;
11209 else if (c_parser_next_token_is (parser
, CPP_NAME
)
11210 && c_parser_peek_2nd_token (parser
)->type
== CPP_EQ
)
11212 struct c_expr decl_exp
;
11213 struct c_expr init_exp
;
11214 location_t init_loc
;
11216 decl_exp
= c_parser_postfix_expression (parser
);
11217 decl
= decl_exp
.value
;
11219 c_parser_require (parser
, CPP_EQ
, "expected %<=%>");
11221 init_loc
= c_parser_peek_token (parser
)->location
;
11222 init_exp
= c_parser_expr_no_commas (parser
, NULL
);
11223 init_exp
= default_function_array_read_conversion (init_loc
,
11225 init
= build_modify_expr (init_loc
, decl
, decl_exp
.original_type
,
11226 NOP_EXPR
, init_loc
, init_exp
.value
,
11227 init_exp
.original_type
);
11228 init
= c_process_expr_stmt (init_loc
, init
);
11230 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
11235 c_parser_error (parser
,
11236 "expected iteration declaration or initialization");
11237 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
11243 /* Parse the loop condition. */
11245 if (c_parser_next_token_is_not (parser
, CPP_SEMICOLON
))
11247 location_t cond_loc
= c_parser_peek_token (parser
)->location
;
11248 struct c_expr cond_expr
11249 = c_parser_binary_expression (parser
, NULL
, NULL_TREE
);
11251 cond
= cond_expr
.value
;
11252 cond
= c_objc_common_truthvalue_conversion (cond_loc
, cond
);
11253 cond
= c_fully_fold (cond
, false, NULL
);
11254 switch (cond_expr
.original_code
)
11262 /* Can't be cond = error_mark_node, because we want to preserve
11263 the location until c_finish_omp_for. */
11264 cond
= build1 (NOP_EXPR
, boolean_type_node
, error_mark_node
);
11267 protected_set_expr_location (cond
, cond_loc
);
11269 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
11271 /* Parse the increment expression. */
11273 if (c_parser_next_token_is_not (parser
, CPP_CLOSE_PAREN
))
11275 location_t incr_loc
= c_parser_peek_token (parser
)->location
;
11277 incr
= c_process_expr_stmt (incr_loc
,
11278 c_parser_expression (parser
).value
);
11280 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
11282 if (decl
== NULL
|| decl
== error_mark_node
|| init
== error_mark_node
)
11286 TREE_VEC_ELT (declv
, i
) = decl
;
11287 TREE_VEC_ELT (initv
, i
) = init
;
11288 TREE_VEC_ELT (condv
, i
) = cond
;
11289 TREE_VEC_ELT (incrv
, i
) = incr
;
11293 if (i
== collapse
- 1)
11296 /* FIXME: OpenMP 3.0 draft isn't very clear on what exactly is allowed
11297 in between the collapsed for loops to be still considered perfectly
11298 nested. Hopefully the final version clarifies this.
11299 For now handle (multiple) {'s and empty statements. */
11302 if (c_parser_next_token_is_keyword (parser
, RID_FOR
))
11304 c_parser_consume_token (parser
);
11307 else if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
11309 c_parser_consume_token (parser
);
11312 else if (bracecount
11313 && c_parser_next_token_is (parser
, CPP_SEMICOLON
))
11314 c_parser_consume_token (parser
);
11317 c_parser_error (parser
, "not enough perfectly nested loops");
11320 open_brace_parsed
= true;
11330 nbraces
+= bracecount
;
11333 save_break
= c_break_label
;
11334 c_break_label
= size_one_node
;
11335 save_cont
= c_cont_label
;
11336 c_cont_label
= NULL_TREE
;
11337 body
= push_stmt_list ();
11339 if (open_brace_parsed
)
11341 location_t here
= c_parser_peek_token (parser
)->location
;
11342 stmt
= c_begin_compound_stmt (true);
11343 c_parser_compound_statement_nostart (parser
);
11344 add_stmt (c_end_compound_stmt (here
, stmt
, true));
11347 add_stmt (c_parser_c99_block_statement (parser
));
11350 tree t
= build1 (LABEL_EXPR
, void_type_node
, c_cont_label
);
11351 SET_EXPR_LOCATION (t
, loc
);
11355 body
= pop_stmt_list (body
);
11356 c_break_label
= save_break
;
11357 c_cont_label
= save_cont
;
11361 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
11363 c_parser_consume_token (parser
);
11366 else if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
11367 c_parser_consume_token (parser
);
11370 c_parser_error (parser
, "collapsed loops not perfectly nested");
11373 location_t here
= c_parser_peek_token (parser
)->location
;
11374 stmt
= c_begin_compound_stmt (true);
11376 c_parser_compound_statement_nostart (parser
);
11377 body
= c_end_compound_stmt (here
, stmt
, true);
11384 /* Only bother calling c_finish_omp_for if we haven't already generated
11385 an error from the initialization parsing. */
11388 stmt
= c_finish_omp_for (loc
, code
, declv
, initv
, condv
,
11389 incrv
, body
, NULL
);
11392 if (cclauses
!= NULL
11393 && cclauses
[C_OMP_CLAUSE_SPLIT_PARALLEL
] != NULL
)
11396 for (c
= &cclauses
[C_OMP_CLAUSE_SPLIT_PARALLEL
]; *c
; )
11397 if (OMP_CLAUSE_CODE (*c
) != OMP_CLAUSE_FIRSTPRIVATE
11398 && OMP_CLAUSE_CODE (*c
) != OMP_CLAUSE_LASTPRIVATE
)
11399 c
= &OMP_CLAUSE_CHAIN (*c
);
11402 for (i
= 0; i
< collapse
; i
++)
11403 if (TREE_VEC_ELT (declv
, i
) == OMP_CLAUSE_DECL (*c
))
11406 c
= &OMP_CLAUSE_CHAIN (*c
);
11407 else if (OMP_CLAUSE_CODE (*c
) == OMP_CLAUSE_FIRSTPRIVATE
)
11410 "iteration variable %qD should not be firstprivate",
11411 OMP_CLAUSE_DECL (*c
));
11412 *c
= OMP_CLAUSE_CHAIN (*c
);
11416 /* Copy lastprivate (decl) clause to OMP_FOR_CLAUSES,
11417 change it to shared (decl) in
11418 OMP_PARALLEL_CLAUSES. */
11419 tree l
= build_omp_clause (OMP_CLAUSE_LOCATION (*c
),
11420 OMP_CLAUSE_LASTPRIVATE
);
11421 OMP_CLAUSE_DECL (l
) = OMP_CLAUSE_DECL (*c
);
11422 OMP_CLAUSE_CHAIN (l
) = clauses
;
11424 OMP_CLAUSE_SET_CODE (*c
, OMP_CLAUSE_SHARED
);
11428 OMP_FOR_CLAUSES (stmt
) = clauses
;
11433 while (!for_block
->is_empty ())
11435 /* FIXME diagnostics: LOC below should be the actual location of
11436 this particular for block. We need to build a list of
11437 locations to go along with FOR_BLOCK. */
11438 stmt
= c_end_compound_stmt (loc
, for_block
->pop (), true);
11441 release_tree_vector (for_block
);
11445 /* Helper function for OpenMP parsing, split clauses and call
11446 finish_omp_clauses on each of the set of clauses afterwards. */
11449 omp_split_clauses (location_t loc
, enum tree_code code
,
11450 omp_clause_mask mask
, tree clauses
, tree
*cclauses
)
11453 c_omp_split_clauses (loc
, code
, mask
, clauses
, cclauses
);
11454 for (i
= 0; i
< C_OMP_CLAUSE_SPLIT_COUNT
; i
++)
11456 cclauses
[i
] = c_finish_omp_clauses (cclauses
[i
]);
11460 #pragma omp simd simd-clause[optseq] new-line
11463 LOC is the location of the #pragma token.
11466 #define OMP_SIMD_CLAUSE_MASK \
11467 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SAFELEN) \
11468 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR) \
11469 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALIGNED) \
11470 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
11471 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
11472 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
11473 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE))
11476 c_parser_omp_simd (location_t loc
, c_parser
*parser
,
11477 char *p_name
, omp_clause_mask mask
, tree
*cclauses
)
11479 tree block
, clauses
, ret
;
11481 strcat (p_name
, " simd");
11482 mask
|= OMP_SIMD_CLAUSE_MASK
;
11483 mask
&= ~(OMP_CLAUSE_MASK_1
<< PRAGMA_OMP_CLAUSE_ORDERED
);
11485 clauses
= c_parser_omp_all_clauses (parser
, mask
, p_name
, cclauses
== NULL
);
11488 omp_split_clauses (loc
, OMP_SIMD
, mask
, clauses
, cclauses
);
11489 clauses
= cclauses
[C_OMP_CLAUSE_SPLIT_SIMD
];
11492 block
= c_begin_compound_stmt (true);
11493 ret
= c_parser_omp_for_loop (loc
, parser
, OMP_SIMD
, clauses
, cclauses
);
11494 block
= c_end_compound_stmt (loc
, block
, true);
11501 #pragma omp for for-clause[optseq] new-line
11505 #pragma omp for simd for-simd-clause[optseq] new-line
11508 LOC is the location of the #pragma token.
11511 #define OMP_FOR_CLAUSE_MASK \
11512 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
11513 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
11514 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
11515 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
11516 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ORDERED) \
11517 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SCHEDULE) \
11518 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE) \
11519 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
11522 c_parser_omp_for (location_t loc
, c_parser
*parser
,
11523 char *p_name
, omp_clause_mask mask
, tree
*cclauses
)
11525 tree block
, clauses
, ret
;
11527 strcat (p_name
, " for");
11528 mask
|= OMP_FOR_CLAUSE_MASK
;
11530 mask
&= ~(OMP_CLAUSE_MASK_1
<< PRAGMA_OMP_CLAUSE_NOWAIT
);
11532 if (c_parser_next_token_is (parser
, CPP_NAME
))
11534 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
11536 if (strcmp (p
, "simd") == 0)
11538 tree cclauses_buf
[C_OMP_CLAUSE_SPLIT_COUNT
];
11539 if (cclauses
== NULL
)
11540 cclauses
= cclauses_buf
;
11542 c_parser_consume_token (parser
);
11543 block
= c_begin_compound_stmt (true);
11544 ret
= c_parser_omp_simd (loc
, parser
, p_name
, mask
, cclauses
);
11545 block
= c_end_compound_stmt (loc
, block
, true);
11546 if (ret
== NULL_TREE
)
11548 ret
= make_node (OMP_FOR
);
11549 TREE_TYPE (ret
) = void_type_node
;
11550 OMP_FOR_BODY (ret
) = block
;
11551 OMP_FOR_CLAUSES (ret
) = cclauses
[C_OMP_CLAUSE_SPLIT_FOR
];
11552 SET_EXPR_LOCATION (ret
, loc
);
11558 clauses
= c_parser_omp_all_clauses (parser
, mask
, p_name
, cclauses
== NULL
);
11561 omp_split_clauses (loc
, OMP_FOR
, mask
, clauses
, cclauses
);
11562 clauses
= cclauses
[C_OMP_CLAUSE_SPLIT_FOR
];
11565 block
= c_begin_compound_stmt (true);
11566 ret
= c_parser_omp_for_loop (loc
, parser
, OMP_FOR
, clauses
, cclauses
);
11567 block
= c_end_compound_stmt (loc
, block
, true);
11574 # pragma omp master new-line
11577 LOC is the location of the #pragma token.
11581 c_parser_omp_master (location_t loc
, c_parser
*parser
)
11583 c_parser_skip_to_pragma_eol (parser
);
11584 return c_finish_omp_master (loc
, c_parser_omp_structured_block (parser
));
11588 # pragma omp ordered new-line
11591 LOC is the location of the #pragma itself.
11595 c_parser_omp_ordered (location_t loc
, c_parser
*parser
)
11597 c_parser_skip_to_pragma_eol (parser
);
11598 return c_finish_omp_ordered (loc
, c_parser_omp_structured_block (parser
));
11604 { section-sequence }
11607 section-directive[opt] structured-block
11608 section-sequence section-directive structured-block
11610 SECTIONS_LOC is the location of the #pragma omp sections. */
11613 c_parser_omp_sections_scope (location_t sections_loc
, c_parser
*parser
)
11615 tree stmt
, substmt
;
11616 bool error_suppress
= false;
11619 loc
= c_parser_peek_token (parser
)->location
;
11620 if (!c_parser_require (parser
, CPP_OPEN_BRACE
, "expected %<{%>"))
11622 /* Avoid skipping until the end of the block. */
11623 parser
->error
= false;
11627 stmt
= push_stmt_list ();
11629 if (c_parser_peek_token (parser
)->pragma_kind
!= PRAGMA_OMP_SECTION
)
11631 substmt
= c_parser_omp_structured_block (parser
);
11632 substmt
= build1 (OMP_SECTION
, void_type_node
, substmt
);
11633 SET_EXPR_LOCATION (substmt
, loc
);
11634 add_stmt (substmt
);
11639 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
11641 if (c_parser_next_token_is (parser
, CPP_EOF
))
11644 loc
= c_parser_peek_token (parser
)->location
;
11645 if (c_parser_peek_token (parser
)->pragma_kind
== PRAGMA_OMP_SECTION
)
11647 c_parser_consume_pragma (parser
);
11648 c_parser_skip_to_pragma_eol (parser
);
11649 error_suppress
= false;
11651 else if (!error_suppress
)
11653 error_at (loc
, "expected %<#pragma omp section%> or %<}%>");
11654 error_suppress
= true;
11657 substmt
= c_parser_omp_structured_block (parser
);
11658 substmt
= build1 (OMP_SECTION
, void_type_node
, substmt
);
11659 SET_EXPR_LOCATION (substmt
, loc
);
11660 add_stmt (substmt
);
11662 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
,
11663 "expected %<#pragma omp section%> or %<}%>");
11665 substmt
= pop_stmt_list (stmt
);
11667 stmt
= make_node (OMP_SECTIONS
);
11668 SET_EXPR_LOCATION (stmt
, sections_loc
);
11669 TREE_TYPE (stmt
) = void_type_node
;
11670 OMP_SECTIONS_BODY (stmt
) = substmt
;
11672 return add_stmt (stmt
);
11676 # pragma omp sections sections-clause[optseq] newline
11679 LOC is the location of the #pragma token.
11682 #define OMP_SECTIONS_CLAUSE_MASK \
11683 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
11684 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
11685 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
11686 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
11687 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
11690 c_parser_omp_sections (location_t loc
, c_parser
*parser
,
11691 char *p_name
, omp_clause_mask mask
, tree
*cclauses
)
11693 tree block
, clauses
, ret
;
11695 strcat (p_name
, " sections");
11696 mask
|= OMP_SECTIONS_CLAUSE_MASK
;
11698 mask
&= ~(OMP_CLAUSE_MASK_1
<< PRAGMA_OMP_CLAUSE_NOWAIT
);
11700 clauses
= c_parser_omp_all_clauses (parser
, mask
, p_name
, cclauses
== NULL
);
11703 omp_split_clauses (loc
, OMP_SECTIONS
, mask
, clauses
, cclauses
);
11704 clauses
= cclauses
[C_OMP_CLAUSE_SPLIT_SECTIONS
];
11707 block
= c_begin_compound_stmt (true);
11708 ret
= c_parser_omp_sections_scope (loc
, parser
);
11710 OMP_SECTIONS_CLAUSES (ret
) = clauses
;
11711 block
= c_end_compound_stmt (loc
, block
, true);
11718 # pragma parallel parallel-clause new-line
11719 # pragma parallel for parallel-for-clause new-line
11720 # pragma parallel sections parallel-sections-clause new-line
11722 LOC is the location of the #pragma token.
11725 #define OMP_PARALLEL_CLAUSE_MASK \
11726 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
11727 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
11728 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
11729 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT) \
11730 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
11731 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COPYIN) \
11732 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
11733 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_THREADS) \
11734 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PROC_BIND))
11737 c_parser_omp_parallel (location_t loc
, c_parser
*parser
,
11738 char *p_name
, omp_clause_mask mask
, tree
*cclauses
)
11740 tree stmt
, clauses
, block
;
11742 strcat (p_name
, " parallel");
11743 mask
|= OMP_PARALLEL_CLAUSE_MASK
;
11745 if (c_parser_next_token_is_keyword (parser
, RID_FOR
))
11747 tree cclauses_buf
[C_OMP_CLAUSE_SPLIT_COUNT
];
11748 if (cclauses
== NULL
)
11749 cclauses
= cclauses_buf
;
11751 c_parser_consume_token (parser
);
11752 block
= c_begin_omp_parallel ();
11753 c_parser_omp_for (loc
, parser
, p_name
, mask
, cclauses
);
11755 = c_finish_omp_parallel (loc
, cclauses
[C_OMP_CLAUSE_SPLIT_PARALLEL
],
11757 OMP_PARALLEL_COMBINED (stmt
) = 1;
11762 error_at (loc
, "expected %<for%> after %qs", p_name
);
11763 c_parser_skip_to_pragma_eol (parser
);
11766 else if (c_parser_next_token_is (parser
, CPP_NAME
))
11768 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
11769 if (strcmp (p
, "sections") == 0)
11771 tree cclauses_buf
[C_OMP_CLAUSE_SPLIT_COUNT
];
11772 if (cclauses
== NULL
)
11773 cclauses
= cclauses_buf
;
11775 c_parser_consume_token (parser
);
11776 block
= c_begin_omp_parallel ();
11777 c_parser_omp_sections (loc
, parser
, p_name
, mask
, cclauses
);
11778 stmt
= c_finish_omp_parallel (loc
,
11779 cclauses
[C_OMP_CLAUSE_SPLIT_PARALLEL
],
11781 OMP_PARALLEL_COMBINED (stmt
) = 1;
11786 clauses
= c_parser_omp_all_clauses (parser
, mask
, p_name
, cclauses
== NULL
);
11788 block
= c_begin_omp_parallel ();
11789 c_parser_statement (parser
);
11790 stmt
= c_finish_omp_parallel (loc
, clauses
, block
);
11796 # pragma omp single single-clause[optseq] new-line
11799 LOC is the location of the #pragma.
11802 #define OMP_SINGLE_CLAUSE_MASK \
11803 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
11804 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
11805 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COPYPRIVATE) \
11806 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT))
11809 c_parser_omp_single (location_t loc
, c_parser
*parser
)
11811 tree stmt
= make_node (OMP_SINGLE
);
11812 SET_EXPR_LOCATION (stmt
, loc
);
11813 TREE_TYPE (stmt
) = void_type_node
;
11815 OMP_SINGLE_CLAUSES (stmt
)
11816 = c_parser_omp_all_clauses (parser
, OMP_SINGLE_CLAUSE_MASK
,
11817 "#pragma omp single");
11818 OMP_SINGLE_BODY (stmt
) = c_parser_omp_structured_block (parser
);
11820 return add_stmt (stmt
);
11824 # pragma omp task task-clause[optseq] new-line
11826 LOC is the location of the #pragma.
11829 #define OMP_TASK_CLAUSE_MASK \
11830 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF) \
11831 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNTIED) \
11832 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT) \
11833 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
11834 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
11835 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
11836 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FINAL) \
11837 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MERGEABLE) \
11838 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEPEND))
11841 c_parser_omp_task (location_t loc
, c_parser
*parser
)
11843 tree clauses
, block
;
11845 clauses
= c_parser_omp_all_clauses (parser
, OMP_TASK_CLAUSE_MASK
,
11846 "#pragma omp task");
11848 block
= c_begin_omp_task ();
11849 c_parser_statement (parser
);
11850 return c_finish_omp_task (loc
, clauses
, block
);
11854 # pragma omp taskwait new-line
11858 c_parser_omp_taskwait (c_parser
*parser
)
11860 location_t loc
= c_parser_peek_token (parser
)->location
;
11861 c_parser_consume_pragma (parser
);
11862 c_parser_skip_to_pragma_eol (parser
);
11864 c_finish_omp_taskwait (loc
);
11868 # pragma omp taskyield new-line
11872 c_parser_omp_taskyield (c_parser
*parser
)
11874 location_t loc
= c_parser_peek_token (parser
)->location
;
11875 c_parser_consume_pragma (parser
);
11876 c_parser_skip_to_pragma_eol (parser
);
11878 c_finish_omp_taskyield (loc
);
11882 # pragma omp taskgroup new-line
11886 c_parser_omp_taskgroup (c_parser
*parser
)
11888 location_t loc
= c_parser_peek_token (parser
)->location
;
11889 c_parser_skip_to_pragma_eol (parser
);
11890 return c_finish_omp_taskgroup (loc
, c_parser_omp_structured_block (parser
));
11894 # pragma omp cancel cancel-clause[optseq] new-line
11896 LOC is the location of the #pragma.
11899 #define OMP_CANCEL_CLAUSE_MASK \
11900 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PARALLEL) \
11901 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FOR) \
11902 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SECTIONS) \
11903 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TASKGROUP) \
11904 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF))
11907 c_parser_omp_cancel (c_parser
*parser
)
11909 location_t loc
= c_parser_peek_token (parser
)->location
;
11911 c_parser_consume_pragma (parser
);
11912 tree clauses
= c_parser_omp_all_clauses (parser
, OMP_CANCEL_CLAUSE_MASK
,
11913 "#pragma omp cancel");
11915 c_finish_omp_cancel (loc
, clauses
);
11919 # pragma omp cancellation point cancelpt-clause[optseq] new-line
11921 LOC is the location of the #pragma.
11924 #define OMP_CANCELLATION_POINT_CLAUSE_MASK \
11925 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PARALLEL) \
11926 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FOR) \
11927 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SECTIONS) \
11928 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TASKGROUP))
11931 c_parser_omp_cancellation_point (c_parser
*parser
)
11933 location_t loc
= c_parser_peek_token (parser
)->location
;
11935 bool point_seen
= false;
11937 c_parser_consume_pragma (parser
);
11938 if (c_parser_next_token_is (parser
, CPP_NAME
))
11940 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
11941 if (strcmp (p
, "point") == 0)
11943 c_parser_consume_token (parser
);
11949 c_parser_error (parser
, "expected %<point%>");
11950 c_parser_skip_to_pragma_eol (parser
);
11955 = c_parser_omp_all_clauses (parser
, OMP_CANCELLATION_POINT_CLAUSE_MASK
,
11956 "#pragma omp cancellation point");
11958 c_finish_omp_cancellation_point (loc
, clauses
);
11962 #pragma omp distribute distribute-clause[optseq] new-line
11965 #define OMP_DISTRIBUTE_CLAUSE_MASK \
11966 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
11967 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
11968 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DIST_SCHEDULE)\
11969 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_COLLAPSE))
11972 c_parser_omp_distribute (location_t loc
, c_parser
*parser
,
11973 char *p_name
, omp_clause_mask mask
, tree
*cclauses
)
11975 tree clauses
, block
, ret
;
11977 strcat (p_name
, " distribute");
11978 mask
|= OMP_DISTRIBUTE_CLAUSE_MASK
;
11980 if (c_parser_next_token_is (parser
, CPP_NAME
))
11982 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
11984 bool parallel
= false;
11986 if (strcmp (p
, "simd") == 0)
11989 parallel
= strcmp (p
, "parallel") == 0;
11990 if (parallel
|| simd
)
11992 tree cclauses_buf
[C_OMP_CLAUSE_SPLIT_COUNT
];
11993 if (cclauses
== NULL
)
11994 cclauses
= cclauses_buf
;
11995 c_parser_consume_token (parser
);
11996 block
= c_begin_compound_stmt (true);
11998 ret
= c_parser_omp_simd (loc
, parser
, p_name
, mask
, cclauses
);
12000 ret
= c_parser_omp_parallel (loc
, parser
, p_name
, mask
, cclauses
);
12001 block
= c_end_compound_stmt (loc
, block
, true);
12004 ret
= make_node (OMP_DISTRIBUTE
);
12005 TREE_TYPE (ret
) = void_type_node
;
12006 OMP_FOR_BODY (ret
) = block
;
12007 OMP_FOR_CLAUSES (ret
) = cclauses
[C_OMP_CLAUSE_SPLIT_DISTRIBUTE
];
12008 SET_EXPR_LOCATION (ret
, loc
);
12014 clauses
= c_parser_omp_all_clauses (parser
, mask
, p_name
, cclauses
== NULL
);
12017 omp_split_clauses (loc
, OMP_DISTRIBUTE
, mask
, clauses
, cclauses
);
12018 clauses
= cclauses
[C_OMP_CLAUSE_SPLIT_DISTRIBUTE
];
12021 block
= c_begin_compound_stmt (true);
12022 ret
= c_parser_omp_for_loop (loc
, parser
, OMP_DISTRIBUTE
, clauses
, NULL
);
12023 block
= c_end_compound_stmt (loc
, block
, true);
12030 # pragma omp teams teams-clause[optseq] new-line
12031 structured-block */
12033 #define OMP_TEAMS_CLAUSE_MASK \
12034 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_PRIVATE) \
12035 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
12036 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SHARED) \
12037 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_REDUCTION) \
12038 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NUM_TEAMS) \
12039 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_THREAD_LIMIT) \
12040 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEFAULT))
12043 c_parser_omp_teams (location_t loc
, c_parser
*parser
,
12044 char *p_name
, omp_clause_mask mask
, tree
*cclauses
)
12046 tree clauses
, block
, ret
;
12048 strcat (p_name
, " teams");
12049 mask
|= OMP_TEAMS_CLAUSE_MASK
;
12051 if (c_parser_next_token_is (parser
, CPP_NAME
))
12053 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
12054 if (strcmp (p
, "distribute") == 0)
12056 tree cclauses_buf
[C_OMP_CLAUSE_SPLIT_COUNT
];
12057 if (cclauses
== NULL
)
12058 cclauses
= cclauses_buf
;
12060 c_parser_consume_token (parser
);
12061 block
= c_begin_compound_stmt (true);
12062 ret
= c_parser_omp_distribute (loc
, parser
, p_name
, mask
, cclauses
);
12063 block
= c_end_compound_stmt (loc
, block
, true);
12066 clauses
= cclauses
[C_OMP_CLAUSE_SPLIT_TEAMS
];
12067 ret
= make_node (OMP_TEAMS
);
12068 TREE_TYPE (ret
) = void_type_node
;
12069 OMP_TEAMS_CLAUSES (ret
) = clauses
;
12070 OMP_TEAMS_BODY (ret
) = block
;
12071 return add_stmt (ret
);
12075 clauses
= c_parser_omp_all_clauses (parser
, mask
, p_name
, cclauses
== NULL
);
12078 omp_split_clauses (loc
, OMP_TEAMS
, mask
, clauses
, cclauses
);
12079 clauses
= cclauses
[C_OMP_CLAUSE_SPLIT_TEAMS
];
12082 tree stmt
= make_node (OMP_TEAMS
);
12083 TREE_TYPE (stmt
) = void_type_node
;
12084 OMP_TEAMS_CLAUSES (stmt
) = clauses
;
12085 OMP_TEAMS_BODY (stmt
) = c_parser_omp_structured_block (parser
);
12087 return add_stmt (stmt
);
12091 # pragma omp target data target-data-clause[optseq] new-line
12092 structured-block */
12094 #define OMP_TARGET_DATA_CLAUSE_MASK \
12095 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
12096 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
12097 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF))
12100 c_parser_omp_target_data (location_t loc
, c_parser
*parser
)
12102 tree stmt
= make_node (OMP_TARGET_DATA
);
12103 TREE_TYPE (stmt
) = void_type_node
;
12105 OMP_TARGET_DATA_CLAUSES (stmt
)
12106 = c_parser_omp_all_clauses (parser
, OMP_TARGET_DATA_CLAUSE_MASK
,
12107 "#pragma omp target data");
12108 keep_next_level ();
12109 tree block
= c_begin_compound_stmt (true);
12110 add_stmt (c_parser_omp_structured_block (parser
));
12111 OMP_TARGET_DATA_BODY (stmt
) = c_end_compound_stmt (loc
, block
, true);
12113 SET_EXPR_LOCATION (stmt
, loc
);
12114 return add_stmt (stmt
);
12118 # pragma omp target update target-update-clause[optseq] new-line */
12120 #define OMP_TARGET_UPDATE_CLAUSE_MASK \
12121 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_FROM) \
12122 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_TO) \
12123 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
12124 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF))
12127 c_parser_omp_target_update (location_t loc
, c_parser
*parser
,
12128 enum pragma_context context
)
12130 if (context
== pragma_stmt
)
12133 "%<#pragma omp target update%> may only be "
12134 "used in compound statements");
12135 c_parser_skip_to_pragma_eol (parser
);
12140 = c_parser_omp_all_clauses (parser
, OMP_TARGET_UPDATE_CLAUSE_MASK
,
12141 "#pragma omp target update");
12142 if (find_omp_clause (clauses
, OMP_CLAUSE_TO
) == NULL_TREE
12143 && find_omp_clause (clauses
, OMP_CLAUSE_FROM
) == NULL_TREE
)
12146 "%<#pragma omp target update must contain at least one "
12147 "%<from%> or %<to%> clauses");
12151 tree stmt
= make_node (OMP_TARGET_UPDATE
);
12152 TREE_TYPE (stmt
) = void_type_node
;
12153 OMP_TARGET_UPDATE_CLAUSES (stmt
) = clauses
;
12154 SET_EXPR_LOCATION (stmt
, loc
);
12160 # pragma omp target target-clause[optseq] new-line
12161 structured-block */
12163 #define OMP_TARGET_CLAUSE_MASK \
12164 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DEVICE) \
12165 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP) \
12166 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_IF))
12169 c_parser_omp_target (c_parser
*parser
, enum pragma_context context
)
12171 location_t loc
= c_parser_peek_token (parser
)->location
;
12172 c_parser_consume_pragma (parser
);
12174 if (context
!= pragma_stmt
&& context
!= pragma_compound
)
12176 c_parser_error (parser
, "expected declaration specifiers");
12177 c_parser_skip_to_pragma_eol (parser
);
12181 if (c_parser_next_token_is (parser
, CPP_NAME
))
12183 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
12185 if (strcmp (p
, "data") == 0)
12187 c_parser_consume_token (parser
);
12188 c_parser_omp_target_data (loc
, parser
);
12191 else if (strcmp (p
, "update") == 0)
12193 c_parser_consume_token (parser
);
12194 return c_parser_omp_target_update (loc
, parser
, context
);
12196 else if (strcmp (p
, "teams") == 0)
12198 tree cclauses
[C_OMP_CLAUSE_SPLIT_COUNT
];
12199 char p_name
[sizeof ("#pragma omp target teams distribute "
12200 "parallel for simd")];
12202 c_parser_consume_token (parser
);
12203 strcpy (p_name
, "#pragma omp target");
12204 keep_next_level ();
12205 tree block
= c_begin_compound_stmt (true);
12206 tree ret
= c_parser_omp_teams (loc
, parser
, p_name
,
12207 OMP_TARGET_CLAUSE_MASK
, cclauses
);
12208 block
= c_end_compound_stmt (loc
, block
, true);
12211 tree stmt
= make_node (OMP_TARGET
);
12212 TREE_TYPE (stmt
) = void_type_node
;
12213 OMP_TARGET_CLAUSES (stmt
) = cclauses
[C_OMP_CLAUSE_SPLIT_TARGET
];
12214 OMP_TARGET_BODY (stmt
) = block
;
12220 tree stmt
= make_node (OMP_TARGET
);
12221 TREE_TYPE (stmt
) = void_type_node
;
12223 OMP_TARGET_CLAUSES (stmt
)
12224 = c_parser_omp_all_clauses (parser
, OMP_TARGET_CLAUSE_MASK
,
12225 "#pragma omp target");
12226 keep_next_level ();
12227 tree block
= c_begin_compound_stmt (true);
12228 add_stmt (c_parser_omp_structured_block (parser
));
12229 OMP_TARGET_BODY (stmt
) = c_end_compound_stmt (loc
, block
, true);
12231 SET_EXPR_LOCATION (stmt
, loc
);
12237 # pragma omp declare simd declare-simd-clauses[optseq] new-line */
12239 #define OMP_DECLARE_SIMD_CLAUSE_MASK \
12240 ( (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_SIMDLEN) \
12241 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_LINEAR) \
12242 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_ALIGNED) \
12243 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_UNIFORM) \
12244 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_INBRANCH) \
12245 | (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOTINBRANCH))
12248 c_parser_omp_declare_simd (c_parser
*parser
, enum pragma_context context
)
12250 vec
<c_token
> clauses
= vNULL
;
12251 while (c_parser_next_token_is_not (parser
, CPP_PRAGMA_EOL
))
12253 c_token
*token
= c_parser_peek_token (parser
);
12254 if (token
->type
== CPP_EOF
)
12256 c_parser_skip_to_pragma_eol (parser
);
12257 clauses
.release ();
12260 clauses
.safe_push (*token
);
12261 c_parser_consume_token (parser
);
12263 clauses
.safe_push (*c_parser_peek_token (parser
));
12264 c_parser_skip_to_pragma_eol (parser
);
12266 while (c_parser_next_token_is (parser
, CPP_PRAGMA
))
12268 if (c_parser_peek_token (parser
)->pragma_kind
12269 != PRAGMA_OMP_DECLARE_REDUCTION
12270 || c_parser_peek_2nd_token (parser
)->type
!= CPP_NAME
12271 || strcmp (IDENTIFIER_POINTER
12272 (c_parser_peek_2nd_token (parser
)->value
),
12275 c_parser_error (parser
,
12276 "%<#pragma omp declare simd%> must be followed by "
12277 "function declaration or definition or another "
12278 "%<#pragma omp declare simd%>");
12279 clauses
.release ();
12282 c_parser_consume_pragma (parser
);
12283 while (c_parser_next_token_is_not (parser
, CPP_PRAGMA_EOL
))
12285 c_token
*token
= c_parser_peek_token (parser
);
12286 if (token
->type
== CPP_EOF
)
12288 c_parser_skip_to_pragma_eol (parser
);
12289 clauses
.release ();
12292 clauses
.safe_push (*token
);
12293 c_parser_consume_token (parser
);
12295 clauses
.safe_push (*c_parser_peek_token (parser
));
12296 c_parser_skip_to_pragma_eol (parser
);
12299 /* Make sure nothing tries to read past the end of the tokens. */
12301 memset (&eof_token
, 0, sizeof (eof_token
));
12302 eof_token
.type
= CPP_EOF
;
12303 clauses
.safe_push (eof_token
);
12304 clauses
.safe_push (eof_token
);
12308 case pragma_external
:
12309 if (c_parser_next_token_is (parser
, CPP_KEYWORD
)
12310 && c_parser_peek_token (parser
)->keyword
== RID_EXTENSION
)
12312 int ext
= disable_extension_diagnostics ();
12314 c_parser_consume_token (parser
);
12315 while (c_parser_next_token_is (parser
, CPP_KEYWORD
)
12316 && c_parser_peek_token (parser
)->keyword
== RID_EXTENSION
);
12317 c_parser_declaration_or_fndef (parser
, true, true, true, false, true,
12319 restore_extension_diagnostics (ext
);
12322 c_parser_declaration_or_fndef (parser
, true, true, true, false, true,
12325 case pragma_struct
:
12327 c_parser_error (parser
, "%<#pragma omp declare simd%> must be followed by "
12328 "function declaration or definition");
12330 case pragma_compound
:
12332 if (c_parser_next_token_is (parser
, CPP_KEYWORD
)
12333 && c_parser_peek_token (parser
)->keyword
== RID_EXTENSION
)
12335 int ext
= disable_extension_diagnostics ();
12337 c_parser_consume_token (parser
);
12338 while (c_parser_next_token_is (parser
, CPP_KEYWORD
)
12339 && c_parser_peek_token (parser
)->keyword
== RID_EXTENSION
);
12340 if (c_parser_next_tokens_start_declaration (parser
))
12342 c_parser_declaration_or_fndef (parser
, true, true, true, true,
12343 true, NULL
, clauses
);
12344 restore_extension_diagnostics (ext
);
12347 restore_extension_diagnostics (ext
);
12349 else if (c_parser_next_tokens_start_declaration (parser
))
12351 c_parser_declaration_or_fndef (parser
, true, true, true, true, true,
12355 c_parser_error (parser
, "%<#pragma omp declare simd%> must be followed by "
12356 "function declaration or definition");
12359 gcc_unreachable ();
12361 clauses
.release ();
12364 /* Finalize #pragma omp declare simd clauses after FNDECL has been parsed,
12365 and put that into "omp declare simd" attribute. */
12368 c_finish_omp_declare_simd (c_parser
*parser
, tree fndecl
, tree parms
,
12369 vec
<c_token
> clauses
)
12371 /* Normally first token is CPP_NAME "simd". CPP_EOF there indicates
12372 error has been reported and CPP_PRAGMA that c_finish_omp_declare_simd
12373 has already processed the tokens. */
12374 if (clauses
[0].type
== CPP_EOF
)
12376 if (fndecl
== NULL_TREE
|| TREE_CODE (fndecl
) != FUNCTION_DECL
)
12378 error ("%<#pragma omp declare simd%> not immediately followed by "
12379 "a function declaration or definition");
12380 clauses
[0].type
= CPP_EOF
;
12383 if (clauses
[0].type
!= CPP_NAME
)
12385 error_at (DECL_SOURCE_LOCATION (fndecl
),
12386 "%<#pragma omp declare simd%> not immediately followed by "
12387 "a single function declaration or definition");
12388 clauses
[0].type
= CPP_EOF
;
12392 if (parms
== NULL_TREE
)
12393 parms
= DECL_ARGUMENTS (fndecl
);
12395 unsigned int tokens_avail
= parser
->tokens_avail
;
12396 gcc_assert (parser
->tokens
== &parser
->tokens_buf
[0]);
12397 parser
->tokens
= clauses
.address ();
12398 parser
->tokens_avail
= clauses
.length ();
12400 /* c_parser_omp_declare_simd pushed 2 extra CPP_EOF tokens at the end. */
12401 while (parser
->tokens_avail
> 3)
12403 c_token
*token
= c_parser_peek_token (parser
);
12404 gcc_assert (token
->type
== CPP_NAME
12405 && strcmp (IDENTIFIER_POINTER (token
->value
), "simd") == 0);
12406 c_parser_consume_token (parser
);
12407 parser
->in_pragma
= true;
12409 tree c
= c_parser_omp_all_clauses (parser
, OMP_DECLARE_SIMD_CLAUSE_MASK
,
12410 "#pragma omp declare simd");
12411 c
= c_omp_declare_simd_clauses_to_numbers (parms
, c
);
12412 if (c
!= NULL_TREE
)
12413 c
= tree_cons (NULL_TREE
, c
, NULL_TREE
);
12414 c
= build_tree_list (get_identifier ("omp declare simd"), c
);
12415 TREE_CHAIN (c
) = DECL_ATTRIBUTES (fndecl
);
12416 DECL_ATTRIBUTES (fndecl
) = c
;
12419 parser
->tokens
= &parser
->tokens_buf
[0];
12420 parser
->tokens_avail
= tokens_avail
;
12421 clauses
[0].type
= CPP_PRAGMA
;
12426 # pragma omp declare target new-line
12427 declarations and definitions
12428 # pragma omp end declare target new-line */
12431 c_parser_omp_declare_target (c_parser
*parser
)
12433 c_parser_skip_to_pragma_eol (parser
);
12434 current_omp_declare_target_attribute
++;
12438 c_parser_omp_end_declare_target (c_parser
*parser
)
12440 location_t loc
= c_parser_peek_token (parser
)->location
;
12441 c_parser_consume_pragma (parser
);
12442 if (c_parser_next_token_is (parser
, CPP_NAME
)
12443 && strcmp (IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
),
12446 c_parser_consume_token (parser
);
12447 if (c_parser_next_token_is (parser
, CPP_NAME
)
12448 && strcmp (IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
),
12450 c_parser_consume_token (parser
);
12453 c_parser_error (parser
, "expected %<target%>");
12454 c_parser_skip_to_pragma_eol (parser
);
12460 c_parser_error (parser
, "expected %<declare%>");
12461 c_parser_skip_to_pragma_eol (parser
);
12464 c_parser_skip_to_pragma_eol (parser
);
12465 if (!current_omp_declare_target_attribute
)
12466 error_at (loc
, "%<#pragma omp end declare target%> without corresponding "
12467 "%<#pragma omp declare target%>");
12469 current_omp_declare_target_attribute
--;
12474 #pragma omp declare reduction (reduction-id : typename-list : expression) \
12475 initializer-clause[opt] new-line
12477 initializer-clause:
12478 initializer (omp_priv = initializer)
12479 initializer (function-name (argument-list)) */
12482 c_parser_omp_declare_reduction (c_parser
*parser
, enum pragma_context context
)
12484 unsigned int tokens_avail
= 0, i
;
12485 vec
<tree
> types
= vNULL
;
12486 vec
<c_token
> clauses
= vNULL
;
12487 enum tree_code reduc_code
= ERROR_MARK
;
12488 tree reduc_id
= NULL_TREE
;
12490 location_t rloc
= c_parser_peek_token (parser
)->location
;
12492 if (context
== pragma_struct
|| context
== pragma_param
)
12494 error ("%<#pragma omp declare reduction%> not at file or block scope");
12498 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
12501 switch (c_parser_peek_token (parser
)->type
)
12504 reduc_code
= PLUS_EXPR
;
12507 reduc_code
= MULT_EXPR
;
12510 reduc_code
= MINUS_EXPR
;
12513 reduc_code
= BIT_AND_EXPR
;
12516 reduc_code
= BIT_XOR_EXPR
;
12519 reduc_code
= BIT_IOR_EXPR
;
12522 reduc_code
= TRUTH_ANDIF_EXPR
;
12525 reduc_code
= TRUTH_ORIF_EXPR
;
12529 p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
12530 if (strcmp (p
, "min") == 0)
12532 reduc_code
= MIN_EXPR
;
12535 if (strcmp (p
, "max") == 0)
12537 reduc_code
= MAX_EXPR
;
12540 reduc_id
= c_parser_peek_token (parser
)->value
;
12543 c_parser_error (parser
,
12544 "expected %<+%>, %<*%>, %<-%>, %<&%>, "
12545 "%<^%>, %<|%>, %<&&%>, %<||%>, %<min%> or identifier");
12549 tree orig_reduc_id
, reduc_decl
;
12550 orig_reduc_id
= reduc_id
;
12551 reduc_id
= c_omp_reduction_id (reduc_code
, reduc_id
);
12552 reduc_decl
= c_omp_reduction_decl (reduc_id
);
12553 c_parser_consume_token (parser
);
12555 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
12560 location_t loc
= c_parser_peek_token (parser
)->location
;
12561 struct c_type_name
*ctype
= c_parser_type_name (parser
);
12564 type
= groktypename (ctype
, NULL
, NULL
);
12565 if (type
== error_mark_node
)
12567 else if ((INTEGRAL_TYPE_P (type
)
12568 || TREE_CODE (type
) == REAL_TYPE
12569 || TREE_CODE (type
) == COMPLEX_TYPE
)
12570 && orig_reduc_id
== NULL_TREE
)
12571 error_at (loc
, "predeclared arithmetic type in "
12572 "%<#pragma omp declare reduction%>");
12573 else if (TREE_CODE (type
) == FUNCTION_TYPE
12574 || TREE_CODE (type
) == ARRAY_TYPE
)
12575 error_at (loc
, "function or array type in "
12576 "%<#pragma omp declare reduction%>");
12577 else if (TYPE_QUALS_NO_ADDR_SPACE (type
))
12578 error_at (loc
, "const, volatile or restrict qualified type in "
12579 "%<#pragma omp declare reduction%>");
12583 for (t
= DECL_INITIAL (reduc_decl
); t
; t
= TREE_CHAIN (t
))
12584 if (comptypes (TREE_PURPOSE (t
), type
))
12586 error_at (loc
, "redeclaration of %qs "
12587 "%<#pragma omp declare reduction%> for "
12589 IDENTIFIER_POINTER (reduc_id
)
12590 + sizeof ("omp declare reduction ") - 1,
12593 = DECL_SOURCE_LOCATION (TREE_VEC_ELT (TREE_VALUE (t
),
12595 error_at (ploc
, "previous %<#pragma omp declare "
12599 if (t
== NULL_TREE
)
12600 types
.safe_push (type
);
12602 if (c_parser_next_token_is (parser
, CPP_COMMA
))
12603 c_parser_consume_token (parser
);
12611 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%>")
12612 || types
.is_empty ())
12615 clauses
.release ();
12619 c_token
*token
= c_parser_peek_token (parser
);
12620 if (token
->type
== CPP_EOF
|| token
->type
== CPP_PRAGMA_EOL
)
12622 c_parser_consume_token (parser
);
12624 c_parser_skip_to_pragma_eol (parser
);
12628 if (types
.length () > 1)
12630 while (c_parser_next_token_is_not (parser
, CPP_PRAGMA_EOL
))
12632 c_token
*token
= c_parser_peek_token (parser
);
12633 if (token
->type
== CPP_EOF
)
12635 clauses
.safe_push (*token
);
12636 c_parser_consume_token (parser
);
12638 clauses
.safe_push (*c_parser_peek_token (parser
));
12639 c_parser_skip_to_pragma_eol (parser
);
12641 /* Make sure nothing tries to read past the end of the tokens. */
12643 memset (&eof_token
, 0, sizeof (eof_token
));
12644 eof_token
.type
= CPP_EOF
;
12645 clauses
.safe_push (eof_token
);
12646 clauses
.safe_push (eof_token
);
12649 int errs
= errorcount
;
12650 FOR_EACH_VEC_ELT (types
, i
, type
)
12652 tokens_avail
= parser
->tokens_avail
;
12653 gcc_assert (parser
->tokens
== &parser
->tokens_buf
[0]);
12654 if (!clauses
.is_empty ())
12656 parser
->tokens
= clauses
.address ();
12657 parser
->tokens_avail
= clauses
.length ();
12658 parser
->in_pragma
= true;
12661 bool nested
= current_function_decl
!= NULL_TREE
;
12663 c_push_function_context ();
12664 tree fndecl
= build_decl (BUILTINS_LOCATION
, FUNCTION_DECL
,
12665 reduc_id
, default_function_type
);
12666 current_function_decl
= fndecl
;
12667 allocate_struct_function (fndecl
, true);
12669 tree stmt
= push_stmt_list ();
12670 /* Intentionally BUILTINS_LOCATION, so that -Wshadow doesn't
12671 warn about these. */
12672 tree omp_out
= build_decl (BUILTINS_LOCATION
, VAR_DECL
,
12673 get_identifier ("omp_out"), type
);
12674 DECL_ARTIFICIAL (omp_out
) = 1;
12675 DECL_CONTEXT (omp_out
) = fndecl
;
12676 pushdecl (omp_out
);
12677 tree omp_in
= build_decl (BUILTINS_LOCATION
, VAR_DECL
,
12678 get_identifier ("omp_in"), type
);
12679 DECL_ARTIFICIAL (omp_in
) = 1;
12680 DECL_CONTEXT (omp_in
) = fndecl
;
12682 struct c_expr combiner
= c_parser_expression (parser
);
12683 struct c_expr initializer
;
12684 tree omp_priv
= NULL_TREE
, omp_orig
= NULL_TREE
;
12686 initializer
.value
= error_mark_node
;
12687 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
12689 else if (c_parser_next_token_is (parser
, CPP_NAME
)
12690 && strcmp (IDENTIFIER_POINTER
12691 (c_parser_peek_token (parser
)->value
),
12692 "initializer") == 0)
12694 c_parser_consume_token (parser
);
12697 omp_priv
= build_decl (BUILTINS_LOCATION
, VAR_DECL
,
12698 get_identifier ("omp_priv"), type
);
12699 DECL_ARTIFICIAL (omp_priv
) = 1;
12700 DECL_INITIAL (omp_priv
) = error_mark_node
;
12701 DECL_CONTEXT (omp_priv
) = fndecl
;
12702 pushdecl (omp_priv
);
12703 omp_orig
= build_decl (BUILTINS_LOCATION
, VAR_DECL
,
12704 get_identifier ("omp_orig"), type
);
12705 DECL_ARTIFICIAL (omp_orig
) = 1;
12706 DECL_CONTEXT (omp_orig
) = fndecl
;
12707 pushdecl (omp_orig
);
12708 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
12710 else if (!c_parser_next_token_is (parser
, CPP_NAME
))
12712 c_parser_error (parser
, "expected %<omp_priv%> or "
12716 else if (strcmp (IDENTIFIER_POINTER
12717 (c_parser_peek_token (parser
)->value
),
12720 if (c_parser_peek_2nd_token (parser
)->type
!= CPP_OPEN_PAREN
12721 || c_parser_peek_token (parser
)->id_kind
!= C_ID_ID
)
12723 c_parser_error (parser
, "expected function-name %<(%>");
12727 initializer
= c_parser_postfix_expression (parser
);
12728 if (initializer
.value
12729 && TREE_CODE (initializer
.value
) == CALL_EXPR
)
12732 tree c
= initializer
.value
;
12733 for (j
= 0; j
< call_expr_nargs (c
); j
++)
12734 if (TREE_CODE (CALL_EXPR_ARG (c
, j
)) == ADDR_EXPR
12735 && TREE_OPERAND (CALL_EXPR_ARG (c
, j
), 0) == omp_priv
)
12737 if (j
== call_expr_nargs (c
))
12738 error ("one of the initializer call arguments should be "
12744 c_parser_consume_token (parser
);
12745 if (!c_parser_require (parser
, CPP_EQ
, "expected %<=%>"))
12749 tree st
= push_stmt_list ();
12750 start_init (omp_priv
, NULL_TREE
, 0);
12751 location_t loc
= c_parser_peek_token (parser
)->location
;
12752 struct c_expr init
= c_parser_initializer (parser
);
12754 finish_decl (omp_priv
, loc
, init
.value
,
12755 init
.original_type
, NULL_TREE
);
12756 pop_stmt_list (st
);
12760 && !c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
12766 c_parser_skip_to_pragma_eol (parser
);
12768 tree t
= tree_cons (type
, make_tree_vec (omp_priv
? 6 : 3),
12769 DECL_INITIAL (reduc_decl
));
12770 DECL_INITIAL (reduc_decl
) = t
;
12771 DECL_SOURCE_LOCATION (omp_out
) = rloc
;
12772 TREE_VEC_ELT (TREE_VALUE (t
), 0) = omp_out
;
12773 TREE_VEC_ELT (TREE_VALUE (t
), 1) = omp_in
;
12774 TREE_VEC_ELT (TREE_VALUE (t
), 2) = combiner
.value
;
12775 walk_tree (&combiner
.value
, c_check_omp_declare_reduction_r
,
12776 &TREE_VEC_ELT (TREE_VALUE (t
), 0), NULL
);
12779 DECL_SOURCE_LOCATION (omp_priv
) = rloc
;
12780 TREE_VEC_ELT (TREE_VALUE (t
), 3) = omp_priv
;
12781 TREE_VEC_ELT (TREE_VALUE (t
), 4) = omp_orig
;
12782 TREE_VEC_ELT (TREE_VALUE (t
), 5) = initializer
.value
;
12783 walk_tree (&initializer
.value
, c_check_omp_declare_reduction_r
,
12784 &TREE_VEC_ELT (TREE_VALUE (t
), 3), NULL
);
12785 walk_tree (&DECL_INITIAL (omp_priv
),
12786 c_check_omp_declare_reduction_r
,
12787 &TREE_VEC_ELT (TREE_VALUE (t
), 3), NULL
);
12791 pop_stmt_list (stmt
);
12793 if (cfun
->language
!= NULL
)
12795 ggc_free (cfun
->language
);
12796 cfun
->language
= NULL
;
12799 current_function_decl
= NULL_TREE
;
12801 c_pop_function_context ();
12803 if (!clauses
.is_empty ())
12805 parser
->tokens
= &parser
->tokens_buf
[0];
12806 parser
->tokens_avail
= tokens_avail
;
12810 if (errs
!= errorcount
)
12814 clauses
.release ();
12820 #pragma omp declare simd declare-simd-clauses[optseq] new-line
12821 #pragma omp declare reduction (reduction-id : typename-list : expression) \
12822 initializer-clause[opt] new-line
12823 #pragma omp declare target new-line */
12826 c_parser_omp_declare (c_parser
*parser
, enum pragma_context context
)
12828 c_parser_consume_pragma (parser
);
12829 if (c_parser_next_token_is (parser
, CPP_NAME
))
12831 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
12832 if (strcmp (p
, "simd") == 0)
12834 /* c_parser_consume_token (parser); done in
12835 c_parser_omp_declare_simd. */
12836 c_parser_omp_declare_simd (parser
, context
);
12839 if (strcmp (p
, "reduction") == 0)
12841 c_parser_consume_token (parser
);
12842 c_parser_omp_declare_reduction (parser
, context
);
12845 if (strcmp (p
, "target") == 0)
12847 c_parser_consume_token (parser
);
12848 c_parser_omp_declare_target (parser
);
12853 c_parser_error (parser
, "expected %<simd%> or %<reduction%> "
12855 c_parser_skip_to_pragma_eol (parser
);
12858 /* Main entry point to parsing most OpenMP pragmas. */
12861 c_parser_omp_construct (c_parser
*parser
)
12863 enum pragma_kind p_kind
;
12866 char p_name
[sizeof "#pragma omp teams distribute parallel for simd"];
12867 omp_clause_mask
mask (0);
12869 loc
= c_parser_peek_token (parser
)->location
;
12870 p_kind
= c_parser_peek_token (parser
)->pragma_kind
;
12871 c_parser_consume_pragma (parser
);
12875 case PRAGMA_OMP_ATOMIC
:
12876 c_parser_omp_atomic (loc
, parser
);
12878 case PRAGMA_OMP_CRITICAL
:
12879 stmt
= c_parser_omp_critical (loc
, parser
);
12881 case PRAGMA_OMP_DISTRIBUTE
:
12882 strcpy (p_name
, "#pragma omp");
12883 stmt
= c_parser_omp_distribute (loc
, parser
, p_name
, mask
, NULL
);
12885 case PRAGMA_OMP_FOR
:
12886 strcpy (p_name
, "#pragma omp");
12887 stmt
= c_parser_omp_for (loc
, parser
, p_name
, mask
, NULL
);
12889 case PRAGMA_OMP_MASTER
:
12890 stmt
= c_parser_omp_master (loc
, parser
);
12892 case PRAGMA_OMP_ORDERED
:
12893 stmt
= c_parser_omp_ordered (loc
, parser
);
12895 case PRAGMA_OMP_PARALLEL
:
12896 strcpy (p_name
, "#pragma omp");
12897 stmt
= c_parser_omp_parallel (loc
, parser
, p_name
, mask
, NULL
);
12899 case PRAGMA_OMP_SECTIONS
:
12900 strcpy (p_name
, "#pragma omp");
12901 stmt
= c_parser_omp_sections (loc
, parser
, p_name
, mask
, NULL
);
12903 case PRAGMA_OMP_SIMD
:
12904 strcpy (p_name
, "#pragma omp");
12905 stmt
= c_parser_omp_simd (loc
, parser
, p_name
, mask
, NULL
);
12907 case PRAGMA_OMP_SINGLE
:
12908 stmt
= c_parser_omp_single (loc
, parser
);
12910 case PRAGMA_OMP_TASK
:
12911 stmt
= c_parser_omp_task (loc
, parser
);
12913 case PRAGMA_OMP_TASKGROUP
:
12914 stmt
= c_parser_omp_taskgroup (parser
);
12916 case PRAGMA_OMP_TEAMS
:
12917 strcpy (p_name
, "#pragma omp");
12918 stmt
= c_parser_omp_teams (loc
, parser
, p_name
, mask
, NULL
);
12921 gcc_unreachable ();
12925 gcc_assert (EXPR_LOCATION (stmt
) != UNKNOWN_LOCATION
);
12930 # pragma omp threadprivate (variable-list) */
12933 c_parser_omp_threadprivate (c_parser
*parser
)
12938 c_parser_consume_pragma (parser
);
12939 loc
= c_parser_peek_token (parser
)->location
;
12940 vars
= c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_ERROR
, NULL
);
12942 /* Mark every variable in VARS to be assigned thread local storage. */
12943 for (t
= vars
; t
; t
= TREE_CHAIN (t
))
12945 tree v
= TREE_PURPOSE (t
);
12947 /* FIXME diagnostics: Ideally we should keep individual
12948 locations for all the variables in the var list to make the
12949 following errors more precise. Perhaps
12950 c_parser_omp_var_list_parens() should construct a list of
12951 locations to go along with the var list. */
12953 /* If V had already been marked threadprivate, it doesn't matter
12954 whether it had been used prior to this point. */
12955 if (TREE_CODE (v
) != VAR_DECL
)
12956 error_at (loc
, "%qD is not a variable", v
);
12957 else if (TREE_USED (v
) && !C_DECL_THREADPRIVATE_P (v
))
12958 error_at (loc
, "%qE declared %<threadprivate%> after first use", v
);
12959 else if (! TREE_STATIC (v
) && ! DECL_EXTERNAL (v
))
12960 error_at (loc
, "automatic variable %qE cannot be %<threadprivate%>", v
);
12961 else if (TREE_TYPE (v
) == error_mark_node
)
12963 else if (! COMPLETE_TYPE_P (TREE_TYPE (v
)))
12964 error_at (loc
, "%<threadprivate%> %qE has incomplete type", v
);
12967 if (! DECL_THREAD_LOCAL_P (v
))
12969 DECL_TLS_MODEL (v
) = decl_default_tls_model (v
);
12970 /* If rtl has been already set for this var, call
12971 make_decl_rtl once again, so that encode_section_info
12972 has a chance to look at the new decl flags. */
12973 if (DECL_RTL_SET_P (v
))
12976 C_DECL_THREADPRIVATE_P (v
) = 1;
12980 c_parser_skip_to_pragma_eol (parser
);
12983 /* Parse a transaction attribute (GCC Extension).
12985 transaction-attribute:
12989 The transactional memory language description is written for C++,
12990 and uses the C++0x attribute syntax. For compatibility, allow the
12991 bracket style for transactions in C as well. */
12994 c_parser_transaction_attributes (c_parser
*parser
)
12996 tree attr_name
, attr
= NULL
;
12998 if (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
12999 return c_parser_attributes (parser
);
13001 if (!c_parser_next_token_is (parser
, CPP_OPEN_SQUARE
))
13003 c_parser_consume_token (parser
);
13004 if (!c_parser_require (parser
, CPP_OPEN_SQUARE
, "expected %<[%>"))
13007 attr_name
= c_parser_attribute_any_word (parser
);
13010 c_parser_consume_token (parser
);
13011 attr
= build_tree_list (attr_name
, NULL_TREE
);
13014 c_parser_error (parser
, "expected identifier");
13016 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
, "expected %<]%>");
13018 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
, "expected %<]%>");
13022 /* Parse a __transaction_atomic or __transaction_relaxed statement
13025 transaction-statement:
13026 __transaction_atomic transaction-attribute[opt] compound-statement
13027 __transaction_relaxed compound-statement
13029 Note that the only valid attribute is: "outer".
13033 c_parser_transaction (c_parser
*parser
, enum rid keyword
)
13035 unsigned int old_in
= parser
->in_transaction
;
13036 unsigned int this_in
= 1, new_in
;
13037 location_t loc
= c_parser_peek_token (parser
)->location
;
13040 gcc_assert ((keyword
== RID_TRANSACTION_ATOMIC
13041 || keyword
== RID_TRANSACTION_RELAXED
)
13042 && c_parser_next_token_is_keyword (parser
, keyword
));
13043 c_parser_consume_token (parser
);
13045 if (keyword
== RID_TRANSACTION_RELAXED
)
13046 this_in
|= TM_STMT_ATTR_RELAXED
;
13049 attrs
= c_parser_transaction_attributes (parser
);
13051 this_in
|= parse_tm_stmt_attr (attrs
, TM_STMT_ATTR_OUTER
);
13054 /* Keep track if we're in the lexical scope of an outer transaction. */
13055 new_in
= this_in
| (old_in
& TM_STMT_ATTR_OUTER
);
13057 parser
->in_transaction
= new_in
;
13058 stmt
= c_parser_compound_statement (parser
);
13059 parser
->in_transaction
= old_in
;
13062 stmt
= c_finish_transaction (loc
, stmt
, this_in
);
13064 error_at (loc
, (keyword
== RID_TRANSACTION_ATOMIC
?
13065 "%<__transaction_atomic%> without transactional memory support enabled"
13066 : "%<__transaction_relaxed %> "
13067 "without transactional memory support enabled"));
13072 /* Parse a __transaction_atomic or __transaction_relaxed expression
13075 transaction-expression:
13076 __transaction_atomic ( expression )
13077 __transaction_relaxed ( expression )
13080 static struct c_expr
13081 c_parser_transaction_expression (c_parser
*parser
, enum rid keyword
)
13084 unsigned int old_in
= parser
->in_transaction
;
13085 unsigned int this_in
= 1;
13086 location_t loc
= c_parser_peek_token (parser
)->location
;
13089 gcc_assert ((keyword
== RID_TRANSACTION_ATOMIC
13090 || keyword
== RID_TRANSACTION_RELAXED
)
13091 && c_parser_next_token_is_keyword (parser
, keyword
));
13092 c_parser_consume_token (parser
);
13094 if (keyword
== RID_TRANSACTION_RELAXED
)
13095 this_in
|= TM_STMT_ATTR_RELAXED
;
13098 attrs
= c_parser_transaction_attributes (parser
);
13100 this_in
|= parse_tm_stmt_attr (attrs
, 0);
13103 parser
->in_transaction
= this_in
;
13104 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
13106 tree expr
= c_parser_expression (parser
).value
;
13107 ret
.original_type
= TREE_TYPE (expr
);
13108 ret
.value
= build1 (TRANSACTION_EXPR
, ret
.original_type
, expr
);
13109 if (this_in
& TM_STMT_ATTR_RELAXED
)
13110 TRANSACTION_EXPR_RELAXED (ret
.value
) = 1;
13111 SET_EXPR_LOCATION (ret
.value
, loc
);
13112 ret
.original_code
= TRANSACTION_EXPR
;
13113 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
13115 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
13122 ret
.value
= error_mark_node
;
13123 ret
.original_code
= ERROR_MARK
;
13124 ret
.original_type
= NULL
;
13126 parser
->in_transaction
= old_in
;
13129 error_at (loc
, (keyword
== RID_TRANSACTION_ATOMIC
?
13130 "%<__transaction_atomic%> without transactional memory support enabled"
13131 : "%<__transaction_relaxed %> "
13132 "without transactional memory support enabled"));
13137 /* Parse a __transaction_cancel statement (GCC Extension).
13139 transaction-cancel-statement:
13140 __transaction_cancel transaction-attribute[opt] ;
13142 Note that the only valid attribute is "outer".
13146 c_parser_transaction_cancel (c_parser
*parser
)
13148 location_t loc
= c_parser_peek_token (parser
)->location
;
13150 bool is_outer
= false;
13152 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_TRANSACTION_CANCEL
));
13153 c_parser_consume_token (parser
);
13155 attrs
= c_parser_transaction_attributes (parser
);
13157 is_outer
= (parse_tm_stmt_attr (attrs
, TM_STMT_ATTR_OUTER
) != 0);
13161 error_at (loc
, "%<__transaction_cancel%> without "
13162 "transactional memory support enabled");
13165 else if (parser
->in_transaction
& TM_STMT_ATTR_RELAXED
)
13167 error_at (loc
, "%<__transaction_cancel%> within a "
13168 "%<__transaction_relaxed%>");
13173 if ((parser
->in_transaction
& TM_STMT_ATTR_OUTER
) == 0
13174 && !is_tm_may_cancel_outer (current_function_decl
))
13176 error_at (loc
, "outer %<__transaction_cancel%> not "
13177 "within outer %<__transaction_atomic%>");
13178 error_at (loc
, " or a %<transaction_may_cancel_outer%> function");
13182 else if (parser
->in_transaction
== 0)
13184 error_at (loc
, "%<__transaction_cancel%> not within "
13185 "%<__transaction_atomic%>");
13189 return add_stmt (build_tm_abort_call (loc
, is_outer
));
13192 return build1 (NOP_EXPR
, void_type_node
, error_mark_node
);
13195 /* Parse a single source file. */
13198 c_parse_file (void)
13200 /* Use local storage to begin. If the first token is a pragma, parse it.
13201 If it is #pragma GCC pch_preprocess, then this will load a PCH file
13202 which will cause garbage collection. */
13205 memset (&tparser
, 0, sizeof tparser
);
13206 tparser
.tokens
= &tparser
.tokens_buf
[0];
13207 the_parser
= &tparser
;
13209 if (c_parser_peek_token (&tparser
)->pragma_kind
== PRAGMA_GCC_PCH_PREPROCESS
)
13210 c_parser_pragma_pch_preprocess (&tparser
);
13212 the_parser
= ggc_alloc_c_parser ();
13213 *the_parser
= tparser
;
13214 if (tparser
.tokens
== &tparser
.tokens_buf
[0])
13215 the_parser
->tokens
= &the_parser
->tokens_buf
[0];
13217 /* Initialize EH, if we've been told to do so. */
13218 if (flag_exceptions
)
13219 using_eh_for_cleanups ();
13221 c_parser_translation_unit (the_parser
);
13225 /* This function parses Cilk Plus array notation. The starting index is
13226 passed in INITIAL_INDEX and the array name is passes in ARRAY_VALUE. The
13227 return value of this function is a tree_node called VALUE_TREE of type
13228 ARRAY_NOTATION_REF. */
13231 c_parser_array_notation (location_t loc
, c_parser
*parser
, tree initial_index
,
13234 c_token
*token
= NULL
;
13235 tree start_index
= NULL_TREE
, end_index
= NULL_TREE
, stride
= NULL_TREE
;
13236 tree value_tree
= NULL_TREE
, type
= NULL_TREE
, array_type
= NULL_TREE
;
13237 tree array_type_domain
= NULL_TREE
;
13239 if (array_value
== error_mark_node
)
13241 /* No need to continue. If either of these 2 were true, then an error
13242 must be emitted already. Thus, no need to emit them twice. */
13243 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
, NULL
);
13244 return error_mark_node
;
13247 array_type
= TREE_TYPE (array_value
);
13248 gcc_assert (array_type
);
13249 type
= TREE_TYPE (array_type
);
13250 token
= c_parser_peek_token (parser
);
13252 if (token
->type
== CPP_EOF
)
13254 c_parser_error (parser
, "expected %<:%> or numeral");
13257 else if (token
->type
== CPP_COLON
)
13259 if (!initial_index
)
13261 /* If we are here, then we have a case like this A[:]. */
13262 c_parser_consume_token (parser
);
13263 if (TREE_CODE (array_type
) == POINTER_TYPE
)
13265 error_at (loc
, "start-index and length fields necessary for "
13266 "using array notations in pointers");
13267 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
, NULL
);
13268 return error_mark_node
;
13270 if (TREE_CODE (array_type
) == FUNCTION_TYPE
)
13272 error_at (loc
, "array notations cannot be used with function "
13274 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
, NULL
);
13275 return error_mark_node
;
13277 array_type_domain
= TYPE_DOMAIN (array_type
);
13279 if (!array_type_domain
)
13281 error_at (loc
, "start-index and length fields necessary for "
13282 "using array notations in dimensionless arrays");
13283 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
, NULL
);
13284 return error_mark_node
;
13287 start_index
= TYPE_MINVAL (array_type_domain
);
13288 start_index
= fold_build1 (CONVERT_EXPR
, ptrdiff_type_node
,
13290 if (!TYPE_MAXVAL (array_type_domain
)
13291 || !TREE_CONSTANT (TYPE_MAXVAL (array_type_domain
)))
13293 error_at (loc
, "start-index and length fields necessary for "
13294 "using array notations in variable-length arrays");
13295 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
, NULL
);
13296 return error_mark_node
;
13298 end_index
= TYPE_MAXVAL (array_type_domain
);
13299 end_index
= fold_build2 (PLUS_EXPR
, TREE_TYPE (end_index
),
13300 end_index
, integer_one_node
);
13301 end_index
= fold_build1 (CONVERT_EXPR
, ptrdiff_type_node
, end_index
);
13302 stride
= build_int_cst (integer_type_node
, 1);
13303 stride
= fold_build1 (CONVERT_EXPR
, ptrdiff_type_node
, stride
);
13305 else if (initial_index
!= error_mark_node
)
13307 /* If we are here, then there should be 2 possibilities:
13308 1. Array [EXPR : EXPR]
13309 2. Array [EXPR : EXPR : EXPR]
13311 start_index
= initial_index
;
13313 if (TREE_CODE (array_type
) == FUNCTION_TYPE
)
13315 error_at (loc
, "array notations cannot be used with function "
13317 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
, NULL
);
13318 return error_mark_node
;
13320 c_parser_consume_token (parser
); /* consume the ':' */
13321 end_index
= c_parser_expression (parser
).value
;
13322 if (!end_index
|| end_index
== error_mark_node
)
13324 c_parser_skip_to_end_of_block_or_statement (parser
);
13325 return error_mark_node
;
13327 if (c_parser_peek_token (parser
)->type
== CPP_COLON
)
13329 c_parser_consume_token (parser
);
13330 stride
= c_parser_expression (parser
).value
;
13331 if (!stride
|| stride
== error_mark_node
)
13333 c_parser_skip_to_end_of_block_or_statement (parser
);
13334 return error_mark_node
;
13339 c_parser_error (parser
, "expected array notation expression");
13342 c_parser_error (parser
, "expected array notation expression");
13344 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
, "expected %<]%>");
13346 value_tree
= build_array_notation_ref (loc
, array_value
, start_index
,
13347 end_index
, stride
, type
);
13348 if (value_tree
!= error_mark_node
)
13349 SET_EXPR_LOCATION (value_tree
, loc
);
13353 #include "gt-c-c-parser.h"