1 /* Parser for C and Objective-C.
2 Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
6 Parser actions based on the old Bison parser; structure somewhat
7 influenced by and fragments based on the C++ parser.
9 This file is part of GCC.
11 GCC is free software; you can redistribute it and/or modify it under
12 the terms of the GNU General Public License as published by the Free
13 Software Foundation; either version 3, or (at your option) any later
16 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
17 WARRANTY; without even the implied warranty of MERCHANTABILITY or
18 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
21 You should have received a copy of the GNU General Public License
22 along with GCC; see the file COPYING3. If not see
23 <http://www.gnu.org/licenses/>. */
27 Make sure all relevant comments, and all relevant code from all
28 actions, brought over from old parser. Verify exact correspondence
31 Add testcases covering every input symbol in every state in old and
34 Include full syntax for GNU C, including erroneous cases accepted
35 with error messages, in syntax productions in comments.
37 Make more diagnostics in the front end generally take an explicit
38 location rather than implicitly using input_location. */
42 #include "coretypes.h"
43 #include "tm.h" /* For rtl.h: needs enum reg_class. */
45 #include "langhooks.h"
49 #include "c-family/c-pragma.h"
55 #include "c-family/c-common.h"
62 /* Initialization routine for this file. */
67 /* The only initialization required is of the reserved word
73 /* Make sure RID_MAX hasn't grown past the 8 bits used to hold the keyword in
74 the c_token structure. */
75 gcc_assert (RID_MAX
<= 255);
82 mask
|= D_ASM
| D_EXT
;
86 if (!c_dialect_objc ())
87 mask
|= D_OBJC
| D_CXX_OBJC
;
89 ridpointers
= ggc_alloc_cleared_vec_tree ((int) RID_MAX
);
90 for (i
= 0; i
< num_c_common_reswords
; i
++)
92 /* If a keyword is disabled, do not enter it into the table
93 and so create a canonical spelling that isn't a keyword. */
94 if (c_common_reswords
[i
].disable
& mask
)
97 && (c_common_reswords
[i
].disable
& D_CXXWARN
))
99 id
= get_identifier (c_common_reswords
[i
].word
);
100 C_SET_RID_CODE (id
, RID_CXX_COMPAT_WARN
);
101 C_IS_RESERVED_WORD (id
) = 1;
106 id
= get_identifier (c_common_reswords
[i
].word
);
107 C_SET_RID_CODE (id
, c_common_reswords
[i
].rid
);
108 C_IS_RESERVED_WORD (id
) = 1;
109 ridpointers
[(int) c_common_reswords
[i
].rid
] = id
;
113 /* The C lexer intermediates between the lexer in cpplib and c-lex.c
114 and the C parser. Unlike the C++ lexer, the parser structure
115 stores the lexer information instead of using a separate structure.
116 Identifiers are separated into ordinary identifiers, type names,
117 keywords and some other Objective-C types of identifiers, and some
118 look-ahead is maintained.
120 ??? It might be a good idea to lex the whole file up front (as for
121 C++). It would then be possible to share more of the C and C++
122 lexer code, if desired. */
124 /* The following local token type is used. */
127 #define CPP_KEYWORD ((enum cpp_ttype) (N_TTYPES + 1))
129 /* More information about the type of a CPP_NAME token. */
130 typedef enum c_id_kind
{
131 /* An ordinary identifier. */
133 /* An identifier declared as a typedef name. */
135 /* An identifier declared as an Objective-C class name. */
137 /* An address space identifier. */
139 /* Not an identifier. */
143 /* A single C token after string literal concatenation and conversion
144 of preprocessing tokens to tokens. */
145 typedef struct GTY (()) c_token
{
146 /* The kind of token. */
147 ENUM_BITFIELD (cpp_ttype
) type
: 8;
148 /* If this token is a CPP_NAME, this value indicates whether also
149 declared as some kind of type. Otherwise, it is C_ID_NONE. */
150 ENUM_BITFIELD (c_id_kind
) id_kind
: 8;
151 /* If this token is a keyword, this value indicates which keyword.
152 Otherwise, this value is RID_MAX. */
153 ENUM_BITFIELD (rid
) keyword
: 8;
154 /* If this token is a CPP_PRAGMA, this indicates the pragma that
155 was seen. Otherwise it is PRAGMA_NONE. */
156 ENUM_BITFIELD (pragma_kind
) pragma_kind
: 8;
157 /* The location at which this token was found. */
159 /* The value associated with this token, if any. */
163 /* A parser structure recording information about the state and
164 context of parsing. Includes lexer information with up to two
165 tokens of look-ahead; more are not needed for C. */
166 typedef struct GTY(()) c_parser
{
167 /* The look-ahead tokens. */
169 /* How many look-ahead tokens are available (0, 1 or 2). */
171 /* True if a syntax error is being recovered from; false otherwise.
172 c_parser_error sets this flag. It should clear this flag when
173 enough tokens have been consumed to recover from the error. */
174 BOOL_BITFIELD error
: 1;
175 /* True if we're processing a pragma, and shouldn't automatically
176 consume CPP_PRAGMA_EOL. */
177 BOOL_BITFIELD in_pragma
: 1;
178 /* True if we're parsing the outermost block of an if statement. */
179 BOOL_BITFIELD in_if_block
: 1;
180 /* True if we want to lex an untranslated string. */
181 BOOL_BITFIELD lex_untranslated_string
: 1;
182 /* Objective-C specific parser/lexer information. */
183 BOOL_BITFIELD objc_pq_context
: 1;
184 /* The following flag is needed to contextualize Objective-C lexical
185 analysis. In some cases (e.g., 'int NSObject;'), it is
186 undesirable to bind an identifier to an Objective-C class, even
187 if a class with that name exists. */
188 BOOL_BITFIELD objc_need_raw_identifier
: 1;
192 /* The actual parser and external interface. ??? Does this need to be
193 garbage-collected? */
195 static GTY (()) c_parser
*the_parser
;
198 /* Read in and lex a single token, storing it in *TOKEN. */
201 c_lex_one_token (c_parser
*parser
, c_token
*token
)
203 timevar_push (TV_LEX
);
205 token
->type
= c_lex_with_flags (&token
->value
, &token
->location
, NULL
,
206 (parser
->lex_untranslated_string
207 ? C_LEX_STRING_NO_TRANSLATE
: 0));
208 token
->id_kind
= C_ID_NONE
;
209 token
->keyword
= RID_MAX
;
210 token
->pragma_kind
= PRAGMA_NONE
;
218 bool objc_force_identifier
= parser
->objc_need_raw_identifier
;
219 if (c_dialect_objc ())
220 parser
->objc_need_raw_identifier
= false;
222 if (C_IS_RESERVED_WORD (token
->value
))
224 enum rid rid_code
= C_RID_CODE (token
->value
);
226 if (rid_code
== RID_CXX_COMPAT_WARN
)
228 warning_at (token
->location
,
230 "identifier %qE conflicts with C++ keyword",
233 else if (rid_code
>= RID_FIRST_ADDR_SPACE
234 && rid_code
<= RID_LAST_ADDR_SPACE
)
236 token
->id_kind
= C_ID_ADDRSPACE
;
237 token
->keyword
= rid_code
;
240 else if (c_dialect_objc ())
242 if (!objc_is_reserved_word (token
->value
)
243 && (!OBJC_IS_PQ_KEYWORD (rid_code
)
244 || parser
->objc_pq_context
))
246 /* Return the canonical spelling for this keyword. */
247 token
->value
= ridpointers
[(int) rid_code
];
248 token
->type
= CPP_KEYWORD
;
249 token
->keyword
= rid_code
;
255 token
->type
= CPP_KEYWORD
;
256 token
->keyword
= rid_code
;
261 decl
= lookup_name (token
->value
);
264 if (TREE_CODE (decl
) == TYPE_DECL
)
266 token
->id_kind
= C_ID_TYPENAME
;
270 else if (c_dialect_objc ())
272 tree objc_interface_decl
= objc_is_class_name (token
->value
);
273 /* Objective-C class names are in the same namespace as
274 variables and typedefs, and hence are shadowed by local
276 if (objc_interface_decl
277 && (global_bindings_p ()
278 || (!objc_force_identifier
&& !decl
)))
280 token
->value
= objc_interface_decl
;
281 token
->id_kind
= C_ID_CLASSNAME
;
285 token
->id_kind
= C_ID_ID
;
289 /* This only happens in Objective-C; it must be a keyword. */
290 token
->type
= CPP_KEYWORD
;
291 token
->keyword
= C_RID_CODE (token
->value
);
295 case CPP_CLOSE_PAREN
:
297 /* These tokens may affect the interpretation of any identifiers
298 following, if doing Objective-C. */
299 if (c_dialect_objc ())
300 parser
->objc_need_raw_identifier
= false;
303 /* We smuggled the cpp_token->u.pragma value in an INTEGER_CST. */
304 token
->pragma_kind
= (enum pragma_kind
) TREE_INT_CST_LOW (token
->value
);
310 timevar_pop (TV_LEX
);
313 /* Return a pointer to the next token from PARSER, reading it in if
316 static inline c_token
*
317 c_parser_peek_token (c_parser
*parser
)
319 if (parser
->tokens_avail
== 0)
321 c_lex_one_token (parser
, &parser
->tokens
[0]);
322 parser
->tokens_avail
= 1;
324 return &parser
->tokens
[0];
327 /* Return true if the next token from PARSER has the indicated
331 c_parser_next_token_is (c_parser
*parser
, enum cpp_ttype type
)
333 return c_parser_peek_token (parser
)->type
== type
;
336 /* Return true if the next token from PARSER does not have the
340 c_parser_next_token_is_not (c_parser
*parser
, enum cpp_ttype type
)
342 return !c_parser_next_token_is (parser
, type
);
345 /* Return true if the next token from PARSER is the indicated
349 c_parser_next_token_is_keyword (c_parser
*parser
, enum rid keyword
)
351 return c_parser_peek_token (parser
)->keyword
== keyword
;
354 /* Return true if TOKEN can start a type name,
357 c_token_starts_typename (c_token
*token
)
362 switch (token
->id_kind
)
371 gcc_assert (c_dialect_objc ());
377 switch (token
->keyword
)
410 if (c_dialect_objc ())
418 /* Return true if the next token from PARSER can start a type name,
421 c_parser_next_token_starts_typename (c_parser
*parser
)
423 c_token
*token
= c_parser_peek_token (parser
);
424 return c_token_starts_typename (token
);
427 /* Return true if TOKEN can start declaration specifiers, false
430 c_token_starts_declspecs (c_token
*token
)
435 switch (token
->id_kind
)
444 gcc_assert (c_dialect_objc ());
450 switch (token
->keyword
)
490 if (c_dialect_objc ())
499 /* Return true if TOKEN can start declaration specifiers or a static
500 assertion, false otherwise. */
502 c_token_starts_declaration (c_token
*token
)
504 if (c_token_starts_declspecs (token
)
505 || token
->keyword
== RID_STATIC_ASSERT
)
511 /* Return true if the next token from PARSER can start declaration
512 specifiers, false otherwise. */
514 c_parser_next_token_starts_declspecs (c_parser
*parser
)
516 c_token
*token
= c_parser_peek_token (parser
);
517 return c_token_starts_declspecs (token
);
520 /* Return true if the next token from PARSER can start declaration
521 specifiers or a static assertion, false otherwise. */
523 c_parser_next_token_starts_declaration (c_parser
*parser
)
525 c_token
*token
= c_parser_peek_token (parser
);
526 return c_token_starts_declaration (token
);
529 /* Return a pointer to the next-but-one token from PARSER, reading it
530 in if necessary. The next token is already read in. */
533 c_parser_peek_2nd_token (c_parser
*parser
)
535 if (parser
->tokens_avail
>= 2)
536 return &parser
->tokens
[1];
537 gcc_assert (parser
->tokens_avail
== 1);
538 gcc_assert (parser
->tokens
[0].type
!= CPP_EOF
);
539 gcc_assert (parser
->tokens
[0].type
!= CPP_PRAGMA_EOL
);
540 c_lex_one_token (parser
, &parser
->tokens
[1]);
541 parser
->tokens_avail
= 2;
542 return &parser
->tokens
[1];
545 /* Consume the next token from PARSER. */
548 c_parser_consume_token (c_parser
*parser
)
550 gcc_assert (parser
->tokens_avail
>= 1);
551 gcc_assert (parser
->tokens
[0].type
!= CPP_EOF
);
552 gcc_assert (!parser
->in_pragma
|| parser
->tokens
[0].type
!= CPP_PRAGMA_EOL
);
553 gcc_assert (parser
->error
|| parser
->tokens
[0].type
!= CPP_PRAGMA
);
554 if (parser
->tokens_avail
== 2)
555 parser
->tokens
[0] = parser
->tokens
[1];
556 parser
->tokens_avail
--;
559 /* Expect the current token to be a #pragma. Consume it and remember
560 that we've begun parsing a pragma. */
563 c_parser_consume_pragma (c_parser
*parser
)
565 gcc_assert (!parser
->in_pragma
);
566 gcc_assert (parser
->tokens_avail
>= 1);
567 gcc_assert (parser
->tokens
[0].type
== CPP_PRAGMA
);
568 if (parser
->tokens_avail
== 2)
569 parser
->tokens
[0] = parser
->tokens
[1];
570 parser
->tokens_avail
--;
571 parser
->in_pragma
= true;
574 /* Update the globals input_location and in_system_header from
577 c_parser_set_source_position_from_token (c_token
*token
)
579 if (token
->type
!= CPP_EOF
)
581 input_location
= token
->location
;
585 /* Issue a diagnostic of the form
586 FILE:LINE: MESSAGE before TOKEN
587 where TOKEN is the next token in the input stream of PARSER.
588 MESSAGE (specified by the caller) is usually of the form "expected
591 Do not issue a diagnostic if still recovering from an error.
593 ??? This is taken from the C++ parser, but building up messages in
594 this way is not i18n-friendly and some other approach should be
598 c_parser_error (c_parser
*parser
, const char *gmsgid
)
600 c_token
*token
= c_parser_peek_token (parser
);
603 parser
->error
= true;
606 /* This diagnostic makes more sense if it is tagged to the line of
607 the token we just peeked at. */
608 c_parser_set_source_position_from_token (token
);
609 c_parse_error (gmsgid
,
610 /* Because c_parse_error does not understand
611 CPP_KEYWORD, keywords are treated like
613 (token
->type
== CPP_KEYWORD
? CPP_NAME
: token
->type
),
614 /* ??? The C parser does not save the cpp flags of a
615 token, we need to pass 0 here and we will not get
616 the source spelling of some tokens but rather the
617 canonical spelling. */
618 token
->value
, /*flags=*/0);
621 /* If the next token is of the indicated TYPE, consume it. Otherwise,
622 issue the error MSGID. If MSGID is NULL then a message has already
623 been produced and no message will be produced this time. Returns
624 true if found, false otherwise. */
627 c_parser_require (c_parser
*parser
,
631 if (c_parser_next_token_is (parser
, type
))
633 c_parser_consume_token (parser
);
638 c_parser_error (parser
, msgid
);
643 /* If the next token is the indicated keyword, consume it. Otherwise,
644 issue the error MSGID. Returns true if found, false otherwise. */
647 c_parser_require_keyword (c_parser
*parser
,
651 if (c_parser_next_token_is_keyword (parser
, keyword
))
653 c_parser_consume_token (parser
);
658 c_parser_error (parser
, msgid
);
663 /* Like c_parser_require, except that tokens will be skipped until the
664 desired token is found. An error message is still produced if the
665 next token is not as expected. If MSGID is NULL then a message has
666 already been produced and no message will be produced this
670 c_parser_skip_until_found (c_parser
*parser
,
674 unsigned nesting_depth
= 0;
676 if (c_parser_require (parser
, type
, msgid
))
679 /* Skip tokens until the desired token is found. */
682 /* Peek at the next token. */
683 c_token
*token
= c_parser_peek_token (parser
);
684 /* If we've reached the token we want, consume it and stop. */
685 if (token
->type
== type
&& !nesting_depth
)
687 c_parser_consume_token (parser
);
691 /* If we've run out of tokens, stop. */
692 if (token
->type
== CPP_EOF
)
694 if (token
->type
== CPP_PRAGMA_EOL
&& parser
->in_pragma
)
696 if (token
->type
== CPP_OPEN_BRACE
697 || token
->type
== CPP_OPEN_PAREN
698 || token
->type
== CPP_OPEN_SQUARE
)
700 else if (token
->type
== CPP_CLOSE_BRACE
701 || token
->type
== CPP_CLOSE_PAREN
702 || token
->type
== CPP_CLOSE_SQUARE
)
704 if (nesting_depth
-- == 0)
707 /* Consume this token. */
708 c_parser_consume_token (parser
);
710 parser
->error
= false;
713 /* Skip tokens until the end of a parameter is found, but do not
714 consume the comma, semicolon or closing delimiter. */
717 c_parser_skip_to_end_of_parameter (c_parser
*parser
)
719 unsigned nesting_depth
= 0;
723 c_token
*token
= c_parser_peek_token (parser
);
724 if ((token
->type
== CPP_COMMA
|| token
->type
== CPP_SEMICOLON
)
727 /* If we've run out of tokens, stop. */
728 if (token
->type
== CPP_EOF
)
730 if (token
->type
== CPP_PRAGMA_EOL
&& parser
->in_pragma
)
732 if (token
->type
== CPP_OPEN_BRACE
733 || token
->type
== CPP_OPEN_PAREN
734 || token
->type
== CPP_OPEN_SQUARE
)
736 else if (token
->type
== CPP_CLOSE_BRACE
737 || token
->type
== CPP_CLOSE_PAREN
738 || token
->type
== CPP_CLOSE_SQUARE
)
740 if (nesting_depth
-- == 0)
743 /* Consume this token. */
744 c_parser_consume_token (parser
);
746 parser
->error
= false;
749 /* Expect to be at the end of the pragma directive and consume an
750 end of line marker. */
753 c_parser_skip_to_pragma_eol (c_parser
*parser
)
755 gcc_assert (parser
->in_pragma
);
756 parser
->in_pragma
= false;
758 if (!c_parser_require (parser
, CPP_PRAGMA_EOL
, "expected end of line"))
761 c_token
*token
= c_parser_peek_token (parser
);
762 if (token
->type
== CPP_EOF
)
764 if (token
->type
== CPP_PRAGMA_EOL
)
766 c_parser_consume_token (parser
);
769 c_parser_consume_token (parser
);
772 parser
->error
= false;
775 /* Skip tokens until we have consumed an entire block, or until we
776 have consumed a non-nested ';'. */
779 c_parser_skip_to_end_of_block_or_statement (c_parser
*parser
)
781 unsigned nesting_depth
= 0;
782 bool save_error
= parser
->error
;
788 /* Peek at the next token. */
789 token
= c_parser_peek_token (parser
);
797 if (parser
->in_pragma
)
802 /* If the next token is a ';', we have reached the
803 end of the statement. */
806 /* Consume the ';'. */
807 c_parser_consume_token (parser
);
812 case CPP_CLOSE_BRACE
:
813 /* If the next token is a non-nested '}', then we have
814 reached the end of the current block. */
815 if (nesting_depth
== 0 || --nesting_depth
== 0)
817 c_parser_consume_token (parser
);
823 /* If it the next token is a '{', then we are entering a new
824 block. Consume the entire block. */
829 /* If we see a pragma, consume the whole thing at once. We
830 have some safeguards against consuming pragmas willy-nilly.
831 Normally, we'd expect to be here with parser->error set,
832 which disables these safeguards. But it's possible to get
833 here for secondary error recovery, after parser->error has
835 c_parser_consume_pragma (parser
);
836 c_parser_skip_to_pragma_eol (parser
);
837 parser
->error
= save_error
;
844 c_parser_consume_token (parser
);
848 parser
->error
= false;
851 /* CPP's options (initialized by c-opts.c). */
852 extern cpp_options
*cpp_opts
;
854 /* Save the warning flags which are controlled by __extension__. */
857 disable_extension_diagnostics (void)
860 | (warn_pointer_arith
<< 1)
861 | (warn_traditional
<< 2)
863 | (warn_long_long
<< 4)
864 | (warn_cxx_compat
<< 5));
865 cpp_opts
->pedantic
= pedantic
= 0;
866 warn_pointer_arith
= 0;
867 cpp_opts
->warn_traditional
= warn_traditional
= 0;
869 cpp_opts
->warn_long_long
= warn_long_long
= 0;
874 /* Restore the warning flags which are controlled by __extension__.
875 FLAGS is the return value from disable_extension_diagnostics. */
878 restore_extension_diagnostics (int flags
)
880 cpp_opts
->pedantic
= pedantic
= flags
& 1;
881 warn_pointer_arith
= (flags
>> 1) & 1;
882 cpp_opts
->warn_traditional
= warn_traditional
= (flags
>> 2) & 1;
883 flag_iso
= (flags
>> 3) & 1;
884 cpp_opts
->warn_long_long
= warn_long_long
= (flags
>> 4) & 1;
885 warn_cxx_compat
= (flags
>> 5) & 1;
888 /* Possibly kinds of declarator to parse. */
889 typedef enum c_dtr_syn
{
890 /* A normal declarator with an identifier. */
892 /* An abstract declarator (maybe empty). */
894 /* A parameter declarator: may be either, but after a type name does
895 not redeclare a typedef name as an identifier if it can
896 alternatively be interpreted as a typedef name; see DR#009,
897 applied in C90 TC1, omitted from C99 and reapplied in C99 TC2
898 following DR#249. For example, given a typedef T, "int T" and
899 "int *T" are valid parameter declarations redeclaring T, while
900 "int (T)" and "int * (T)" and "int (T[])" and "int (T (int))" are
901 abstract declarators rather than involving redundant parentheses;
902 the same applies with attributes inside the parentheses before
907 static void c_parser_external_declaration (c_parser
*);
908 static void c_parser_asm_definition (c_parser
*);
909 static void c_parser_declaration_or_fndef (c_parser
*, bool, bool, bool,
911 static void c_parser_static_assert_declaration_no_semi (c_parser
*);
912 static void c_parser_static_assert_declaration (c_parser
*);
913 static void c_parser_declspecs (c_parser
*, struct c_declspecs
*, bool, bool,
915 static struct c_typespec
c_parser_enum_specifier (c_parser
*);
916 static struct c_typespec
c_parser_struct_or_union_specifier (c_parser
*);
917 static tree
c_parser_struct_declaration (c_parser
*);
918 static struct c_typespec
c_parser_typeof_specifier (c_parser
*);
919 static struct c_declarator
*c_parser_declarator (c_parser
*, bool, c_dtr_syn
,
921 static struct c_declarator
*c_parser_direct_declarator (c_parser
*, bool,
923 static struct c_declarator
*c_parser_direct_declarator_inner (c_parser
*,
925 struct c_declarator
*);
926 static struct c_arg_info
*c_parser_parms_declarator (c_parser
*, bool, tree
);
927 static struct c_arg_info
*c_parser_parms_list_declarator (c_parser
*, tree
);
928 static struct c_parm
*c_parser_parameter_declaration (c_parser
*, tree
);
929 static tree
c_parser_simple_asm_expr (c_parser
*);
930 static tree
c_parser_attributes (c_parser
*);
931 static struct c_type_name
*c_parser_type_name (c_parser
*);
932 static struct c_expr
c_parser_initializer (c_parser
*);
933 static struct c_expr
c_parser_braced_init (c_parser
*, tree
, bool);
934 static void c_parser_initelt (c_parser
*, struct obstack
*);
935 static void c_parser_initval (c_parser
*, struct c_expr
*,
937 static tree
c_parser_compound_statement (c_parser
*);
938 static void c_parser_compound_statement_nostart (c_parser
*);
939 static void c_parser_label (c_parser
*);
940 static void c_parser_statement (c_parser
*);
941 static void c_parser_statement_after_labels (c_parser
*);
942 static void c_parser_if_statement (c_parser
*);
943 static void c_parser_switch_statement (c_parser
*);
944 static void c_parser_while_statement (c_parser
*);
945 static void c_parser_do_statement (c_parser
*);
946 static void c_parser_for_statement (c_parser
*);
947 static tree
c_parser_asm_statement (c_parser
*);
948 static tree
c_parser_asm_operands (c_parser
*, bool);
949 static tree
c_parser_asm_goto_operands (c_parser
*);
950 static tree
c_parser_asm_clobbers (c_parser
*);
951 static struct c_expr
c_parser_expr_no_commas (c_parser
*, struct c_expr
*);
952 static struct c_expr
c_parser_conditional_expression (c_parser
*,
954 static struct c_expr
c_parser_binary_expression (c_parser
*, struct c_expr
*);
955 static struct c_expr
c_parser_cast_expression (c_parser
*, struct c_expr
*);
956 static struct c_expr
c_parser_unary_expression (c_parser
*);
957 static struct c_expr
c_parser_sizeof_expression (c_parser
*);
958 static struct c_expr
c_parser_alignof_expression (c_parser
*);
959 static struct c_expr
c_parser_postfix_expression (c_parser
*);
960 static struct c_expr
c_parser_postfix_expression_after_paren_type (c_parser
*,
961 struct c_type_name
*,
963 static struct c_expr
c_parser_postfix_expression_after_primary (c_parser
*,
966 static struct c_expr
c_parser_expression (c_parser
*);
967 static struct c_expr
c_parser_expression_conv (c_parser
*);
968 static VEC(tree
,gc
) *c_parser_expr_list (c_parser
*, bool, bool,
970 static void c_parser_omp_construct (c_parser
*);
971 static void c_parser_omp_threadprivate (c_parser
*);
972 static void c_parser_omp_barrier (c_parser
*);
973 static void c_parser_omp_flush (c_parser
*);
974 static void c_parser_omp_taskwait (c_parser
*);
976 enum pragma_context
{ pragma_external
, pragma_stmt
, pragma_compound
};
977 static bool c_parser_pragma (c_parser
*, enum pragma_context
);
979 /* These Objective-C parser functions are only ever called when
980 compiling Objective-C. */
981 static void c_parser_objc_class_definition (c_parser
*);
982 static void c_parser_objc_class_instance_variables (c_parser
*);
983 static void c_parser_objc_class_declaration (c_parser
*);
984 static void c_parser_objc_alias_declaration (c_parser
*);
985 static void c_parser_objc_protocol_definition (c_parser
*);
986 static enum tree_code
c_parser_objc_method_type (c_parser
*);
987 static void c_parser_objc_method_definition (c_parser
*);
988 static void c_parser_objc_methodprotolist (c_parser
*);
989 static void c_parser_objc_methodproto (c_parser
*);
990 static tree
c_parser_objc_method_decl (c_parser
*);
991 static tree
c_parser_objc_type_name (c_parser
*);
992 static tree
c_parser_objc_protocol_refs (c_parser
*);
993 static void c_parser_objc_try_catch_statement (c_parser
*);
994 static void c_parser_objc_synchronized_statement (c_parser
*);
995 static tree
c_parser_objc_selector (c_parser
*);
996 static tree
c_parser_objc_selector_arg (c_parser
*);
997 static tree
c_parser_objc_receiver (c_parser
*);
998 static tree
c_parser_objc_message_args (c_parser
*);
999 static tree
c_parser_objc_keywordexpr (c_parser
*);
1001 /* Parse a translation unit (C90 6.7, C99 6.9).
1004 external-declarations
1006 external-declarations:
1007 external-declaration
1008 external-declarations external-declaration
1017 c_parser_translation_unit (c_parser
*parser
)
1019 if (c_parser_next_token_is (parser
, CPP_EOF
))
1021 pedwarn (c_parser_peek_token (parser
)->location
, OPT_pedantic
,
1022 "ISO C forbids an empty translation unit");
1026 void *obstack_position
= obstack_alloc (&parser_obstack
, 0);
1027 mark_valid_location_for_stdc_pragma (false);
1031 c_parser_external_declaration (parser
);
1032 obstack_free (&parser_obstack
, obstack_position
);
1034 while (c_parser_next_token_is_not (parser
, CPP_EOF
));
1038 /* Parse an external declaration (C90 6.7, C99 6.9).
1040 external-declaration:
1046 external-declaration:
1049 __extension__ external-declaration
1053 external-declaration:
1054 objc-class-definition
1055 objc-class-declaration
1056 objc-alias-declaration
1057 objc-protocol-definition
1058 objc-method-definition
1063 c_parser_external_declaration (c_parser
*parser
)
1066 switch (c_parser_peek_token (parser
)->type
)
1069 switch (c_parser_peek_token (parser
)->keyword
)
1072 ext
= disable_extension_diagnostics ();
1073 c_parser_consume_token (parser
);
1074 c_parser_external_declaration (parser
);
1075 restore_extension_diagnostics (ext
);
1078 c_parser_asm_definition (parser
);
1080 case RID_AT_INTERFACE
:
1081 case RID_AT_IMPLEMENTATION
:
1082 gcc_assert (c_dialect_objc ());
1083 c_parser_objc_class_definition (parser
);
1086 gcc_assert (c_dialect_objc ());
1087 c_parser_objc_class_declaration (parser
);
1090 gcc_assert (c_dialect_objc ());
1091 c_parser_objc_alias_declaration (parser
);
1093 case RID_AT_PROTOCOL
:
1094 gcc_assert (c_dialect_objc ());
1095 c_parser_objc_protocol_definition (parser
);
1098 gcc_assert (c_dialect_objc ());
1099 c_parser_consume_token (parser
);
1100 objc_finish_implementation ();
1107 pedwarn (c_parser_peek_token (parser
)->location
, OPT_pedantic
,
1108 "ISO C does not allow extra %<;%> outside of a function");
1109 c_parser_consume_token (parser
);
1112 mark_valid_location_for_stdc_pragma (true);
1113 c_parser_pragma (parser
, pragma_external
);
1114 mark_valid_location_for_stdc_pragma (false);
1118 if (c_dialect_objc ())
1120 c_parser_objc_method_definition (parser
);
1123 /* Else fall through, and yield a syntax error trying to parse
1124 as a declaration or function definition. */
1127 /* A declaration or a function definition. We can only tell
1128 which after parsing the declaration specifiers, if any, and
1129 the first declarator. */
1130 c_parser_declaration_or_fndef (parser
, true, true, true, false, true);
1136 /* Parse a declaration or function definition (C90 6.5, 6.7.1, C99
1137 6.7, 6.9.1). If FNDEF_OK is true, a function definition is
1138 accepted; otherwise (old-style parameter declarations) only other
1139 declarations are accepted. If STATIC_ASSERT_OK is true, a static
1140 assertion is accepted; otherwise (old-style parameter declarations)
1141 it is not. If NESTED is true, we are inside a function or parsing
1142 old-style parameter declarations; any functions encountered are
1143 nested functions and declaration specifiers are required; otherwise
1144 we are at top level and functions are normal functions and
1145 declaration specifiers may be optional. If EMPTY_OK is true, empty
1146 declarations are OK (subject to all other constraints); otherwise
1147 (old-style parameter declarations) they are diagnosed. If
1148 START_ATTR_OK is true, the declaration specifiers may start with
1149 attributes; otherwise they may not.
1152 declaration-specifiers init-declarator-list[opt] ;
1153 static_assert-declaration
1155 function-definition:
1156 declaration-specifiers[opt] declarator declaration-list[opt]
1161 declaration-list declaration
1163 init-declarator-list:
1165 init-declarator-list , init-declarator
1168 declarator simple-asm-expr[opt] attributes[opt]
1169 declarator simple-asm-expr[opt] attributes[opt] = initializer
1173 nested-function-definition:
1174 declaration-specifiers declarator declaration-list[opt]
1177 The simple-asm-expr and attributes are GNU extensions.
1179 This function does not handle __extension__; that is handled in its
1180 callers. ??? Following the old parser, __extension__ may start
1181 external declarations, declarations in functions and declarations
1182 at the start of "for" loops, but not old-style parameter
1185 C99 requires declaration specifiers in a function definition; the
1186 absence is diagnosed through the diagnosis of implicit int. In GNU
1187 C we also allow but diagnose declarations without declaration
1188 specifiers, but only at top level (elsewhere they conflict with
1194 threadprivate-directive */
1197 c_parser_declaration_or_fndef (c_parser
*parser
, bool fndef_ok
,
1198 bool static_assert_ok
, bool empty_ok
,
1199 bool nested
, bool start_attr_ok
)
1201 struct c_declspecs
*specs
;
1203 tree all_prefix_attrs
;
1204 bool diagnosed_no_specs
= false;
1205 location_t here
= c_parser_peek_token (parser
)->location
;
1207 if (static_assert_ok
1208 && c_parser_next_token_is_keyword (parser
, RID_STATIC_ASSERT
))
1210 c_parser_static_assert_declaration (parser
);
1213 specs
= build_null_declspecs ();
1214 c_parser_declspecs (parser
, specs
, true, true, start_attr_ok
);
1217 c_parser_skip_to_end_of_block_or_statement (parser
);
1220 if (nested
&& !specs
->declspecs_seen_p
)
1222 c_parser_error (parser
, "expected declaration specifiers");
1223 c_parser_skip_to_end_of_block_or_statement (parser
);
1226 finish_declspecs (specs
);
1227 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
1233 shadow_tag_warned (specs
, 1);
1234 pedwarn (here
, 0, "empty declaration");
1236 c_parser_consume_token (parser
);
1239 pending_xref_error ();
1240 prefix_attrs
= specs
->attrs
;
1241 all_prefix_attrs
= prefix_attrs
;
1242 specs
->attrs
= NULL_TREE
;
1245 struct c_declarator
*declarator
;
1248 /* Declaring either one or more declarators (in which case we
1249 should diagnose if there were no declaration specifiers) or a
1250 function definition (in which case the diagnostic for
1251 implicit int suffices). */
1252 declarator
= c_parser_declarator (parser
, specs
->type_seen_p
,
1253 C_DTR_NORMAL
, &dummy
);
1254 if (declarator
== NULL
)
1256 c_parser_skip_to_end_of_block_or_statement (parser
);
1259 if (c_parser_next_token_is (parser
, CPP_EQ
)
1260 || c_parser_next_token_is (parser
, CPP_COMMA
)
1261 || c_parser_next_token_is (parser
, CPP_SEMICOLON
)
1262 || c_parser_next_token_is_keyword (parser
, RID_ASM
)
1263 || c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
1265 tree asm_name
= NULL_TREE
;
1266 tree postfix_attrs
= NULL_TREE
;
1267 if (!diagnosed_no_specs
&& !specs
->declspecs_seen_p
)
1269 diagnosed_no_specs
= true;
1270 pedwarn (here
, 0, "data definition has no type or storage class");
1272 /* Having seen a data definition, there cannot now be a
1273 function definition. */
1275 if (c_parser_next_token_is_keyword (parser
, RID_ASM
))
1276 asm_name
= c_parser_simple_asm_expr (parser
);
1277 if (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
1278 postfix_attrs
= c_parser_attributes (parser
);
1279 if (c_parser_next_token_is (parser
, CPP_EQ
))
1283 location_t init_loc
;
1284 c_parser_consume_token (parser
);
1285 /* The declaration of the variable is in effect while
1286 its initializer is parsed. */
1287 d
= start_decl (declarator
, specs
, true,
1288 chainon (postfix_attrs
, all_prefix_attrs
));
1290 d
= error_mark_node
;
1291 start_init (d
, asm_name
, global_bindings_p ());
1292 init_loc
= c_parser_peek_token (parser
)->location
;
1293 init
= c_parser_initializer (parser
);
1295 if (d
!= error_mark_node
)
1297 maybe_warn_string_init (TREE_TYPE (d
), init
);
1298 finish_decl (d
, init_loc
, init
.value
,
1299 init
.original_type
, asm_name
);
1304 tree d
= start_decl (declarator
, specs
, false,
1305 chainon (postfix_attrs
,
1308 finish_decl (d
, UNKNOWN_LOCATION
, NULL_TREE
,
1309 NULL_TREE
, asm_name
);
1311 if (c_parser_next_token_is (parser
, CPP_COMMA
))
1313 c_parser_consume_token (parser
);
1314 if (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
1315 all_prefix_attrs
= chainon (c_parser_attributes (parser
),
1318 all_prefix_attrs
= prefix_attrs
;
1321 else if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
1323 c_parser_consume_token (parser
);
1328 c_parser_error (parser
, "expected %<,%> or %<;%>");
1329 c_parser_skip_to_end_of_block_or_statement (parser
);
1335 c_parser_error (parser
, "expected %<=%>, %<,%>, %<;%>, "
1336 "%<asm%> or %<__attribute__%>");
1337 c_parser_skip_to_end_of_block_or_statement (parser
);
1340 /* Function definition (nested or otherwise). */
1343 pedwarn (here
, OPT_pedantic
, "ISO C forbids nested functions");
1344 c_push_function_context ();
1346 if (!start_function (specs
, declarator
, all_prefix_attrs
))
1348 /* This can appear in many cases looking nothing like a
1349 function definition, so we don't give a more specific
1350 error suggesting there was one. */
1351 c_parser_error (parser
, "expected %<=%>, %<,%>, %<;%>, %<asm%> "
1352 "or %<__attribute__%>");
1354 c_pop_function_context ();
1357 /* Parse old-style parameter declarations. ??? Attributes are
1358 not allowed to start declaration specifiers here because of a
1359 syntax conflict between a function declaration with attribute
1360 suffix and a function definition with an attribute prefix on
1361 first old-style parameter declaration. Following the old
1362 parser, they are not accepted on subsequent old-style
1363 parameter declarations either. However, there is no
1364 ambiguity after the first declaration, nor indeed on the
1365 first as long as we don't allow postfix attributes after a
1366 declarator with a nonempty identifier list in a definition;
1367 and postfix attributes have never been accepted here in
1368 function definitions either. */
1369 while (c_parser_next_token_is_not (parser
, CPP_EOF
)
1370 && c_parser_next_token_is_not (parser
, CPP_OPEN_BRACE
))
1371 c_parser_declaration_or_fndef (parser
, false, false, false,
1373 store_parm_decls ();
1374 DECL_STRUCT_FUNCTION (current_function_decl
)->function_start_locus
1375 = c_parser_peek_token (parser
)->location
;
1376 fnbody
= c_parser_compound_statement (parser
);
1379 tree decl
= current_function_decl
;
1380 /* Mark nested functions as needing static-chain initially.
1381 lower_nested_functions will recompute it but the
1382 DECL_STATIC_CHAIN flag is also used before that happens,
1383 by initializer_constant_valid_p. See gcc.dg/nested-fn-2.c. */
1384 DECL_STATIC_CHAIN (decl
) = 1;
1387 c_pop_function_context ();
1388 add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl
), DECL_EXPR
, decl
));
1399 /* Parse an asm-definition (asm() outside a function body). This is a
1407 c_parser_asm_definition (c_parser
*parser
)
1409 tree asm_str
= c_parser_simple_asm_expr (parser
);
1411 cgraph_add_asm_node (asm_str
);
1412 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
1415 /* Parse a static assertion (C1X N1425 6.7.10).
1417 static_assert-declaration:
1418 static_assert-declaration-no-semi ;
1422 c_parser_static_assert_declaration (c_parser
*parser
)
1424 c_parser_static_assert_declaration_no_semi (parser
);
1426 || !c_parser_require (parser
, CPP_SEMICOLON
, "expected %<;%>"))
1427 c_parser_skip_to_end_of_block_or_statement (parser
);
1430 /* Parse a static assertion (C1X N1425 6.7.10), without the trailing
1433 static_assert-declaration-no-semi:
1434 _Static_assert ( constant-expression , string-literal )
1438 c_parser_static_assert_declaration_no_semi (c_parser
*parser
)
1440 location_t assert_loc
, value_loc
;
1444 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_STATIC_ASSERT
));
1445 assert_loc
= c_parser_peek_token (parser
)->location
;
1449 pedwarn (assert_loc
, OPT_pedantic
,
1450 "ISO C99 does not support %<_Static_assert%>");
1452 pedwarn (assert_loc
, OPT_pedantic
,
1453 "ISO C90 does not support %<_Static_assert%>");
1455 c_parser_consume_token (parser
);
1456 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1458 value_loc
= c_parser_peek_token (parser
)->location
;
1459 value
= c_parser_expr_no_commas (parser
, NULL
).value
;
1460 parser
->lex_untranslated_string
= true;
1461 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
1463 parser
->lex_untranslated_string
= false;
1466 switch (c_parser_peek_token (parser
)->type
)
1472 case CPP_UTF8STRING
:
1473 string
= c_parser_peek_token (parser
)->value
;
1474 c_parser_consume_token (parser
);
1475 parser
->lex_untranslated_string
= false;
1478 c_parser_error (parser
, "expected string literal");
1479 parser
->lex_untranslated_string
= false;
1482 c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
1484 if (!INTEGRAL_TYPE_P (TREE_TYPE (value
)))
1486 error_at (value_loc
, "expression in static assertion is not an integer");
1489 if (TREE_CODE (value
) != INTEGER_CST
)
1491 value
= c_fully_fold (value
, false, NULL
);
1492 if (TREE_CODE (value
) == INTEGER_CST
)
1493 pedwarn (value_loc
, OPT_pedantic
, "expression in static assertion "
1494 "is not an integer constant expression");
1496 if (TREE_CODE (value
) != INTEGER_CST
)
1498 error_at (value_loc
, "expression in static assertion is not constant");
1501 constant_expression_warning (value
);
1502 if (integer_zerop (value
))
1503 error_at (assert_loc
, "static assertion failed: %E", string
);
1506 /* Parse some declaration specifiers (possibly none) (C90 6.5, C99
1507 6.7), adding them to SPECS (which may already include some).
1508 Storage class specifiers are accepted iff SCSPEC_OK; type
1509 specifiers are accepted iff TYPESPEC_OK; attributes are accepted at
1510 the start iff START_ATTR_OK.
1512 declaration-specifiers:
1513 storage-class-specifier declaration-specifiers[opt]
1514 type-specifier declaration-specifiers[opt]
1515 type-qualifier declaration-specifiers[opt]
1516 function-specifier declaration-specifiers[opt]
1518 Function specifiers (inline) are from C99, and are currently
1519 handled as storage class specifiers, as is __thread.
1521 C90 6.5.1, C99 6.7.1:
1522 storage-class-specifier:
1533 C90 6.5.2, C99 6.7.2:
1546 [_Imaginary removed in C99 TC2]
1547 struct-or-union-specifier
1551 (_Bool and _Complex are new in C99.)
1553 C90 6.5.3, C99 6.7.3:
1559 address-space-qualifier
1561 (restrict is new in C99.)
1565 declaration-specifiers:
1566 attributes declaration-specifiers[opt]
1572 identifier recognized by the target
1574 storage-class-specifier:
1587 (_Fract, _Accum, and _Sat are new from ISO/IEC DTR 18037:
1588 http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1169.pdf)
1593 class-name objc-protocol-refs[opt]
1594 typedef-name objc-protocol-refs
1599 c_parser_declspecs (c_parser
*parser
, struct c_declspecs
*specs
,
1600 bool scspec_ok
, bool typespec_ok
, bool start_attr_ok
)
1602 bool attrs_ok
= start_attr_ok
;
1603 bool seen_type
= specs
->type_seen_p
;
1604 while (c_parser_next_token_is (parser
, CPP_NAME
)
1605 || c_parser_next_token_is (parser
, CPP_KEYWORD
)
1606 || (c_dialect_objc () && c_parser_next_token_is (parser
, CPP_LESS
)))
1608 struct c_typespec t
;
1610 location_t loc
= c_parser_peek_token (parser
)->location
;
1611 if (c_parser_next_token_is (parser
, CPP_NAME
))
1613 tree value
= c_parser_peek_token (parser
)->value
;
1614 c_id_kind kind
= c_parser_peek_token (parser
)->id_kind
;
1616 if (kind
== C_ID_ADDRSPACE
)
1619 = c_parser_peek_token (parser
)->keyword
- RID_FIRST_ADDR_SPACE
;
1620 declspecs_add_addrspace (specs
, as
);
1621 c_parser_consume_token (parser
);
1626 /* This finishes the specifiers unless a type name is OK, it
1627 is declared as a type name and a type name hasn't yet
1629 if (!typespec_ok
|| seen_type
1630 || (kind
!= C_ID_TYPENAME
&& kind
!= C_ID_CLASSNAME
))
1632 c_parser_consume_token (parser
);
1635 if (kind
== C_ID_TYPENAME
1636 && (!c_dialect_objc ()
1637 || c_parser_next_token_is_not (parser
, CPP_LESS
)))
1639 t
.kind
= ctsk_typedef
;
1640 /* For a typedef name, record the meaning, not the name.
1641 In case of 'foo foo, bar;'. */
1642 t
.spec
= lookup_name (value
);
1644 t
.expr_const_operands
= true;
1648 tree proto
= NULL_TREE
;
1649 gcc_assert (c_dialect_objc ());
1651 if (c_parser_next_token_is (parser
, CPP_LESS
))
1652 proto
= c_parser_objc_protocol_refs (parser
);
1653 t
.spec
= objc_get_protocol_qualified_type (value
, proto
);
1655 t
.expr_const_operands
= true;
1657 declspecs_add_type (loc
, specs
, t
);
1660 if (c_parser_next_token_is (parser
, CPP_LESS
))
1662 /* Make "<SomeProtocol>" equivalent to "id <SomeProtocol>" -
1663 nisse@lysator.liu.se. */
1665 gcc_assert (c_dialect_objc ());
1666 if (!typespec_ok
|| seen_type
)
1668 proto
= c_parser_objc_protocol_refs (parser
);
1670 t
.spec
= objc_get_protocol_qualified_type (NULL_TREE
, proto
);
1672 t
.expr_const_operands
= true;
1673 declspecs_add_type (loc
, specs
, t
);
1676 gcc_assert (c_parser_next_token_is (parser
, CPP_KEYWORD
));
1677 switch (c_parser_peek_token (parser
)->keyword
)
1689 /* TODO: Distinguish between function specifiers (inline)
1690 and storage class specifiers, either here or in
1691 declspecs_add_scspec. */
1692 declspecs_add_scspec (specs
, c_parser_peek_token (parser
)->value
);
1693 c_parser_consume_token (parser
);
1717 if (c_dialect_objc ())
1718 parser
->objc_need_raw_identifier
= true;
1719 t
.kind
= ctsk_resword
;
1720 t
.spec
= c_parser_peek_token (parser
)->value
;
1722 t
.expr_const_operands
= true;
1723 declspecs_add_type (loc
, specs
, t
);
1724 c_parser_consume_token (parser
);
1731 t
= c_parser_enum_specifier (parser
);
1732 declspecs_add_type (loc
, specs
, t
);
1740 t
= c_parser_struct_or_union_specifier (parser
);
1741 invoke_plugin_callbacks (PLUGIN_FINISH_TYPE
, t
.spec
);
1742 declspecs_add_type (loc
, specs
, t
);
1745 /* ??? The old parser rejected typeof after other type
1746 specifiers, but is a syntax error the best way of
1748 if (!typespec_ok
|| seen_type
)
1752 t
= c_parser_typeof_specifier (parser
);
1753 declspecs_add_type (loc
, specs
, t
);
1759 declspecs_add_qual (specs
, c_parser_peek_token (parser
)->value
);
1760 c_parser_consume_token (parser
);
1765 attrs
= c_parser_attributes (parser
);
1766 declspecs_add_attrs (specs
, attrs
);
1775 /* Parse an enum specifier (C90 6.5.2.2, C99 6.7.2.2).
1778 enum attributes[opt] identifier[opt] { enumerator-list } attributes[opt]
1779 enum attributes[opt] identifier[opt] { enumerator-list , } attributes[opt]
1780 enum attributes[opt] identifier
1782 The form with trailing comma is new in C99. The forms with
1783 attributes are GNU extensions. In GNU C, we accept any expression
1784 without commas in the syntax (assignment expressions, not just
1785 conditional expressions); assignment expressions will be diagnosed
1790 enumerator-list , enumerator
1793 enumeration-constant
1794 enumeration-constant = constant-expression
1797 static struct c_typespec
1798 c_parser_enum_specifier (c_parser
*parser
)
1800 struct c_typespec ret
;
1802 tree ident
= NULL_TREE
;
1803 location_t enum_loc
;
1804 location_t ident_loc
= UNKNOWN_LOCATION
; /* Quiet warning. */
1805 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_ENUM
));
1806 enum_loc
= c_parser_peek_token (parser
)->location
;
1807 c_parser_consume_token (parser
);
1808 attrs
= c_parser_attributes (parser
);
1809 enum_loc
= c_parser_peek_token (parser
)->location
;
1810 /* Set the location in case we create a decl now. */
1811 c_parser_set_source_position_from_token (c_parser_peek_token (parser
));
1812 if (c_parser_next_token_is (parser
, CPP_NAME
))
1814 ident
= c_parser_peek_token (parser
)->value
;
1815 ident_loc
= c_parser_peek_token (parser
)->location
;
1816 enum_loc
= ident_loc
;
1817 c_parser_consume_token (parser
);
1819 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
1821 /* Parse an enum definition. */
1822 struct c_enum_contents the_enum
;
1823 tree type
= start_enum (enum_loc
, &the_enum
, ident
);
1825 /* We chain the enumerators in reverse order, then put them in
1826 forward order at the end. */
1827 tree values
= NULL_TREE
;
1828 c_parser_consume_token (parser
);
1836 location_t comma_loc
= UNKNOWN_LOCATION
; /* Quiet warning. */
1837 location_t value_loc
;
1838 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
1840 c_parser_error (parser
, "expected identifier");
1841 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
, NULL
);
1842 values
= error_mark_node
;
1845 token
= c_parser_peek_token (parser
);
1846 enum_id
= token
->value
;
1847 /* Set the location in case we create a decl now. */
1848 c_parser_set_source_position_from_token (token
);
1849 value_loc
= token
->location
;
1850 c_parser_consume_token (parser
);
1851 if (c_parser_next_token_is (parser
, CPP_EQ
))
1853 c_parser_consume_token (parser
);
1854 value_loc
= c_parser_peek_token (parser
)->location
;
1855 enum_value
= c_parser_expr_no_commas (parser
, NULL
).value
;
1858 enum_value
= NULL_TREE
;
1859 enum_decl
= build_enumerator (value_loc
,
1860 &the_enum
, enum_id
, enum_value
);
1861 TREE_CHAIN (enum_decl
) = values
;
1864 if (c_parser_next_token_is (parser
, CPP_COMMA
))
1866 comma_loc
= c_parser_peek_token (parser
)->location
;
1868 c_parser_consume_token (parser
);
1870 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
1872 if (seen_comma
&& !flag_isoc99
)
1873 pedwarn (comma_loc
, OPT_pedantic
, "comma at end of enumerator list");
1874 c_parser_consume_token (parser
);
1879 c_parser_error (parser
, "expected %<,%> or %<}%>");
1880 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
, NULL
);
1881 values
= error_mark_node
;
1885 postfix_attrs
= c_parser_attributes (parser
);
1886 ret
.spec
= finish_enum (type
, nreverse (values
),
1887 chainon (attrs
, postfix_attrs
));
1888 ret
.kind
= ctsk_tagdef
;
1889 ret
.expr
= NULL_TREE
;
1890 ret
.expr_const_operands
= true;
1895 c_parser_error (parser
, "expected %<{%>");
1896 ret
.spec
= error_mark_node
;
1897 ret
.kind
= ctsk_tagref
;
1898 ret
.expr
= NULL_TREE
;
1899 ret
.expr_const_operands
= true;
1902 ret
= parser_xref_tag (ident_loc
, ENUMERAL_TYPE
, ident
);
1903 /* In ISO C, enumerated types can be referred to only if already
1905 if (pedantic
&& !COMPLETE_TYPE_P (ret
.spec
))
1908 pedwarn (enum_loc
, OPT_pedantic
,
1909 "ISO C forbids forward references to %<enum%> types");
1914 /* Parse a struct or union specifier (C90 6.5.2.1, C99 6.7.2.1).
1916 struct-or-union-specifier:
1917 struct-or-union attributes[opt] identifier[opt]
1918 { struct-contents } attributes[opt]
1919 struct-or-union attributes[opt] identifier
1922 struct-declaration-list
1924 struct-declaration-list:
1925 struct-declaration ;
1926 struct-declaration-list struct-declaration ;
1933 struct-declaration-list struct-declaration
1935 struct-declaration-list:
1936 struct-declaration-list ;
1939 (Note that in the syntax here, unlike that in ISO C, the semicolons
1940 are included here rather than in struct-declaration, in order to
1941 describe the syntax with extra semicolons and missing semicolon at
1946 struct-declaration-list:
1947 @defs ( class-name )
1949 (Note this does not include a trailing semicolon, but can be
1950 followed by further declarations, and gets a pedwarn-if-pedantic
1951 when followed by a semicolon.) */
1953 static struct c_typespec
1954 c_parser_struct_or_union_specifier (c_parser
*parser
)
1956 struct c_typespec ret
;
1958 tree ident
= NULL_TREE
;
1959 location_t struct_loc
;
1960 location_t ident_loc
= UNKNOWN_LOCATION
;
1961 enum tree_code code
;
1962 switch (c_parser_peek_token (parser
)->keyword
)
1973 struct_loc
= c_parser_peek_token (parser
)->location
;
1974 c_parser_consume_token (parser
);
1975 attrs
= c_parser_attributes (parser
);
1977 /* Set the location in case we create a decl now. */
1978 c_parser_set_source_position_from_token (c_parser_peek_token (parser
));
1980 if (c_parser_next_token_is (parser
, CPP_NAME
))
1982 ident
= c_parser_peek_token (parser
)->value
;
1983 ident_loc
= c_parser_peek_token (parser
)->location
;
1984 struct_loc
= ident_loc
;
1985 c_parser_consume_token (parser
);
1987 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
1989 /* Parse a struct or union definition. Start the scope of the
1990 tag before parsing components. */
1991 struct c_struct_parse_info
*struct_info
;
1992 tree type
= start_struct (struct_loc
, code
, ident
, &struct_info
);
1994 /* We chain the components in reverse order, then put them in
1995 forward order at the end. Each struct-declaration may
1996 declare multiple components (comma-separated), so we must use
1997 chainon to join them, although when parsing each
1998 struct-declaration we can use TREE_CHAIN directly.
2000 The theory behind all this is that there will be more
2001 semicolon separated fields than comma separated fields, and
2002 so we'll be minimizing the number of node traversals required
2004 tree contents
= NULL_TREE
;
2005 c_parser_consume_token (parser
);
2006 /* Handle the Objective-C @defs construct,
2007 e.g. foo(sizeof(struct{ @defs(ClassName) }));. */
2008 if (c_parser_next_token_is_keyword (parser
, RID_AT_DEFS
))
2011 gcc_assert (c_dialect_objc ());
2012 c_parser_consume_token (parser
);
2013 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
2015 if (c_parser_next_token_is (parser
, CPP_NAME
)
2016 && c_parser_peek_token (parser
)->id_kind
== C_ID_CLASSNAME
)
2018 name
= c_parser_peek_token (parser
)->value
;
2019 c_parser_consume_token (parser
);
2023 c_parser_error (parser
, "expected class name");
2024 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
2027 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
2029 contents
= nreverse (objc_get_class_ivars (name
));
2032 /* Parse the struct-declarations and semicolons. Problems with
2033 semicolons are diagnosed here; empty structures are diagnosed
2038 /* Parse any stray semicolon. */
2039 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
2041 pedwarn (c_parser_peek_token (parser
)->location
, OPT_pedantic
,
2042 "extra semicolon in struct or union specified");
2043 c_parser_consume_token (parser
);
2046 /* Stop if at the end of the struct or union contents. */
2047 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
2049 c_parser_consume_token (parser
);
2052 /* Accept #pragmas at struct scope. */
2053 if (c_parser_next_token_is (parser
, CPP_PRAGMA
))
2055 c_parser_pragma (parser
, pragma_external
);
2058 /* Parse some comma-separated declarations, but not the
2059 trailing semicolon if any. */
2060 decls
= c_parser_struct_declaration (parser
);
2061 contents
= chainon (decls
, contents
);
2062 /* If no semicolon follows, either we have a parse error or
2063 are at the end of the struct or union and should
2065 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
2066 c_parser_consume_token (parser
);
2069 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
2070 pedwarn (c_parser_peek_token (parser
)->location
, 0,
2071 "no semicolon at end of struct or union");
2074 c_parser_error (parser
, "expected %<;%>");
2075 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
, NULL
);
2080 postfix_attrs
= c_parser_attributes (parser
);
2081 ret
.spec
= finish_struct (struct_loc
, type
, nreverse (contents
),
2082 chainon (attrs
, postfix_attrs
), struct_info
);
2083 ret
.kind
= ctsk_tagdef
;
2084 ret
.expr
= NULL_TREE
;
2085 ret
.expr_const_operands
= true;
2090 c_parser_error (parser
, "expected %<{%>");
2091 ret
.spec
= error_mark_node
;
2092 ret
.kind
= ctsk_tagref
;
2093 ret
.expr
= NULL_TREE
;
2094 ret
.expr_const_operands
= true;
2097 ret
= parser_xref_tag (ident_loc
, code
, ident
);
2101 /* Parse a struct-declaration (C90 6.5.2.1, C99 6.7.2.1), *without*
2102 the trailing semicolon.
2105 specifier-qualifier-list struct-declarator-list
2106 static_assert-declaration-no-semi
2108 specifier-qualifier-list:
2109 type-specifier specifier-qualifier-list[opt]
2110 type-qualifier specifier-qualifier-list[opt]
2111 attributes specifier-qualifier-list[opt]
2113 struct-declarator-list:
2115 struct-declarator-list , attributes[opt] struct-declarator
2118 declarator attributes[opt]
2119 declarator[opt] : constant-expression attributes[opt]
2124 __extension__ struct-declaration
2125 specifier-qualifier-list
2127 Unlike the ISO C syntax, semicolons are handled elsewhere. The use
2128 of attributes where shown is a GNU extension. In GNU C, we accept
2129 any expression without commas in the syntax (assignment
2130 expressions, not just conditional expressions); assignment
2131 expressions will be diagnosed as non-constant. */
2134 c_parser_struct_declaration (c_parser
*parser
)
2136 struct c_declspecs
*specs
;
2138 tree all_prefix_attrs
;
2140 location_t decl_loc
;
2141 if (c_parser_next_token_is_keyword (parser
, RID_EXTENSION
))
2145 ext
= disable_extension_diagnostics ();
2146 c_parser_consume_token (parser
);
2147 decl
= c_parser_struct_declaration (parser
);
2148 restore_extension_diagnostics (ext
);
2151 if (c_parser_next_token_is_keyword (parser
, RID_STATIC_ASSERT
))
2153 c_parser_static_assert_declaration_no_semi (parser
);
2156 specs
= build_null_declspecs ();
2157 decl_loc
= c_parser_peek_token (parser
)->location
;
2158 c_parser_declspecs (parser
, specs
, false, true, true);
2161 if (!specs
->declspecs_seen_p
)
2163 c_parser_error (parser
, "expected specifier-qualifier-list");
2166 finish_declspecs (specs
);
2167 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
2170 if (!specs
->type_seen_p
)
2172 pedwarn (decl_loc
, OPT_pedantic
,
2173 "ISO C forbids member declarations with no members");
2174 shadow_tag_warned (specs
, pedantic
);
2179 /* Support for unnamed structs or unions as members of
2180 structs or unions (which is [a] useful and [b] supports
2184 ret
= grokfield (c_parser_peek_token (parser
)->location
,
2185 build_id_declarator (NULL_TREE
), specs
,
2188 decl_attributes (&ret
, attrs
, 0);
2192 pending_xref_error ();
2193 prefix_attrs
= specs
->attrs
;
2194 all_prefix_attrs
= prefix_attrs
;
2195 specs
->attrs
= NULL_TREE
;
2199 /* Declaring one or more declarators or un-named bit-fields. */
2200 struct c_declarator
*declarator
;
2202 if (c_parser_next_token_is (parser
, CPP_COLON
))
2203 declarator
= build_id_declarator (NULL_TREE
);
2205 declarator
= c_parser_declarator (parser
, specs
->type_seen_p
,
2206 C_DTR_NORMAL
, &dummy
);
2207 if (declarator
== NULL
)
2209 c_parser_skip_to_end_of_block_or_statement (parser
);
2212 if (c_parser_next_token_is (parser
, CPP_COLON
)
2213 || c_parser_next_token_is (parser
, CPP_COMMA
)
2214 || c_parser_next_token_is (parser
, CPP_SEMICOLON
)
2215 || c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
)
2216 || c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
2218 tree postfix_attrs
= NULL_TREE
;
2219 tree width
= NULL_TREE
;
2221 if (c_parser_next_token_is (parser
, CPP_COLON
))
2223 c_parser_consume_token (parser
);
2224 width
= c_parser_expr_no_commas (parser
, NULL
).value
;
2226 if (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
2227 postfix_attrs
= c_parser_attributes (parser
);
2228 d
= grokfield (c_parser_peek_token (parser
)->location
,
2229 declarator
, specs
, width
, &all_prefix_attrs
);
2230 decl_attributes (&d
, chainon (postfix_attrs
,
2231 all_prefix_attrs
), 0);
2232 TREE_CHAIN (d
) = decls
;
2234 if (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
2235 all_prefix_attrs
= chainon (c_parser_attributes (parser
),
2238 all_prefix_attrs
= prefix_attrs
;
2239 if (c_parser_next_token_is (parser
, CPP_COMMA
))
2240 c_parser_consume_token (parser
);
2241 else if (c_parser_next_token_is (parser
, CPP_SEMICOLON
)
2242 || c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
2244 /* Semicolon consumed in caller. */
2249 c_parser_error (parser
, "expected %<,%>, %<;%> or %<}%>");
2255 c_parser_error (parser
,
2256 "expected %<:%>, %<,%>, %<;%>, %<}%> or "
2257 "%<__attribute__%>");
2264 /* Parse a typeof specifier (a GNU extension).
2267 typeof ( expression )
2268 typeof ( type-name )
2271 static struct c_typespec
2272 c_parser_typeof_specifier (c_parser
*parser
)
2274 struct c_typespec ret
;
2275 ret
.kind
= ctsk_typeof
;
2276 ret
.spec
= error_mark_node
;
2277 ret
.expr
= NULL_TREE
;
2278 ret
.expr_const_operands
= true;
2279 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_TYPEOF
));
2280 c_parser_consume_token (parser
);
2281 c_inhibit_evaluation_warnings
++;
2283 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
2285 c_inhibit_evaluation_warnings
--;
2289 if (c_parser_next_token_starts_typename (parser
))
2291 struct c_type_name
*type
= c_parser_type_name (parser
);
2292 c_inhibit_evaluation_warnings
--;
2296 ret
.spec
= groktypename (type
, &ret
.expr
, &ret
.expr_const_operands
);
2297 pop_maybe_used (variably_modified_type_p (ret
.spec
, NULL_TREE
));
2303 location_t here
= c_parser_peek_token (parser
)->location
;
2304 struct c_expr expr
= c_parser_expression (parser
);
2305 c_inhibit_evaluation_warnings
--;
2307 if (TREE_CODE (expr
.value
) == COMPONENT_REF
2308 && DECL_C_BIT_FIELD (TREE_OPERAND (expr
.value
, 1)))
2309 error_at (here
, "%<typeof%> applied to a bit-field");
2310 mark_exp_read (expr
.value
);
2311 ret
.spec
= TREE_TYPE (expr
.value
);
2312 was_vm
= variably_modified_type_p (ret
.spec
, NULL_TREE
);
2313 /* This is returned with the type so that when the type is
2314 evaluated, this can be evaluated. */
2316 ret
.expr
= c_fully_fold (expr
.value
, false, &ret
.expr_const_operands
);
2317 pop_maybe_used (was_vm
);
2319 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
2323 /* Parse a declarator, possibly an abstract declarator (C90 6.5.4,
2324 6.5.5, C99 6.7.5, 6.7.6). If TYPE_SEEN_P then a typedef name may
2325 be redeclared; otherwise it may not. KIND indicates which kind of
2326 declarator is wanted. Returns a valid declarator except in the
2327 case of a syntax error in which case NULL is returned. *SEEN_ID is
2328 set to true if an identifier being declared is seen; this is used
2329 to diagnose bad forms of abstract array declarators and to
2330 determine whether an identifier list is syntactically permitted.
2333 pointer[opt] direct-declarator
2337 ( attributes[opt] declarator )
2338 direct-declarator array-declarator
2339 direct-declarator ( parameter-type-list )
2340 direct-declarator ( identifier-list[opt] )
2343 * type-qualifier-list[opt]
2344 * type-qualifier-list[opt] pointer
2346 type-qualifier-list:
2349 type-qualifier-list type-qualifier
2350 type-qualifier-list attributes
2352 parameter-type-list:
2354 parameter-list , ...
2357 parameter-declaration
2358 parameter-list , parameter-declaration
2360 parameter-declaration:
2361 declaration-specifiers declarator attributes[opt]
2362 declaration-specifiers abstract-declarator[opt] attributes[opt]
2366 identifier-list , identifier
2368 abstract-declarator:
2370 pointer[opt] direct-abstract-declarator
2372 direct-abstract-declarator:
2373 ( attributes[opt] abstract-declarator )
2374 direct-abstract-declarator[opt] array-declarator
2375 direct-abstract-declarator[opt] ( parameter-type-list[opt] )
2380 direct-declarator ( parameter-forward-declarations
2381 parameter-type-list[opt] )
2383 direct-abstract-declarator:
2384 direct-abstract-declarator[opt] ( parameter-forward-declarations
2385 parameter-type-list[opt] )
2387 parameter-forward-declarations:
2389 parameter-forward-declarations parameter-list ;
2391 The uses of attributes shown above are GNU extensions.
2393 Some forms of array declarator are not included in C99 in the
2394 syntax for abstract declarators; these are disallowed elsewhere.
2395 This may be a defect (DR#289).
2397 This function also accepts an omitted abstract declarator as being
2398 an abstract declarator, although not part of the formal syntax. */
2400 static struct c_declarator
*
2401 c_parser_declarator (c_parser
*parser
, bool type_seen_p
, c_dtr_syn kind
,
2404 /* Parse any initial pointer part. */
2405 if (c_parser_next_token_is (parser
, CPP_MULT
))
2407 struct c_declspecs
*quals_attrs
= build_null_declspecs ();
2408 struct c_declarator
*inner
;
2409 c_parser_consume_token (parser
);
2410 c_parser_declspecs (parser
, quals_attrs
, false, false, true);
2411 inner
= c_parser_declarator (parser
, type_seen_p
, kind
, seen_id
);
2415 return make_pointer_declarator (quals_attrs
, inner
);
2417 /* Now we have a direct declarator, direct abstract declarator or
2418 nothing (which counts as a direct abstract declarator here). */
2419 return c_parser_direct_declarator (parser
, type_seen_p
, kind
, seen_id
);
2422 /* Parse a direct declarator or direct abstract declarator; arguments
2423 as c_parser_declarator. */
2425 static struct c_declarator
*
2426 c_parser_direct_declarator (c_parser
*parser
, bool type_seen_p
, c_dtr_syn kind
,
2429 /* The direct declarator must start with an identifier (possibly
2430 omitted) or a parenthesized declarator (possibly abstract). In
2431 an ordinary declarator, initial parentheses must start a
2432 parenthesized declarator. In an abstract declarator or parameter
2433 declarator, they could start a parenthesized declarator or a
2434 parameter list. To tell which, the open parenthesis and any
2435 following attributes must be read. If a declaration specifier
2436 follows, then it is a parameter list; if the specifier is a
2437 typedef name, there might be an ambiguity about redeclaring it,
2438 which is resolved in the direction of treating it as a typedef
2439 name. If a close parenthesis follows, it is also an empty
2440 parameter list, as the syntax does not permit empty abstract
2441 declarators. Otherwise, it is a parenthesized declarator (in
2442 which case the analysis may be repeated inside it, recursively).
2444 ??? There is an ambiguity in a parameter declaration "int
2445 (__attribute__((foo)) x)", where x is not a typedef name: it
2446 could be an abstract declarator for a function, or declare x with
2447 parentheses. The proper resolution of this ambiguity needs
2448 documenting. At present we follow an accident of the old
2449 parser's implementation, whereby the first parameter must have
2450 some declaration specifiers other than just attributes. Thus as
2451 a parameter declaration it is treated as a parenthesized
2452 parameter named x, and as an abstract declarator it is
2455 ??? Also following the old parser, attributes inside an empty
2456 parameter list are ignored, making it a list not yielding a
2457 prototype, rather than giving an error or making it have one
2458 parameter with implicit type int.
2460 ??? Also following the old parser, typedef names may be
2461 redeclared in declarators, but not Objective-C class names. */
2463 if (kind
!= C_DTR_ABSTRACT
2464 && c_parser_next_token_is (parser
, CPP_NAME
)
2466 && c_parser_peek_token (parser
)->id_kind
== C_ID_TYPENAME
)
2467 || c_parser_peek_token (parser
)->id_kind
== C_ID_ID
))
2469 struct c_declarator
*inner
2470 = build_id_declarator (c_parser_peek_token (parser
)->value
);
2472 inner
->id_loc
= c_parser_peek_token (parser
)->location
;
2473 c_parser_consume_token (parser
);
2474 return c_parser_direct_declarator_inner (parser
, *seen_id
, inner
);
2477 if (kind
!= C_DTR_NORMAL
2478 && c_parser_next_token_is (parser
, CPP_OPEN_SQUARE
))
2480 struct c_declarator
*inner
= build_id_declarator (NULL_TREE
);
2481 return c_parser_direct_declarator_inner (parser
, *seen_id
, inner
);
2484 /* Either we are at the end of an abstract declarator, or we have
2487 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
2490 struct c_declarator
*inner
;
2491 c_parser_consume_token (parser
);
2492 attrs
= c_parser_attributes (parser
);
2493 if (kind
!= C_DTR_NORMAL
2494 && (c_parser_next_token_starts_declspecs (parser
)
2495 || c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
)))
2497 struct c_arg_info
*args
2498 = c_parser_parms_declarator (parser
, kind
== C_DTR_NORMAL
,
2505 = build_function_declarator (args
,
2506 build_id_declarator (NULL_TREE
));
2507 return c_parser_direct_declarator_inner (parser
, *seen_id
,
2511 /* A parenthesized declarator. */
2512 inner
= c_parser_declarator (parser
, type_seen_p
, kind
, seen_id
);
2513 if (inner
!= NULL
&& attrs
!= NULL
)
2514 inner
= build_attrs_declarator (attrs
, inner
);
2515 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2517 c_parser_consume_token (parser
);
2521 return c_parser_direct_declarator_inner (parser
, *seen_id
, inner
);
2525 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
2532 if (kind
== C_DTR_NORMAL
)
2534 c_parser_error (parser
, "expected identifier or %<(%>");
2538 return build_id_declarator (NULL_TREE
);
2542 /* Parse part of a direct declarator or direct abstract declarator,
2543 given that some (in INNER) has already been parsed; ID_PRESENT is
2544 true if an identifier is present, false for an abstract
2547 static struct c_declarator
*
2548 c_parser_direct_declarator_inner (c_parser
*parser
, bool id_present
,
2549 struct c_declarator
*inner
)
2551 /* Parse a sequence of array declarators and parameter lists. */
2552 if (c_parser_next_token_is (parser
, CPP_OPEN_SQUARE
))
2554 location_t brace_loc
= c_parser_peek_token (parser
)->location
;
2555 struct c_declarator
*declarator
;
2556 struct c_declspecs
*quals_attrs
= build_null_declspecs ();
2560 c_parser_consume_token (parser
);
2561 c_parser_declspecs (parser
, quals_attrs
, false, false, true);
2562 static_seen
= c_parser_next_token_is_keyword (parser
, RID_STATIC
);
2564 c_parser_consume_token (parser
);
2565 if (static_seen
&& !quals_attrs
->declspecs_seen_p
)
2566 c_parser_declspecs (parser
, quals_attrs
, false, false, true);
2567 if (!quals_attrs
->declspecs_seen_p
)
2569 /* If "static" is present, there must be an array dimension.
2570 Otherwise, there may be a dimension, "*", or no
2575 dimen
= c_parser_expr_no_commas (parser
, NULL
).value
;
2579 if (c_parser_next_token_is (parser
, CPP_CLOSE_SQUARE
))
2584 else if (c_parser_next_token_is (parser
, CPP_MULT
))
2586 if (c_parser_peek_2nd_token (parser
)->type
== CPP_CLOSE_SQUARE
)
2590 c_parser_consume_token (parser
);
2595 dimen
= c_parser_expr_no_commas (parser
, NULL
).value
;
2601 dimen
= c_parser_expr_no_commas (parser
, NULL
).value
;
2604 if (c_parser_next_token_is (parser
, CPP_CLOSE_SQUARE
))
2605 c_parser_consume_token (parser
);
2608 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
2613 mark_exp_read (dimen
);
2614 declarator
= build_array_declarator (brace_loc
, dimen
, quals_attrs
,
2615 static_seen
, star_seen
);
2616 if (declarator
== NULL
)
2618 inner
= set_array_declarator_inner (declarator
, inner
);
2619 return c_parser_direct_declarator_inner (parser
, id_present
, inner
);
2621 else if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
2624 struct c_arg_info
*args
;
2625 c_parser_consume_token (parser
);
2626 attrs
= c_parser_attributes (parser
);
2627 args
= c_parser_parms_declarator (parser
, id_present
, attrs
);
2632 inner
= build_function_declarator (args
, inner
);
2633 return c_parser_direct_declarator_inner (parser
, id_present
, inner
);
2639 /* Parse a parameter list or identifier list, including the closing
2640 parenthesis but not the opening one. ATTRS are the attributes at
2641 the start of the list. ID_LIST_OK is true if an identifier list is
2642 acceptable; such a list must not have attributes at the start. */
2644 static struct c_arg_info
*
2645 c_parser_parms_declarator (c_parser
*parser
, bool id_list_ok
, tree attrs
)
2648 declare_parm_level ();
2649 /* If the list starts with an identifier, it is an identifier list.
2650 Otherwise, it is either a prototype list or an empty list. */
2653 && c_parser_next_token_is (parser
, CPP_NAME
)
2654 && c_parser_peek_token (parser
)->id_kind
== C_ID_ID
)
2656 tree list
= NULL_TREE
, *nextp
= &list
;
2657 while (c_parser_next_token_is (parser
, CPP_NAME
)
2658 && c_parser_peek_token (parser
)->id_kind
== C_ID_ID
)
2660 *nextp
= build_tree_list (NULL_TREE
,
2661 c_parser_peek_token (parser
)->value
);
2662 nextp
= & TREE_CHAIN (*nextp
);
2663 c_parser_consume_token (parser
);
2664 if (c_parser_next_token_is_not (parser
, CPP_COMMA
))
2666 c_parser_consume_token (parser
);
2667 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2669 c_parser_error (parser
, "expected identifier");
2673 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2675 struct c_arg_info
*ret
= XOBNEW (&parser_obstack
, struct c_arg_info
);
2680 ret
->pending_sizes
= 0;
2681 ret
->had_vla_unspec
= 0;
2682 c_parser_consume_token (parser
);
2688 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
2696 struct c_arg_info
*ret
= c_parser_parms_list_declarator (parser
, attrs
);
2702 /* Parse a parameter list (possibly empty), including the closing
2703 parenthesis but not the opening one. ATTRS are the attributes at
2704 the start of the list. */
2706 static struct c_arg_info
*
2707 c_parser_parms_list_declarator (c_parser
*parser
, tree attrs
)
2709 bool bad_parm
= false;
2710 /* ??? Following the old parser, forward parameter declarations may
2711 use abstract declarators, and if no real parameter declarations
2712 follow the forward declarations then this is not diagnosed. Also
2713 note as above that attributes are ignored as the only contents of
2714 the parentheses, or as the only contents after forward
2716 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2718 struct c_arg_info
*ret
= XOBNEW (&parser_obstack
, struct c_arg_info
);
2723 ret
->pending_sizes
= 0;
2724 ret
->had_vla_unspec
= 0;
2725 c_parser_consume_token (parser
);
2728 if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
))
2730 struct c_arg_info
*ret
= XOBNEW (&parser_obstack
, struct c_arg_info
);
2734 ret
->pending_sizes
= 0;
2735 ret
->had_vla_unspec
= 0;
2736 /* Suppress -Wold-style-definition for this case. */
2737 ret
->types
= error_mark_node
;
2738 error_at (c_parser_peek_token (parser
)->location
,
2739 "ISO C requires a named argument before %<...%>");
2740 c_parser_consume_token (parser
);
2741 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2743 c_parser_consume_token (parser
);
2748 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
2753 /* Nonempty list of parameters, either terminated with semicolon
2754 (forward declarations; recurse) or with close parenthesis (normal
2755 function) or with ", ... )" (variadic function). */
2758 /* Parse a parameter. */
2759 struct c_parm
*parm
= c_parser_parameter_declaration (parser
, attrs
);
2764 push_parm_decl (parm
);
2765 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
2768 c_parser_consume_token (parser
);
2769 mark_forward_parm_decls ();
2770 new_attrs
= c_parser_attributes (parser
);
2771 return c_parser_parms_list_declarator (parser
, new_attrs
);
2773 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2775 c_parser_consume_token (parser
);
2778 get_pending_sizes ();
2782 return get_parm_info (false);
2784 if (!c_parser_require (parser
, CPP_COMMA
,
2785 "expected %<;%>, %<,%> or %<)%>"))
2787 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
2788 get_pending_sizes ();
2791 if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
))
2793 c_parser_consume_token (parser
);
2794 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2796 c_parser_consume_token (parser
);
2799 get_pending_sizes ();
2803 return get_parm_info (true);
2807 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
2809 get_pending_sizes ();
2816 /* Parse a parameter declaration. ATTRS are the attributes at the
2817 start of the declaration if it is the first parameter. */
2819 static struct c_parm
*
2820 c_parser_parameter_declaration (c_parser
*parser
, tree attrs
)
2822 struct c_declspecs
*specs
;
2823 struct c_declarator
*declarator
;
2825 tree postfix_attrs
= NULL_TREE
;
2827 if (!c_parser_next_token_starts_declspecs (parser
))
2829 c_token
*token
= c_parser_peek_token (parser
);
2832 c_parser_set_source_position_from_token (token
);
2833 if (token
->type
== CPP_NAME
2834 && c_parser_peek_2nd_token (parser
)->type
!= CPP_COMMA
2835 && c_parser_peek_2nd_token (parser
)->type
!= CPP_CLOSE_PAREN
)
2837 error ("unknown type name %qE", token
->value
);
2838 parser
->error
= true;
2840 /* ??? In some Objective-C cases '...' isn't applicable so there
2841 should be a different message. */
2843 c_parser_error (parser
,
2844 "expected declaration specifiers or %<...%>");
2845 c_parser_skip_to_end_of_parameter (parser
);
2848 specs
= build_null_declspecs ();
2851 declspecs_add_attrs (specs
, attrs
);
2854 c_parser_declspecs (parser
, specs
, true, true, true);
2855 finish_declspecs (specs
);
2856 pending_xref_error ();
2857 prefix_attrs
= specs
->attrs
;
2858 specs
->attrs
= NULL_TREE
;
2859 declarator
= c_parser_declarator (parser
, specs
->type_seen_p
,
2860 C_DTR_PARM
, &dummy
);
2861 if (declarator
== NULL
)
2863 c_parser_skip_until_found (parser
, CPP_COMMA
, NULL
);
2866 if (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
2867 postfix_attrs
= c_parser_attributes (parser
);
2868 return build_c_parm (specs
, chainon (postfix_attrs
, prefix_attrs
),
2872 /* Parse a string literal in an asm expression. It should not be
2873 translated, and wide string literals are an error although
2874 permitted by the syntax. This is a GNU extension.
2879 ??? At present, following the old parser, the caller needs to have
2880 set lex_untranslated_string to 1. It would be better to follow the
2881 C++ parser rather than using this kludge. */
2884 c_parser_asm_string_literal (c_parser
*parser
)
2887 if (c_parser_next_token_is (parser
, CPP_STRING
))
2889 str
= c_parser_peek_token (parser
)->value
;
2890 c_parser_consume_token (parser
);
2892 else if (c_parser_next_token_is (parser
, CPP_WSTRING
))
2894 error_at (c_parser_peek_token (parser
)->location
,
2895 "wide string literal in %<asm%>");
2896 str
= build_string (1, "");
2897 c_parser_consume_token (parser
);
2901 c_parser_error (parser
, "expected string literal");
2907 /* Parse a simple asm expression. This is used in restricted
2908 contexts, where a full expression with inputs and outputs does not
2909 make sense. This is a GNU extension.
2912 asm ( asm-string-literal )
2916 c_parser_simple_asm_expr (c_parser
*parser
)
2919 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_ASM
));
2920 /* ??? Follow the C++ parser rather than using the
2921 lex_untranslated_string kludge. */
2922 parser
->lex_untranslated_string
= true;
2923 c_parser_consume_token (parser
);
2924 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
2926 parser
->lex_untranslated_string
= false;
2929 str
= c_parser_asm_string_literal (parser
);
2930 parser
->lex_untranslated_string
= false;
2931 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
2933 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
2939 /* Parse (possibly empty) attributes. This is a GNU extension.
2943 attributes attribute
2946 __attribute__ ( ( attribute-list ) )
2950 attribute_list , attrib
2955 any-word ( identifier )
2956 any-word ( identifier , nonempty-expr-list )
2957 any-word ( expr-list )
2959 where the "identifier" must not be declared as a type, and
2960 "any-word" may be any identifier (including one declared as a
2961 type), a reserved word storage class specifier, type specifier or
2962 type qualifier. ??? This still leaves out most reserved keywords
2963 (following the old parser), shouldn't we include them, and why not
2964 allow identifiers declared as types to start the arguments? */
2967 c_parser_attributes (c_parser
*parser
)
2969 tree attrs
= NULL_TREE
;
2970 while (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
2972 /* ??? Follow the C++ parser rather than using the
2973 lex_untranslated_string kludge. */
2974 parser
->lex_untranslated_string
= true;
2975 c_parser_consume_token (parser
);
2976 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
2978 parser
->lex_untranslated_string
= false;
2981 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
2983 parser
->lex_untranslated_string
= false;
2984 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
2987 /* Parse the attribute list. */
2988 while (c_parser_next_token_is (parser
, CPP_COMMA
)
2989 || c_parser_next_token_is (parser
, CPP_NAME
)
2990 || c_parser_next_token_is (parser
, CPP_KEYWORD
))
2992 tree attr
, attr_name
, attr_args
;
2993 VEC(tree
,gc
) *expr_list
;
2994 if (c_parser_next_token_is (parser
, CPP_COMMA
))
2996 c_parser_consume_token (parser
);
2999 if (c_parser_next_token_is (parser
, CPP_KEYWORD
))
3001 /* ??? See comment above about what keywords are
3004 switch (c_parser_peek_token (parser
)->keyword
)
3042 /* Accept __attribute__((__const)) as __attribute__((const))
3045 = ridpointers
[(int) c_parser_peek_token (parser
)->keyword
];
3048 attr_name
= c_parser_peek_token (parser
)->value
;
3049 c_parser_consume_token (parser
);
3050 if (c_parser_next_token_is_not (parser
, CPP_OPEN_PAREN
))
3052 attr
= build_tree_list (attr_name
, NULL_TREE
);
3053 attrs
= chainon (attrs
, attr
);
3056 c_parser_consume_token (parser
);
3057 /* Parse the attribute contents. If they start with an
3058 identifier which is followed by a comma or close
3059 parenthesis, then the arguments start with that
3060 identifier; otherwise they are an expression list. */
3061 if (c_parser_next_token_is (parser
, CPP_NAME
)
3062 && c_parser_peek_token (parser
)->id_kind
== C_ID_ID
3063 && ((c_parser_peek_2nd_token (parser
)->type
== CPP_COMMA
)
3064 || (c_parser_peek_2nd_token (parser
)->type
3065 == CPP_CLOSE_PAREN
)))
3067 tree arg1
= c_parser_peek_token (parser
)->value
;
3068 c_parser_consume_token (parser
);
3069 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
3070 attr_args
= build_tree_list (NULL_TREE
, arg1
);
3074 c_parser_consume_token (parser
);
3075 expr_list
= c_parser_expr_list (parser
, false, true, NULL
);
3076 tree_list
= build_tree_list_vec (expr_list
);
3077 attr_args
= tree_cons (NULL_TREE
, arg1
, tree_list
);
3078 release_tree_vector (expr_list
);
3083 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
3084 attr_args
= NULL_TREE
;
3087 expr_list
= c_parser_expr_list (parser
, false, true, NULL
);
3088 attr_args
= build_tree_list_vec (expr_list
);
3089 release_tree_vector (expr_list
);
3092 attr
= build_tree_list (attr_name
, attr_args
);
3093 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
3094 c_parser_consume_token (parser
);
3097 parser
->lex_untranslated_string
= false;
3098 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
3102 attrs
= chainon (attrs
, attr
);
3104 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
3105 c_parser_consume_token (parser
);
3108 parser
->lex_untranslated_string
= false;
3109 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
3113 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
3114 c_parser_consume_token (parser
);
3117 parser
->lex_untranslated_string
= false;
3118 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
3122 parser
->lex_untranslated_string
= false;
3127 /* Parse a type name (C90 6.5.5, C99 6.7.6).
3130 specifier-qualifier-list abstract-declarator[opt]
3133 static struct c_type_name
*
3134 c_parser_type_name (c_parser
*parser
)
3136 struct c_declspecs
*specs
= build_null_declspecs ();
3137 struct c_declarator
*declarator
;
3138 struct c_type_name
*ret
;
3140 c_parser_declspecs (parser
, specs
, false, true, true);
3141 if (!specs
->declspecs_seen_p
)
3143 c_parser_error (parser
, "expected specifier-qualifier-list");
3146 pending_xref_error ();
3147 finish_declspecs (specs
);
3148 declarator
= c_parser_declarator (parser
, specs
->type_seen_p
,
3149 C_DTR_ABSTRACT
, &dummy
);
3150 if (declarator
== NULL
)
3152 ret
= XOBNEW (&parser_obstack
, struct c_type_name
);
3154 ret
->declarator
= declarator
;
3158 /* Parse an initializer (C90 6.5.7, C99 6.7.8).
3161 assignment-expression
3162 { initializer-list }
3163 { initializer-list , }
3166 designation[opt] initializer
3167 initializer-list , designation[opt] initializer
3174 designator-list designator
3181 [ constant-expression ]
3193 [ constant-expression ... constant-expression ]
3195 Any expression without commas is accepted in the syntax for the
3196 constant-expressions, with non-constant expressions rejected later.
3198 This function is only used for top-level initializers; for nested
3199 ones, see c_parser_initval. */
3201 static struct c_expr
3202 c_parser_initializer (c_parser
*parser
)
3204 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
3205 return c_parser_braced_init (parser
, NULL_TREE
, false);
3209 location_t loc
= c_parser_peek_token (parser
)->location
;
3210 ret
= c_parser_expr_no_commas (parser
, NULL
);
3211 if (TREE_CODE (ret
.value
) != STRING_CST
3212 && TREE_CODE (ret
.value
) != COMPOUND_LITERAL_EXPR
)
3213 ret
= default_function_array_read_conversion (loc
, ret
);
3218 /* Parse a braced initializer list. TYPE is the type specified for a
3219 compound literal, and NULL_TREE for other initializers and for
3220 nested braced lists. NESTED_P is true for nested braced lists,
3221 false for the list of a compound literal or the list that is the
3222 top-level initializer in a declaration. */
3224 static struct c_expr
3225 c_parser_braced_init (c_parser
*parser
, tree type
, bool nested_p
)
3228 struct obstack braced_init_obstack
;
3229 location_t brace_loc
= c_parser_peek_token (parser
)->location
;
3230 gcc_obstack_init (&braced_init_obstack
);
3231 gcc_assert (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
));
3232 c_parser_consume_token (parser
);
3234 push_init_level (0, &braced_init_obstack
);
3236 really_start_incremental_init (type
);
3237 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
3239 pedwarn (brace_loc
, OPT_pedantic
, "ISO C forbids empty initializer braces");
3243 /* Parse a non-empty initializer list, possibly with a trailing
3247 c_parser_initelt (parser
, &braced_init_obstack
);
3250 if (c_parser_next_token_is (parser
, CPP_COMMA
))
3251 c_parser_consume_token (parser
);
3254 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
3258 if (c_parser_next_token_is_not (parser
, CPP_CLOSE_BRACE
))
3260 ret
.value
= error_mark_node
;
3261 ret
.original_code
= ERROR_MARK
;
3262 ret
.original_type
= NULL
;
3263 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
, "expected %<}%>");
3264 pop_init_level (0, &braced_init_obstack
);
3265 obstack_free (&braced_init_obstack
, NULL
);
3268 c_parser_consume_token (parser
);
3269 ret
= pop_init_level (0, &braced_init_obstack
);
3270 obstack_free (&braced_init_obstack
, NULL
);
3274 /* Parse a nested initializer, including designators. */
3277 c_parser_initelt (c_parser
*parser
, struct obstack
* braced_init_obstack
)
3279 /* Parse any designator or designator list. A single array
3280 designator may have the subsequent "=" omitted in GNU C, but a
3281 longer list or a structure member designator may not. */
3282 if (c_parser_next_token_is (parser
, CPP_NAME
)
3283 && c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
)
3285 /* Old-style structure member designator. */
3286 set_init_label (c_parser_peek_token (parser
)->value
,
3287 braced_init_obstack
);
3288 /* Use the colon as the error location. */
3289 pedwarn (c_parser_peek_2nd_token (parser
)->location
, OPT_pedantic
,
3290 "obsolete use of designated initializer with %<:%>");
3291 c_parser_consume_token (parser
);
3292 c_parser_consume_token (parser
);
3296 /* des_seen is 0 if there have been no designators, 1 if there
3297 has been a single array designator and 2 otherwise. */
3299 /* Location of a designator. */
3300 location_t des_loc
= UNKNOWN_LOCATION
; /* Quiet warning. */
3301 while (c_parser_next_token_is (parser
, CPP_OPEN_SQUARE
)
3302 || c_parser_next_token_is (parser
, CPP_DOT
))
3304 int des_prev
= des_seen
;
3306 des_loc
= c_parser_peek_token (parser
)->location
;
3309 if (c_parser_next_token_is (parser
, CPP_DOT
))
3312 c_parser_consume_token (parser
);
3313 if (c_parser_next_token_is (parser
, CPP_NAME
))
3315 set_init_label (c_parser_peek_token (parser
)->value
,
3316 braced_init_obstack
);
3317 c_parser_consume_token (parser
);
3322 init
.value
= error_mark_node
;
3323 init
.original_code
= ERROR_MARK
;
3324 init
.original_type
= NULL
;
3325 c_parser_error (parser
, "expected identifier");
3326 c_parser_skip_until_found (parser
, CPP_COMMA
, NULL
);
3327 process_init_element (init
, false, braced_init_obstack
);
3334 location_t ellipsis_loc
= UNKNOWN_LOCATION
; /* Quiet warning. */
3335 /* ??? Following the old parser, [ objc-receiver
3336 objc-message-args ] is accepted as an initializer,
3337 being distinguished from a designator by what follows
3338 the first assignment expression inside the square
3339 brackets, but after a first array designator a
3340 subsequent square bracket is for Objective-C taken to
3341 start an expression, using the obsolete form of
3342 designated initializer without '=', rather than
3343 possibly being a second level of designation: in LALR
3344 terms, the '[' is shifted rather than reducing
3345 designator to designator-list. */
3346 if (des_prev
== 1 && c_dialect_objc ())
3348 des_seen
= des_prev
;
3351 if (des_prev
== 0 && c_dialect_objc ())
3353 /* This might be an array designator or an
3354 Objective-C message expression. If the former,
3355 continue parsing here; if the latter, parse the
3356 remainder of the initializer given the starting
3357 primary-expression. ??? It might make sense to
3358 distinguish when des_prev == 1 as well; see
3359 previous comment. */
3361 struct c_expr mexpr
;
3362 c_parser_consume_token (parser
);
3363 if (c_parser_peek_token (parser
)->type
== CPP_NAME
3364 && ((c_parser_peek_token (parser
)->id_kind
3366 || (c_parser_peek_token (parser
)->id_kind
3367 == C_ID_CLASSNAME
)))
3369 /* Type name receiver. */
3370 tree id
= c_parser_peek_token (parser
)->value
;
3371 c_parser_consume_token (parser
);
3372 rec
= objc_get_class_reference (id
);
3373 goto parse_message_args
;
3375 first
= c_parser_expr_no_commas (parser
, NULL
).value
;
3376 mark_exp_read (first
);
3377 if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
)
3378 || c_parser_next_token_is (parser
, CPP_CLOSE_SQUARE
))
3379 goto array_desig_after_first
;
3380 /* Expression receiver. So far only one part
3381 without commas has been parsed; there might be
3382 more of the expression. */
3384 while (c_parser_next_token_is (parser
, CPP_COMMA
))
3387 location_t comma_loc
, exp_loc
;
3388 comma_loc
= c_parser_peek_token (parser
)->location
;
3389 c_parser_consume_token (parser
);
3390 exp_loc
= c_parser_peek_token (parser
)->location
;
3391 next
= c_parser_expr_no_commas (parser
, NULL
);
3392 next
= default_function_array_read_conversion (exp_loc
,
3394 rec
= build_compound_expr (comma_loc
, rec
, next
.value
);
3397 /* Now parse the objc-message-args. */
3398 args
= c_parser_objc_message_args (parser
);
3399 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
3402 = objc_build_message_expr (build_tree_list (rec
, args
));
3403 mexpr
.original_code
= ERROR_MARK
;
3404 mexpr
.original_type
= NULL
;
3405 /* Now parse and process the remainder of the
3406 initializer, starting with this message
3407 expression as a primary-expression. */
3408 c_parser_initval (parser
, &mexpr
, braced_init_obstack
);
3411 c_parser_consume_token (parser
);
3412 first
= c_parser_expr_no_commas (parser
, NULL
).value
;
3413 mark_exp_read (first
);
3414 array_desig_after_first
:
3415 if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
))
3417 ellipsis_loc
= c_parser_peek_token (parser
)->location
;
3418 c_parser_consume_token (parser
);
3419 second
= c_parser_expr_no_commas (parser
, NULL
).value
;
3420 mark_exp_read (second
);
3424 if (c_parser_next_token_is (parser
, CPP_CLOSE_SQUARE
))
3426 c_parser_consume_token (parser
);
3427 set_init_index (first
, second
, braced_init_obstack
);
3429 pedwarn (ellipsis_loc
, OPT_pedantic
,
3430 "ISO C forbids specifying range of elements to initialize");
3433 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
3439 if (c_parser_next_token_is (parser
, CPP_EQ
))
3442 pedwarn (des_loc
, OPT_pedantic
,
3443 "ISO C90 forbids specifying subobject to initialize");
3444 c_parser_consume_token (parser
);
3449 pedwarn (c_parser_peek_token (parser
)->location
, OPT_pedantic
,
3450 "obsolete use of designated initializer without %<=%>");
3454 init
.value
= error_mark_node
;
3455 init
.original_code
= ERROR_MARK
;
3456 init
.original_type
= NULL
;
3457 c_parser_error (parser
, "expected %<=%>");
3458 c_parser_skip_until_found (parser
, CPP_COMMA
, NULL
);
3459 process_init_element (init
, false, braced_init_obstack
);
3465 c_parser_initval (parser
, NULL
, braced_init_obstack
);
3468 /* Parse a nested initializer; as c_parser_initializer but parses
3469 initializers within braced lists, after any designators have been
3470 applied. If AFTER is not NULL then it is an Objective-C message
3471 expression which is the primary-expression starting the
3475 c_parser_initval (c_parser
*parser
, struct c_expr
*after
,
3476 struct obstack
* braced_init_obstack
)
3479 gcc_assert (!after
|| c_dialect_objc ());
3480 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
) && !after
)
3481 init
= c_parser_braced_init (parser
, NULL_TREE
, true);
3484 location_t loc
= c_parser_peek_token (parser
)->location
;
3485 init
= c_parser_expr_no_commas (parser
, after
);
3486 if (init
.value
!= NULL_TREE
3487 && TREE_CODE (init
.value
) != STRING_CST
3488 && TREE_CODE (init
.value
) != COMPOUND_LITERAL_EXPR
)
3489 init
= default_function_array_read_conversion (loc
, init
);
3491 process_init_element (init
, false, braced_init_obstack
);
3494 /* Parse a compound statement (possibly a function body) (C90 6.6.2,
3498 { block-item-list[opt] }
3499 { label-declarations block-item-list }
3503 block-item-list block-item
3515 { label-declarations block-item-list }
3518 __extension__ nested-declaration
3519 nested-function-definition
3523 label-declarations label-declaration
3526 __label__ identifier-list ;
3528 Allowing the mixing of declarations and code is new in C99. The
3529 GNU syntax also permits (not shown above) labels at the end of
3530 compound statements, which yield an error. We don't allow labels
3531 on declarations; this might seem like a natural extension, but
3532 there would be a conflict between attributes on the label and
3533 prefix attributes on the declaration. ??? The syntax follows the
3534 old parser in requiring something after label declarations.
3535 Although they are erroneous if the labels declared aren't defined,
3536 is it useful for the syntax to be this way?
3548 c_parser_compound_statement (c_parser
*parser
)
3551 location_t brace_loc
;
3552 brace_loc
= c_parser_peek_token (parser
)->location
;
3553 if (!c_parser_require (parser
, CPP_OPEN_BRACE
, "expected %<{%>"))
3555 /* Ensure a scope is entered and left anyway to avoid confusion
3556 if we have just prepared to enter a function body. */
3557 stmt
= c_begin_compound_stmt (true);
3558 c_end_compound_stmt (brace_loc
, stmt
, true);
3559 return error_mark_node
;
3561 stmt
= c_begin_compound_stmt (true);
3562 c_parser_compound_statement_nostart (parser
);
3563 return c_end_compound_stmt (brace_loc
, stmt
, true);
3566 /* Parse a compound statement except for the opening brace. This is
3567 used for parsing both compound statements and statement expressions
3568 (which follow different paths to handling the opening). */
3571 c_parser_compound_statement_nostart (c_parser
*parser
)
3573 bool last_stmt
= false;
3574 bool last_label
= false;
3575 bool save_valid_for_pragma
= valid_location_for_stdc_pragma_p ();
3576 location_t label_loc
= UNKNOWN_LOCATION
; /* Quiet warning. */
3577 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
3579 c_parser_consume_token (parser
);
3582 mark_valid_location_for_stdc_pragma (true);
3583 if (c_parser_next_token_is_keyword (parser
, RID_LABEL
))
3585 /* Read zero or more forward-declarations for labels that nested
3586 functions can jump to. */
3587 mark_valid_location_for_stdc_pragma (false);
3588 while (c_parser_next_token_is_keyword (parser
, RID_LABEL
))
3590 label_loc
= c_parser_peek_token (parser
)->location
;
3591 c_parser_consume_token (parser
);
3592 /* Any identifiers, including those declared as type names,
3597 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
3599 c_parser_error (parser
, "expected identifier");
3603 = declare_label (c_parser_peek_token (parser
)->value
);
3604 C_DECLARED_LABEL_FLAG (label
) = 1;
3605 add_stmt (build_stmt (label_loc
, DECL_EXPR
, label
));
3606 c_parser_consume_token (parser
);
3607 if (c_parser_next_token_is (parser
, CPP_COMMA
))
3608 c_parser_consume_token (parser
);
3612 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
3614 pedwarn (label_loc
, OPT_pedantic
, "ISO C forbids label declarations");
3616 /* We must now have at least one statement, label or declaration. */
3617 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
3619 mark_valid_location_for_stdc_pragma (save_valid_for_pragma
);
3620 c_parser_error (parser
, "expected declaration or statement");
3621 c_parser_consume_token (parser
);
3624 while (c_parser_next_token_is_not (parser
, CPP_CLOSE_BRACE
))
3626 location_t loc
= c_parser_peek_token (parser
)->location
;
3627 if (c_parser_next_token_is_keyword (parser
, RID_CASE
)
3628 || c_parser_next_token_is_keyword (parser
, RID_DEFAULT
)
3629 || (c_parser_next_token_is (parser
, CPP_NAME
)
3630 && c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
))
3632 if (c_parser_next_token_is_keyword (parser
, RID_CASE
))
3633 label_loc
= c_parser_peek_2nd_token (parser
)->location
;
3635 label_loc
= c_parser_peek_token (parser
)->location
;
3638 mark_valid_location_for_stdc_pragma (false);
3639 c_parser_label (parser
);
3641 else if (!last_label
3642 && c_parser_next_token_starts_declaration (parser
))
3645 mark_valid_location_for_stdc_pragma (false);
3646 c_parser_declaration_or_fndef (parser
, true, true, true, true, true);
3649 (pedantic
&& !flag_isoc99
)
3651 : OPT_Wdeclaration_after_statement
,
3652 "ISO C90 forbids mixed declarations and code");
3655 else if (!last_label
3656 && c_parser_next_token_is_keyword (parser
, RID_EXTENSION
))
3658 /* __extension__ can start a declaration, but is also an
3659 unary operator that can start an expression. Consume all
3660 but the last of a possible series of __extension__ to
3662 while (c_parser_peek_2nd_token (parser
)->type
== CPP_KEYWORD
3663 && (c_parser_peek_2nd_token (parser
)->keyword
3665 c_parser_consume_token (parser
);
3666 if (c_token_starts_declaration (c_parser_peek_2nd_token (parser
)))
3669 ext
= disable_extension_diagnostics ();
3670 c_parser_consume_token (parser
);
3672 mark_valid_location_for_stdc_pragma (false);
3673 c_parser_declaration_or_fndef (parser
, true, true, true, true,
3675 /* Following the old parser, __extension__ does not
3676 disable this diagnostic. */
3677 restore_extension_diagnostics (ext
);
3679 pedwarn_c90 (loc
, (pedantic
&& !flag_isoc99
)
3681 : OPT_Wdeclaration_after_statement
,
3682 "ISO C90 forbids mixed declarations and code");
3688 else if (c_parser_next_token_is (parser
, CPP_PRAGMA
))
3690 /* External pragmas, and some omp pragmas, are not associated
3691 with regular c code, and so are not to be considered statements
3692 syntactically. This ensures that the user doesn't put them
3693 places that would turn into syntax errors if the directive
3695 if (c_parser_pragma (parser
, pragma_compound
))
3696 last_label
= false, last_stmt
= true;
3698 else if (c_parser_next_token_is (parser
, CPP_EOF
))
3700 mark_valid_location_for_stdc_pragma (save_valid_for_pragma
);
3701 c_parser_error (parser
, "expected declaration or statement");
3704 else if (c_parser_next_token_is_keyword (parser
, RID_ELSE
))
3706 if (parser
->in_if_block
)
3708 mark_valid_location_for_stdc_pragma (save_valid_for_pragma
);
3709 error_at (loc
, """expected %<}%> before %<else%>");
3714 error_at (loc
, "%<else%> without a previous %<if%>");
3715 c_parser_consume_token (parser
);
3724 mark_valid_location_for_stdc_pragma (false);
3725 c_parser_statement_after_labels (parser
);
3728 parser
->error
= false;
3731 error_at (label_loc
, "label at end of compound statement");
3732 c_parser_consume_token (parser
);
3733 /* Restore the value we started with. */
3734 mark_valid_location_for_stdc_pragma (save_valid_for_pragma
);
3737 /* Parse a label (C90 6.6.1, C99 6.8.1).
3740 identifier : attributes[opt]
3741 case constant-expression :
3747 case constant-expression ... constant-expression :
3749 The use of attributes on labels is a GNU extension. The syntax in
3750 GNU C accepts any expressions without commas, non-constant
3751 expressions being rejected later. */
3754 c_parser_label (c_parser
*parser
)
3756 location_t loc1
= c_parser_peek_token (parser
)->location
;
3757 tree label
= NULL_TREE
;
3758 if (c_parser_next_token_is_keyword (parser
, RID_CASE
))
3761 c_parser_consume_token (parser
);
3762 exp1
= c_parser_expr_no_commas (parser
, NULL
).value
;
3763 if (c_parser_next_token_is (parser
, CPP_COLON
))
3765 c_parser_consume_token (parser
);
3766 label
= do_case (loc1
, exp1
, NULL_TREE
);
3768 else if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
))
3770 c_parser_consume_token (parser
);
3771 exp2
= c_parser_expr_no_commas (parser
, NULL
).value
;
3772 if (c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
3773 label
= do_case (loc1
, exp1
, exp2
);
3776 c_parser_error (parser
, "expected %<:%> or %<...%>");
3778 else if (c_parser_next_token_is_keyword (parser
, RID_DEFAULT
))
3780 c_parser_consume_token (parser
);
3781 if (c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
3782 label
= do_case (loc1
, NULL_TREE
, NULL_TREE
);
3786 tree name
= c_parser_peek_token (parser
)->value
;
3789 location_t loc2
= c_parser_peek_token (parser
)->location
;
3790 gcc_assert (c_parser_next_token_is (parser
, CPP_NAME
));
3791 c_parser_consume_token (parser
);
3792 gcc_assert (c_parser_next_token_is (parser
, CPP_COLON
));
3793 c_parser_consume_token (parser
);
3794 attrs
= c_parser_attributes (parser
);
3795 tlab
= define_label (loc2
, name
);
3798 decl_attributes (&tlab
, attrs
, 0);
3799 label
= add_stmt (build_stmt (loc1
, LABEL_EXPR
, tlab
));
3804 if (c_parser_next_token_starts_declaration (parser
)
3805 && !(c_parser_next_token_is (parser
, CPP_NAME
)
3806 && c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
))
3808 error_at (c_parser_peek_token (parser
)->location
,
3809 "a label can only be part of a statement and "
3810 "a declaration is not a statement");
3811 c_parser_declaration_or_fndef (parser
, /*fndef_ok*/ false,
3812 /*static_assert_ok*/ true,
3813 /*nested*/ true, /*empty_ok*/ false,
3814 /*start_attr_ok*/ true);
3819 /* Parse a statement (C90 6.6, C99 6.8).
3824 expression-statement
3832 expression-statement:
3835 selection-statement:
3839 iteration-statement:
3848 return expression[opt] ;
3861 objc-throw-statement
3862 objc-try-catch-statement
3863 objc-synchronized-statement
3865 objc-throw-statement:
3879 parallel-for-construct
3880 parallel-sections-construct
3887 parallel-directive structured-block
3890 for-directive iteration-statement
3893 sections-directive section-scope
3896 single-directive structured-block
3898 parallel-for-construct:
3899 parallel-for-directive iteration-statement
3901 parallel-sections-construct:
3902 parallel-sections-directive section-scope
3905 master-directive structured-block
3908 critical-directive structured-block
3911 atomic-directive expression-statement
3914 ordered-directive structured-block */
3917 c_parser_statement (c_parser
*parser
)
3919 while (c_parser_next_token_is_keyword (parser
, RID_CASE
)
3920 || c_parser_next_token_is_keyword (parser
, RID_DEFAULT
)
3921 || (c_parser_next_token_is (parser
, CPP_NAME
)
3922 && c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
))
3923 c_parser_label (parser
);
3924 c_parser_statement_after_labels (parser
);
3927 /* Parse a statement, other than a labeled statement. */
3930 c_parser_statement_after_labels (c_parser
*parser
)
3932 location_t loc
= c_parser_peek_token (parser
)->location
;
3933 tree stmt
= NULL_TREE
;
3934 bool in_if_block
= parser
->in_if_block
;
3935 parser
->in_if_block
= false;
3936 switch (c_parser_peek_token (parser
)->type
)
3938 case CPP_OPEN_BRACE
:
3939 add_stmt (c_parser_compound_statement (parser
));
3942 switch (c_parser_peek_token (parser
)->keyword
)
3945 c_parser_if_statement (parser
);
3948 c_parser_switch_statement (parser
);
3951 c_parser_while_statement (parser
);
3954 c_parser_do_statement (parser
);
3957 c_parser_for_statement (parser
);
3960 c_parser_consume_token (parser
);
3961 if (c_parser_next_token_is (parser
, CPP_NAME
))
3963 stmt
= c_finish_goto_label (loc
,
3964 c_parser_peek_token (parser
)->value
);
3965 c_parser_consume_token (parser
);
3967 else if (c_parser_next_token_is (parser
, CPP_MULT
))
3969 c_parser_consume_token (parser
);
3970 stmt
= c_finish_goto_ptr (loc
,
3971 c_parser_expression (parser
).value
);
3974 c_parser_error (parser
, "expected identifier or %<*%>");
3975 goto expect_semicolon
;
3977 c_parser_consume_token (parser
);
3978 stmt
= c_finish_bc_stmt (loc
, &c_cont_label
, false);
3979 goto expect_semicolon
;
3981 c_parser_consume_token (parser
);
3982 stmt
= c_finish_bc_stmt (loc
, &c_break_label
, true);
3983 goto expect_semicolon
;
3985 c_parser_consume_token (parser
);
3986 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
3988 stmt
= c_finish_return (loc
, NULL_TREE
, NULL_TREE
);
3989 c_parser_consume_token (parser
);
3993 struct c_expr expr
= c_parser_expression_conv (parser
);
3994 mark_exp_read (expr
.value
);
3995 stmt
= c_finish_return (loc
, expr
.value
, expr
.original_type
);
3996 goto expect_semicolon
;
4000 stmt
= c_parser_asm_statement (parser
);
4003 gcc_assert (c_dialect_objc ());
4004 c_parser_consume_token (parser
);
4005 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
4007 stmt
= objc_build_throw_stmt (loc
, NULL_TREE
);
4008 c_parser_consume_token (parser
);
4012 tree expr
= c_parser_expression (parser
).value
;
4013 expr
= c_fully_fold (expr
, false, NULL
);
4014 stmt
= objc_build_throw_stmt (loc
, expr
);
4015 goto expect_semicolon
;
4019 gcc_assert (c_dialect_objc ());
4020 c_parser_objc_try_catch_statement (parser
);
4022 case RID_AT_SYNCHRONIZED
:
4023 gcc_assert (c_dialect_objc ());
4024 c_parser_objc_synchronized_statement (parser
);
4031 c_parser_consume_token (parser
);
4033 case CPP_CLOSE_PAREN
:
4034 case CPP_CLOSE_SQUARE
:
4035 /* Avoid infinite loop in error recovery:
4036 c_parser_skip_until_found stops at a closing nesting
4037 delimiter without consuming it, but here we need to consume
4038 it to proceed further. */
4039 c_parser_error (parser
, "expected statement");
4040 c_parser_consume_token (parser
);
4043 c_parser_pragma (parser
, pragma_stmt
);
4047 stmt
= c_finish_expr_stmt (loc
, c_parser_expression_conv (parser
).value
);
4049 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
4052 /* Two cases cannot and do not have line numbers associated: If stmt
4053 is degenerate, such as "2;", then stmt is an INTEGER_CST, which
4054 cannot hold line numbers. But that's OK because the statement
4055 will either be changed to a MODIFY_EXPR during gimplification of
4056 the statement expr, or discarded. If stmt was compound, but
4057 without new variables, we will have skipped the creation of a
4058 BIND and will have a bare STATEMENT_LIST. But that's OK because
4059 (recursively) all of the component statements should already have
4060 line numbers assigned. ??? Can we discard no-op statements
4062 if (CAN_HAVE_LOCATION_P (stmt
)
4063 && EXPR_LOCATION (stmt
) == UNKNOWN_LOCATION
)
4064 SET_EXPR_LOCATION (stmt
, loc
);
4066 parser
->in_if_block
= in_if_block
;
4069 /* Parse the condition from an if, do, while or for statements. */
4072 c_parser_condition (c_parser
*parser
)
4074 location_t loc
= c_parser_peek_token (parser
)->location
;
4076 cond
= c_parser_expression_conv (parser
).value
;
4077 cond
= c_objc_common_truthvalue_conversion (loc
, cond
);
4078 cond
= c_fully_fold (cond
, false, NULL
);
4079 if (warn_sequence_point
)
4080 verify_sequence_points (cond
);
4084 /* Parse a parenthesized condition from an if, do or while statement.
4090 c_parser_paren_condition (c_parser
*parser
)
4093 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
4094 return error_mark_node
;
4095 cond
= c_parser_condition (parser
);
4096 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
4100 /* Parse a statement which is a block in C99. */
4103 c_parser_c99_block_statement (c_parser
*parser
)
4105 tree block
= c_begin_compound_stmt (flag_isoc99
);
4106 location_t loc
= c_parser_peek_token (parser
)->location
;
4107 c_parser_statement (parser
);
4108 return c_end_compound_stmt (loc
, block
, flag_isoc99
);
4111 /* Parse the body of an if statement. This is just parsing a
4112 statement but (a) it is a block in C99, (b) we track whether the
4113 body is an if statement for the sake of -Wparentheses warnings, (c)
4114 we handle an empty body specially for the sake of -Wempty-body
4115 warnings, and (d) we call parser_compound_statement directly
4116 because c_parser_statement_after_labels resets
4117 parser->in_if_block. */
4120 c_parser_if_body (c_parser
*parser
, bool *if_p
)
4122 tree block
= c_begin_compound_stmt (flag_isoc99
);
4123 location_t body_loc
= c_parser_peek_token (parser
)->location
;
4124 while (c_parser_next_token_is_keyword (parser
, RID_CASE
)
4125 || c_parser_next_token_is_keyword (parser
, RID_DEFAULT
)
4126 || (c_parser_next_token_is (parser
, CPP_NAME
)
4127 && c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
))
4128 c_parser_label (parser
);
4129 *if_p
= c_parser_next_token_is_keyword (parser
, RID_IF
);
4130 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
4132 location_t loc
= c_parser_peek_token (parser
)->location
;
4133 add_stmt (build_empty_stmt (loc
));
4134 c_parser_consume_token (parser
);
4135 if (!c_parser_next_token_is_keyword (parser
, RID_ELSE
))
4136 warning_at (loc
, OPT_Wempty_body
,
4137 "suggest braces around empty body in an %<if%> statement");
4139 else if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
4140 add_stmt (c_parser_compound_statement (parser
));
4142 c_parser_statement_after_labels (parser
);
4143 return c_end_compound_stmt (body_loc
, block
, flag_isoc99
);
4146 /* Parse the else body of an if statement. This is just parsing a
4147 statement but (a) it is a block in C99, (b) we handle an empty body
4148 specially for the sake of -Wempty-body warnings. */
4151 c_parser_else_body (c_parser
*parser
)
4153 location_t else_loc
= c_parser_peek_token (parser
)->location
;
4154 tree block
= c_begin_compound_stmt (flag_isoc99
);
4155 while (c_parser_next_token_is_keyword (parser
, RID_CASE
)
4156 || c_parser_next_token_is_keyword (parser
, RID_DEFAULT
)
4157 || (c_parser_next_token_is (parser
, CPP_NAME
)
4158 && c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
))
4159 c_parser_label (parser
);
4160 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
4162 location_t loc
= c_parser_peek_token (parser
)->location
;
4165 "suggest braces around empty body in an %<else%> statement");
4166 add_stmt (build_empty_stmt (loc
));
4167 c_parser_consume_token (parser
);
4170 c_parser_statement_after_labels (parser
);
4171 return c_end_compound_stmt (else_loc
, block
, flag_isoc99
);
4174 /* Parse an if statement (C90 6.6.4, C99 6.8.4).
4177 if ( expression ) statement
4178 if ( expression ) statement else statement
4182 c_parser_if_statement (c_parser
*parser
)
4187 bool first_if
= false;
4188 tree first_body
, second_body
;
4191 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_IF
));
4192 c_parser_consume_token (parser
);
4193 block
= c_begin_compound_stmt (flag_isoc99
);
4194 loc
= c_parser_peek_token (parser
)->location
;
4195 cond
= c_parser_paren_condition (parser
);
4196 in_if_block
= parser
->in_if_block
;
4197 parser
->in_if_block
= true;
4198 first_body
= c_parser_if_body (parser
, &first_if
);
4199 parser
->in_if_block
= in_if_block
;
4200 if (c_parser_next_token_is_keyword (parser
, RID_ELSE
))
4202 c_parser_consume_token (parser
);
4203 second_body
= c_parser_else_body (parser
);
4206 second_body
= NULL_TREE
;
4207 c_finish_if_stmt (loc
, cond
, first_body
, second_body
, first_if
);
4208 add_stmt (c_end_compound_stmt (loc
, block
, flag_isoc99
));
4211 /* Parse a switch statement (C90 6.6.4, C99 6.8.4).
4214 switch (expression) statement
4218 c_parser_switch_statement (c_parser
*parser
)
4220 tree block
, expr
, body
, save_break
;
4221 location_t switch_loc
= c_parser_peek_token (parser
)->location
;
4222 location_t switch_cond_loc
;
4223 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_SWITCH
));
4224 c_parser_consume_token (parser
);
4225 block
= c_begin_compound_stmt (flag_isoc99
);
4226 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
4228 switch_cond_loc
= c_parser_peek_token (parser
)->location
;
4229 expr
= c_parser_expression (parser
).value
;
4230 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
4234 switch_cond_loc
= UNKNOWN_LOCATION
;
4235 expr
= error_mark_node
;
4237 c_start_case (switch_loc
, switch_cond_loc
, expr
);
4238 save_break
= c_break_label
;
4239 c_break_label
= NULL_TREE
;
4240 body
= c_parser_c99_block_statement (parser
);
4241 c_finish_case (body
);
4244 location_t here
= c_parser_peek_token (parser
)->location
;
4245 tree t
= build1 (LABEL_EXPR
, void_type_node
, c_break_label
);
4246 SET_EXPR_LOCATION (t
, here
);
4249 c_break_label
= save_break
;
4250 add_stmt (c_end_compound_stmt (switch_loc
, block
, flag_isoc99
));
4253 /* Parse a while statement (C90 6.6.5, C99 6.8.5).
4256 while (expression) statement
4260 c_parser_while_statement (c_parser
*parser
)
4262 tree block
, cond
, body
, save_break
, save_cont
;
4264 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_WHILE
));
4265 c_parser_consume_token (parser
);
4266 block
= c_begin_compound_stmt (flag_isoc99
);
4267 loc
= c_parser_peek_token (parser
)->location
;
4268 cond
= c_parser_paren_condition (parser
);
4269 save_break
= c_break_label
;
4270 c_break_label
= NULL_TREE
;
4271 save_cont
= c_cont_label
;
4272 c_cont_label
= NULL_TREE
;
4273 body
= c_parser_c99_block_statement (parser
);
4274 c_finish_loop (loc
, cond
, NULL
, body
, c_break_label
, c_cont_label
, true);
4275 add_stmt (c_end_compound_stmt (loc
, block
, flag_isoc99
));
4276 c_break_label
= save_break
;
4277 c_cont_label
= save_cont
;
4280 /* Parse a do statement (C90 6.6.5, C99 6.8.5).
4283 do statement while ( expression ) ;
4287 c_parser_do_statement (c_parser
*parser
)
4289 tree block
, cond
, body
, save_break
, save_cont
, new_break
, new_cont
;
4291 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_DO
));
4292 c_parser_consume_token (parser
);
4293 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
4294 warning_at (c_parser_peek_token (parser
)->location
,
4296 "suggest braces around empty body in %<do%> statement");
4297 block
= c_begin_compound_stmt (flag_isoc99
);
4298 loc
= c_parser_peek_token (parser
)->location
;
4299 save_break
= c_break_label
;
4300 c_break_label
= NULL_TREE
;
4301 save_cont
= c_cont_label
;
4302 c_cont_label
= NULL_TREE
;
4303 body
= c_parser_c99_block_statement (parser
);
4304 c_parser_require_keyword (parser
, RID_WHILE
, "expected %<while%>");
4305 new_break
= c_break_label
;
4306 c_break_label
= save_break
;
4307 new_cont
= c_cont_label
;
4308 c_cont_label
= save_cont
;
4309 cond
= c_parser_paren_condition (parser
);
4310 if (!c_parser_require (parser
, CPP_SEMICOLON
, "expected %<;%>"))
4311 c_parser_skip_to_end_of_block_or_statement (parser
);
4312 c_finish_loop (loc
, cond
, NULL
, body
, new_break
, new_cont
, false);
4313 add_stmt (c_end_compound_stmt (loc
, block
, flag_isoc99
));
4316 /* Parse a for statement (C90 6.6.5, C99 6.8.5).
4319 for ( expression[opt] ; expression[opt] ; expression[opt] ) statement
4320 for ( nested-declaration expression[opt] ; expression[opt] ) statement
4322 The form with a declaration is new in C99.
4324 ??? In accordance with the old parser, the declaration may be a
4325 nested function, which is then rejected in check_for_loop_decls,
4326 but does it make any sense for this to be included in the grammar?
4327 Note in particular that the nested function does not include a
4328 trailing ';', whereas the "declaration" production includes one.
4329 Also, can we reject bad declarations earlier and cheaper than
4330 check_for_loop_decls? */
4333 c_parser_for_statement (c_parser
*parser
)
4335 tree block
, cond
, incr
, save_break
, save_cont
, body
;
4336 location_t loc
= c_parser_peek_token (parser
)->location
;
4337 location_t for_loc
= c_parser_peek_token (parser
)->location
;
4338 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_FOR
));
4339 c_parser_consume_token (parser
);
4340 block
= c_begin_compound_stmt (flag_isoc99
);
4341 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
4343 /* Parse the initialization declaration or expression. */
4344 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
4346 c_parser_consume_token (parser
);
4347 c_finish_expr_stmt (loc
, NULL_TREE
);
4349 else if (c_parser_next_token_starts_declaration (parser
))
4351 c_parser_declaration_or_fndef (parser
, true, true, true, true, true);
4352 check_for_loop_decls (for_loc
);
4354 else if (c_parser_next_token_is_keyword (parser
, RID_EXTENSION
))
4356 /* __extension__ can start a declaration, but is also an
4357 unary operator that can start an expression. Consume all
4358 but the last of a possible series of __extension__ to
4360 while (c_parser_peek_2nd_token (parser
)->type
== CPP_KEYWORD
4361 && (c_parser_peek_2nd_token (parser
)->keyword
4363 c_parser_consume_token (parser
);
4364 if (c_token_starts_declaration (c_parser_peek_2nd_token (parser
)))
4367 ext
= disable_extension_diagnostics ();
4368 c_parser_consume_token (parser
);
4369 c_parser_declaration_or_fndef (parser
, true, true, true, true,
4371 restore_extension_diagnostics (ext
);
4372 check_for_loop_decls (for_loc
);
4380 c_finish_expr_stmt (loc
, c_parser_expression (parser
).value
);
4381 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
4383 /* Parse the loop condition. */
4384 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
4386 c_parser_consume_token (parser
);
4391 cond
= c_parser_condition (parser
);
4392 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
4394 /* Parse the increment expression. */
4395 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
4396 incr
= c_process_expr_stmt (loc
, NULL_TREE
);
4398 incr
= c_process_expr_stmt (loc
, c_parser_expression (parser
).value
);
4399 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
4403 cond
= error_mark_node
;
4404 incr
= error_mark_node
;
4406 save_break
= c_break_label
;
4407 c_break_label
= NULL_TREE
;
4408 save_cont
= c_cont_label
;
4409 c_cont_label
= NULL_TREE
;
4410 body
= c_parser_c99_block_statement (parser
);
4411 c_finish_loop (loc
, cond
, incr
, body
, c_break_label
, c_cont_label
, true);
4412 add_stmt (c_end_compound_stmt (loc
, block
, flag_isoc99
));
4413 c_break_label
= save_break
;
4414 c_cont_label
= save_cont
;
4417 /* Parse an asm statement, a GNU extension. This is a full-blown asm
4418 statement with inputs, outputs, clobbers, and volatile tag
4422 asm type-qualifier[opt] ( asm-argument ) ;
4423 asm type-qualifier[opt] goto ( asm-goto-argument ) ;
4427 asm-string-literal : asm-operands[opt]
4428 asm-string-literal : asm-operands[opt] : asm-operands[opt]
4429 asm-string-literal : asm-operands[opt] : asm-operands[opt] : asm-clobbers[opt]
4432 asm-string-literal : : asm-operands[opt] : asm-clobbers[opt] \
4435 Qualifiers other than volatile are accepted in the syntax but
4439 c_parser_asm_statement (c_parser
*parser
)
4441 tree quals
, str
, outputs
, inputs
, clobbers
, labels
, ret
;
4442 bool simple
, is_goto
;
4443 location_t asm_loc
= c_parser_peek_token (parser
)->location
;
4444 int section
, nsections
;
4446 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_ASM
));
4447 c_parser_consume_token (parser
);
4448 if (c_parser_next_token_is_keyword (parser
, RID_VOLATILE
))
4450 quals
= c_parser_peek_token (parser
)->value
;
4451 c_parser_consume_token (parser
);
4453 else if (c_parser_next_token_is_keyword (parser
, RID_CONST
)
4454 || c_parser_next_token_is_keyword (parser
, RID_RESTRICT
))
4456 warning_at (c_parser_peek_token (parser
)->location
,
4458 "%E qualifier ignored on asm",
4459 c_parser_peek_token (parser
)->value
);
4461 c_parser_consume_token (parser
);
4467 if (c_parser_next_token_is_keyword (parser
, RID_GOTO
))
4469 c_parser_consume_token (parser
);
4473 /* ??? Follow the C++ parser rather than using the
4474 lex_untranslated_string kludge. */
4475 parser
->lex_untranslated_string
= true;
4478 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
4481 str
= c_parser_asm_string_literal (parser
);
4482 if (str
== NULL_TREE
)
4483 goto error_close_paren
;
4486 outputs
= NULL_TREE
;
4488 clobbers
= NULL_TREE
;
4491 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
) && !is_goto
)
4494 /* Parse each colon-delimited section of operands. */
4495 nsections
= 3 + is_goto
;
4496 for (section
= 0; section
< nsections
; ++section
)
4498 if (!c_parser_require (parser
, CPP_COLON
,
4501 : "expected %<:%> or %<)%>"))
4502 goto error_close_paren
;
4504 /* Once past any colon, we're no longer a simple asm. */
4507 if ((!c_parser_next_token_is (parser
, CPP_COLON
)
4508 && !c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
4513 /* For asm goto, we don't allow output operands, but reserve
4514 the slot for a future extension that does allow them. */
4516 outputs
= c_parser_asm_operands (parser
, false);
4519 inputs
= c_parser_asm_operands (parser
, true);
4522 clobbers
= c_parser_asm_clobbers (parser
);
4525 labels
= c_parser_asm_goto_operands (parser
);
4531 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
) && !is_goto
)
4536 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
4538 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
4542 if (!c_parser_require (parser
, CPP_SEMICOLON
, "expected %<;%>"))
4543 c_parser_skip_to_end_of_block_or_statement (parser
);
4545 ret
= build_asm_stmt (quals
, build_asm_expr (asm_loc
, str
, outputs
, inputs
,
4546 clobbers
, labels
, simple
));
4549 parser
->lex_untranslated_string
= false;
4553 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
4557 /* Parse asm operands, a GNU extension. If CONVERT_P (for inputs but
4558 not outputs), apply the default conversion of functions and arrays
4563 asm-operands , asm-operand
4566 asm-string-literal ( expression )
4567 [ identifier ] asm-string-literal ( expression )
4571 c_parser_asm_operands (c_parser
*parser
, bool convert_p
)
4573 tree list
= NULL_TREE
;
4579 if (c_parser_next_token_is (parser
, CPP_OPEN_SQUARE
))
4581 c_parser_consume_token (parser
);
4582 if (c_parser_next_token_is (parser
, CPP_NAME
))
4584 tree id
= c_parser_peek_token (parser
)->value
;
4585 c_parser_consume_token (parser
);
4586 name
= build_string (IDENTIFIER_LENGTH (id
),
4587 IDENTIFIER_POINTER (id
));
4591 c_parser_error (parser
, "expected identifier");
4592 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
, NULL
);
4595 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
4600 str
= c_parser_asm_string_literal (parser
);
4601 if (str
== NULL_TREE
)
4603 parser
->lex_untranslated_string
= false;
4604 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
4606 parser
->lex_untranslated_string
= true;
4609 loc
= c_parser_peek_token (parser
)->location
;
4610 expr
= c_parser_expression (parser
);
4611 mark_exp_read (expr
.value
);
4613 expr
= default_function_array_conversion (loc
, expr
);
4614 expr
.value
= c_fully_fold (expr
.value
, false, NULL
);
4615 parser
->lex_untranslated_string
= true;
4616 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
4618 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
4621 list
= chainon (list
, build_tree_list (build_tree_list (name
, str
),
4623 if (c_parser_next_token_is (parser
, CPP_COMMA
))
4624 c_parser_consume_token (parser
);
4631 /* Parse asm clobbers, a GNU extension.
4635 asm-clobbers , asm-string-literal
4639 c_parser_asm_clobbers (c_parser
*parser
)
4641 tree list
= NULL_TREE
;
4644 tree str
= c_parser_asm_string_literal (parser
);
4646 list
= tree_cons (NULL_TREE
, str
, list
);
4649 if (c_parser_next_token_is (parser
, CPP_COMMA
))
4650 c_parser_consume_token (parser
);
4657 /* Parse asm goto labels, a GNU extension.
4661 asm-goto-operands , identifier
4665 c_parser_asm_goto_operands (c_parser
*parser
)
4667 tree list
= NULL_TREE
;
4672 if (c_parser_next_token_is (parser
, CPP_NAME
))
4674 c_token
*tok
= c_parser_peek_token (parser
);
4676 label
= lookup_label_for_goto (tok
->location
, name
);
4677 c_parser_consume_token (parser
);
4678 TREE_USED (label
) = 1;
4682 c_parser_error (parser
, "expected identifier");
4686 name
= build_string (IDENTIFIER_LENGTH (name
),
4687 IDENTIFIER_POINTER (name
));
4688 list
= tree_cons (name
, label
, list
);
4689 if (c_parser_next_token_is (parser
, CPP_COMMA
))
4690 c_parser_consume_token (parser
);
4692 return nreverse (list
);
4696 /* Parse an expression other than a compound expression; that is, an
4697 assignment expression (C90 6.3.16, C99 6.5.16). If AFTER is not
4698 NULL then it is an Objective-C message expression which is the
4699 primary-expression starting the expression as an initializer.
4701 assignment-expression:
4702 conditional-expression
4703 unary-expression assignment-operator assignment-expression
4705 assignment-operator: one of
4706 = *= /= %= += -= <<= >>= &= ^= |=
4708 In GNU C we accept any conditional expression on the LHS and
4709 diagnose the invalid lvalue rather than producing a syntax
4712 static struct c_expr
4713 c_parser_expr_no_commas (c_parser
*parser
, struct c_expr
*after
)
4715 struct c_expr lhs
, rhs
, ret
;
4716 enum tree_code code
;
4717 location_t op_location
, exp_location
;
4718 gcc_assert (!after
|| c_dialect_objc ());
4719 lhs
= c_parser_conditional_expression (parser
, after
);
4720 op_location
= c_parser_peek_token (parser
)->location
;
4721 switch (c_parser_peek_token (parser
)->type
)
4730 code
= TRUNC_DIV_EXPR
;
4733 code
= TRUNC_MOD_EXPR
;
4748 code
= BIT_AND_EXPR
;
4751 code
= BIT_XOR_EXPR
;
4754 code
= BIT_IOR_EXPR
;
4759 c_parser_consume_token (parser
);
4760 exp_location
= c_parser_peek_token (parser
)->location
;
4761 rhs
= c_parser_expr_no_commas (parser
, NULL
);
4762 rhs
= default_function_array_read_conversion (exp_location
, rhs
);
4763 ret
.value
= build_modify_expr (op_location
, lhs
.value
, lhs
.original_type
,
4764 code
, exp_location
, rhs
.value
,
4766 if (code
== NOP_EXPR
)
4767 ret
.original_code
= MODIFY_EXPR
;
4770 TREE_NO_WARNING (ret
.value
) = 1;
4771 ret
.original_code
= ERROR_MARK
;
4773 ret
.original_type
= NULL
;
4777 /* Parse a conditional expression (C90 6.3.15, C99 6.5.15). If AFTER
4778 is not NULL then it is an Objective-C message expression which is
4779 the primary-expression starting the expression as an initializer.
4781 conditional-expression:
4782 logical-OR-expression
4783 logical-OR-expression ? expression : conditional-expression
4787 conditional-expression:
4788 logical-OR-expression ? : conditional-expression
4791 static struct c_expr
4792 c_parser_conditional_expression (c_parser
*parser
, struct c_expr
*after
)
4794 struct c_expr cond
, exp1
, exp2
, ret
;
4795 location_t cond_loc
, colon_loc
, middle_loc
;
4797 gcc_assert (!after
|| c_dialect_objc ());
4799 cond
= c_parser_binary_expression (parser
, after
);
4801 if (c_parser_next_token_is_not (parser
, CPP_QUERY
))
4803 cond_loc
= c_parser_peek_token (parser
)->location
;
4804 cond
= default_function_array_read_conversion (cond_loc
, cond
);
4805 c_parser_consume_token (parser
);
4806 if (c_parser_next_token_is (parser
, CPP_COLON
))
4808 tree eptype
= NULL_TREE
;
4810 middle_loc
= c_parser_peek_token (parser
)->location
;
4811 pedwarn (middle_loc
, OPT_pedantic
,
4812 "ISO C forbids omitting the middle term of a ?: expression");
4813 warn_for_omitted_condop (middle_loc
, cond
.value
);
4814 if (TREE_CODE (cond
.value
) == EXCESS_PRECISION_EXPR
)
4816 eptype
= TREE_TYPE (cond
.value
);
4817 cond
.value
= TREE_OPERAND (cond
.value
, 0);
4819 /* Make sure first operand is calculated only once. */
4820 exp1
.value
= c_save_expr (default_conversion (cond
.value
));
4822 exp1
.value
= build1 (EXCESS_PRECISION_EXPR
, eptype
, exp1
.value
);
4823 exp1
.original_type
= NULL
;
4824 cond
.value
= c_objc_common_truthvalue_conversion (cond_loc
, exp1
.value
);
4825 c_inhibit_evaluation_warnings
+= cond
.value
== truthvalue_true_node
;
4830 = c_objc_common_truthvalue_conversion
4831 (cond_loc
, default_conversion (cond
.value
));
4832 c_inhibit_evaluation_warnings
+= cond
.value
== truthvalue_false_node
;
4833 exp1
= c_parser_expression_conv (parser
);
4834 mark_exp_read (exp1
.value
);
4835 c_inhibit_evaluation_warnings
+=
4836 ((cond
.value
== truthvalue_true_node
)
4837 - (cond
.value
== truthvalue_false_node
));
4840 colon_loc
= c_parser_peek_token (parser
)->location
;
4841 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
4843 c_inhibit_evaluation_warnings
-= cond
.value
== truthvalue_true_node
;
4844 ret
.value
= error_mark_node
;
4845 ret
.original_code
= ERROR_MARK
;
4846 ret
.original_type
= NULL
;
4850 location_t exp2_loc
= c_parser_peek_token (parser
)->location
;
4851 exp2
= c_parser_conditional_expression (parser
, NULL
);
4852 exp2
= default_function_array_read_conversion (exp2_loc
, exp2
);
4854 c_inhibit_evaluation_warnings
-= cond
.value
== truthvalue_true_node
;
4855 ret
.value
= build_conditional_expr (colon_loc
, cond
.value
,
4856 cond
.original_code
== C_MAYBE_CONST_EXPR
,
4857 exp1
.value
, exp1
.original_type
,
4858 exp2
.value
, exp2
.original_type
);
4859 ret
.original_code
= ERROR_MARK
;
4860 if (exp1
.value
== error_mark_node
|| exp2
.value
== error_mark_node
)
4861 ret
.original_type
= NULL
;
4866 /* If both sides are enum type, the default conversion will have
4867 made the type of the result be an integer type. We want to
4868 remember the enum types we started with. */
4869 t1
= exp1
.original_type
? exp1
.original_type
: TREE_TYPE (exp1
.value
);
4870 t2
= exp2
.original_type
? exp2
.original_type
: TREE_TYPE (exp2
.value
);
4871 ret
.original_type
= ((t1
!= error_mark_node
4872 && t2
!= error_mark_node
4873 && (TYPE_MAIN_VARIANT (t1
)
4874 == TYPE_MAIN_VARIANT (t2
)))
4881 /* Parse a binary expression; that is, a logical-OR-expression (C90
4882 6.3.5-6.3.14, C99 6.5.5-6.5.14). If AFTER is not NULL then it is
4883 an Objective-C message expression which is the primary-expression
4884 starting the expression as an initializer.
4886 multiplicative-expression:
4888 multiplicative-expression * cast-expression
4889 multiplicative-expression / cast-expression
4890 multiplicative-expression % cast-expression
4892 additive-expression:
4893 multiplicative-expression
4894 additive-expression + multiplicative-expression
4895 additive-expression - multiplicative-expression
4899 shift-expression << additive-expression
4900 shift-expression >> additive-expression
4902 relational-expression:
4904 relational-expression < shift-expression
4905 relational-expression > shift-expression
4906 relational-expression <= shift-expression
4907 relational-expression >= shift-expression
4909 equality-expression:
4910 relational-expression
4911 equality-expression == relational-expression
4912 equality-expression != relational-expression
4916 AND-expression & equality-expression
4918 exclusive-OR-expression:
4920 exclusive-OR-expression ^ AND-expression
4922 inclusive-OR-expression:
4923 exclusive-OR-expression
4924 inclusive-OR-expression | exclusive-OR-expression
4926 logical-AND-expression:
4927 inclusive-OR-expression
4928 logical-AND-expression && inclusive-OR-expression
4930 logical-OR-expression:
4931 logical-AND-expression
4932 logical-OR-expression || logical-AND-expression
4935 static struct c_expr
4936 c_parser_binary_expression (c_parser
*parser
, struct c_expr
*after
)
4938 /* A binary expression is parsed using operator-precedence parsing,
4939 with the operands being cast expressions. All the binary
4940 operators are left-associative. Thus a binary expression is of
4943 E0 op1 E1 op2 E2 ...
4945 which we represent on a stack. On the stack, the precedence
4946 levels are strictly increasing. When a new operator is
4947 encountered of higher precedence than that at the top of the
4948 stack, it is pushed; its LHS is the top expression, and its RHS
4949 is everything parsed until it is popped. When a new operator is
4950 encountered with precedence less than or equal to that at the top
4951 of the stack, triples E[i-1] op[i] E[i] are popped and replaced
4952 by the result of the operation until the operator at the top of
4953 the stack has lower precedence than the new operator or there is
4954 only one element on the stack; then the top expression is the LHS
4955 of the new operator. In the case of logical AND and OR
4956 expressions, we also need to adjust c_inhibit_evaluation_warnings
4957 as appropriate when the operators are pushed and popped. */
4959 /* The precedence levels, where 0 is a dummy lowest level used for
4960 the bottom of the stack. */
4976 /* The expression at this stack level. */
4978 /* The precedence of the operator on its left, PREC_NONE at the
4979 bottom of the stack. */
4981 /* The operation on its left. */
4983 /* The source location of this operation. */
4987 /* Location of the binary operator. */
4988 location_t binary_loc
= UNKNOWN_LOCATION
; /* Quiet warning. */
4991 switch (stack[sp].op) \
4993 case TRUTH_ANDIF_EXPR: \
4994 c_inhibit_evaluation_warnings -= (stack[sp - 1].expr.value \
4995 == truthvalue_false_node); \
4997 case TRUTH_ORIF_EXPR: \
4998 c_inhibit_evaluation_warnings -= (stack[sp - 1].expr.value \
4999 == truthvalue_true_node); \
5004 stack[sp - 1].expr \
5005 = default_function_array_read_conversion (stack[sp - 1].loc, \
5006 stack[sp - 1].expr); \
5008 = default_function_array_read_conversion (stack[sp].loc, \
5010 stack[sp - 1].expr = parser_build_binary_op (stack[sp].loc, \
5012 stack[sp - 1].expr, \
5016 gcc_assert (!after
|| c_dialect_objc ());
5017 stack
[0].loc
= c_parser_peek_token (parser
)->location
;
5018 stack
[0].expr
= c_parser_cast_expression (parser
, after
);
5019 stack
[0].prec
= PREC_NONE
;
5024 enum tree_code ocode
;
5027 switch (c_parser_peek_token (parser
)->type
)
5035 ocode
= TRUNC_DIV_EXPR
;
5039 ocode
= TRUNC_MOD_EXPR
;
5051 ocode
= LSHIFT_EXPR
;
5055 ocode
= RSHIFT_EXPR
;
5069 case CPP_GREATER_EQ
:
5082 oprec
= PREC_BITAND
;
5083 ocode
= BIT_AND_EXPR
;
5086 oprec
= PREC_BITXOR
;
5087 ocode
= BIT_XOR_EXPR
;
5091 ocode
= BIT_IOR_EXPR
;
5094 oprec
= PREC_LOGAND
;
5095 ocode
= TRUTH_ANDIF_EXPR
;
5099 ocode
= TRUTH_ORIF_EXPR
;
5102 /* Not a binary operator, so end of the binary
5106 binary_loc
= c_parser_peek_token (parser
)->location
;
5107 c_parser_consume_token (parser
);
5108 while (oprec
<= stack
[sp
].prec
)
5112 case TRUTH_ANDIF_EXPR
:
5114 = default_function_array_read_conversion (stack
[sp
].loc
,
5116 stack
[sp
].expr
.value
= c_objc_common_truthvalue_conversion
5117 (stack
[sp
].loc
, default_conversion (stack
[sp
].expr
.value
));
5118 c_inhibit_evaluation_warnings
+= (stack
[sp
].expr
.value
5119 == truthvalue_false_node
);
5121 case TRUTH_ORIF_EXPR
:
5123 = default_function_array_read_conversion (stack
[sp
].loc
,
5125 stack
[sp
].expr
.value
= c_objc_common_truthvalue_conversion
5126 (stack
[sp
].loc
, default_conversion (stack
[sp
].expr
.value
));
5127 c_inhibit_evaluation_warnings
+= (stack
[sp
].expr
.value
5128 == truthvalue_true_node
);
5134 stack
[sp
].loc
= binary_loc
;
5135 stack
[sp
].expr
= c_parser_cast_expression (parser
, NULL
);
5136 stack
[sp
].prec
= oprec
;
5137 stack
[sp
].op
= ocode
;
5138 stack
[sp
].loc
= binary_loc
;
5143 return stack
[0].expr
;
5147 /* Parse a cast expression (C90 6.3.4, C99 6.5.4). If AFTER is not
5148 NULL then it is an Objective-C message expression which is the
5149 primary-expression starting the expression as an initializer.
5153 ( type-name ) unary-expression
5156 static struct c_expr
5157 c_parser_cast_expression (c_parser
*parser
, struct c_expr
*after
)
5159 location_t cast_loc
= c_parser_peek_token (parser
)->location
;
5160 gcc_assert (!after
|| c_dialect_objc ());
5162 return c_parser_postfix_expression_after_primary (parser
,
5164 /* If the expression begins with a parenthesized type name, it may
5165 be either a cast or a compound literal; we need to see whether
5166 the next character is '{' to tell the difference. If not, it is
5167 an unary expression. */
5168 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
)
5169 && c_token_starts_typename (c_parser_peek_2nd_token (parser
)))
5171 struct c_type_name
*type_name
;
5174 c_parser_consume_token (parser
);
5175 type_name
= c_parser_type_name (parser
);
5176 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
5177 if (type_name
== NULL
)
5179 ret
.value
= error_mark_node
;
5180 ret
.original_code
= ERROR_MARK
;
5181 ret
.original_type
= NULL
;
5185 /* Save casted types in the function's used types hash table. */
5186 used_types_insert (type_name
->specs
->type
);
5188 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
5189 return c_parser_postfix_expression_after_paren_type (parser
, type_name
,
5192 location_t expr_loc
= c_parser_peek_token (parser
)->location
;
5193 expr
= c_parser_cast_expression (parser
, NULL
);
5194 expr
= default_function_array_read_conversion (expr_loc
, expr
);
5196 ret
.value
= c_cast_expr (cast_loc
, type_name
, expr
.value
);
5197 ret
.original_code
= ERROR_MARK
;
5198 ret
.original_type
= NULL
;
5202 return c_parser_unary_expression (parser
);
5205 /* Parse an unary expression (C90 6.3.3, C99 6.5.3).
5211 unary-operator cast-expression
5212 sizeof unary-expression
5213 sizeof ( type-name )
5215 unary-operator: one of
5221 __alignof__ unary-expression
5222 __alignof__ ( type-name )
5225 unary-operator: one of
5226 __extension__ __real__ __imag__
5228 In addition, the GNU syntax treats ++ and -- as unary operators, so
5229 they may be applied to cast expressions with errors for non-lvalues
5232 static struct c_expr
5233 c_parser_unary_expression (c_parser
*parser
)
5236 struct c_expr ret
, op
;
5237 location_t op_loc
= c_parser_peek_token (parser
)->location
;
5239 ret
.original_code
= ERROR_MARK
;
5240 ret
.original_type
= NULL
;
5241 switch (c_parser_peek_token (parser
)->type
)
5244 c_parser_consume_token (parser
);
5245 exp_loc
= c_parser_peek_token (parser
)->location
;
5246 op
= c_parser_cast_expression (parser
, NULL
);
5247 op
= default_function_array_read_conversion (exp_loc
, op
);
5248 return parser_build_unary_op (op_loc
, PREINCREMENT_EXPR
, op
);
5249 case CPP_MINUS_MINUS
:
5250 c_parser_consume_token (parser
);
5251 exp_loc
= c_parser_peek_token (parser
)->location
;
5252 op
= c_parser_cast_expression (parser
, NULL
);
5253 op
= default_function_array_read_conversion (exp_loc
, op
);
5254 return parser_build_unary_op (op_loc
, PREDECREMENT_EXPR
, op
);
5256 c_parser_consume_token (parser
);
5257 op
= c_parser_cast_expression (parser
, NULL
);
5258 mark_exp_read (op
.value
);
5259 return parser_build_unary_op (op_loc
, ADDR_EXPR
, op
);
5261 c_parser_consume_token (parser
);
5262 exp_loc
= c_parser_peek_token (parser
)->location
;
5263 op
= c_parser_cast_expression (parser
, NULL
);
5264 op
= default_function_array_read_conversion (exp_loc
, op
);
5265 ret
.value
= build_indirect_ref (op_loc
, op
.value
, RO_UNARY_STAR
);
5268 if (!c_dialect_objc () && !in_system_header
)
5271 "traditional C rejects the unary plus operator");
5272 c_parser_consume_token (parser
);
5273 exp_loc
= c_parser_peek_token (parser
)->location
;
5274 op
= c_parser_cast_expression (parser
, NULL
);
5275 op
= default_function_array_read_conversion (exp_loc
, op
);
5276 return parser_build_unary_op (op_loc
, CONVERT_EXPR
, op
);
5278 c_parser_consume_token (parser
);
5279 exp_loc
= c_parser_peek_token (parser
)->location
;
5280 op
= c_parser_cast_expression (parser
, NULL
);
5281 op
= default_function_array_read_conversion (exp_loc
, op
);
5282 return parser_build_unary_op (op_loc
, NEGATE_EXPR
, op
);
5284 c_parser_consume_token (parser
);
5285 exp_loc
= c_parser_peek_token (parser
)->location
;
5286 op
= c_parser_cast_expression (parser
, NULL
);
5287 op
= default_function_array_read_conversion (exp_loc
, op
);
5288 return parser_build_unary_op (op_loc
, BIT_NOT_EXPR
, op
);
5290 c_parser_consume_token (parser
);
5291 exp_loc
= c_parser_peek_token (parser
)->location
;
5292 op
= c_parser_cast_expression (parser
, NULL
);
5293 op
= default_function_array_read_conversion (exp_loc
, op
);
5294 return parser_build_unary_op (op_loc
, TRUTH_NOT_EXPR
, op
);
5296 /* Refer to the address of a label as a pointer. */
5297 c_parser_consume_token (parser
);
5298 if (c_parser_next_token_is (parser
, CPP_NAME
))
5300 ret
.value
= finish_label_address_expr
5301 (c_parser_peek_token (parser
)->value
, op_loc
);
5302 c_parser_consume_token (parser
);
5306 c_parser_error (parser
, "expected identifier");
5307 ret
.value
= error_mark_node
;
5311 switch (c_parser_peek_token (parser
)->keyword
)
5314 return c_parser_sizeof_expression (parser
);
5316 return c_parser_alignof_expression (parser
);
5318 c_parser_consume_token (parser
);
5319 ext
= disable_extension_diagnostics ();
5320 ret
= c_parser_cast_expression (parser
, NULL
);
5321 restore_extension_diagnostics (ext
);
5324 c_parser_consume_token (parser
);
5325 exp_loc
= c_parser_peek_token (parser
)->location
;
5326 op
= c_parser_cast_expression (parser
, NULL
);
5327 op
= default_function_array_conversion (exp_loc
, op
);
5328 return parser_build_unary_op (op_loc
, REALPART_EXPR
, op
);
5330 c_parser_consume_token (parser
);
5331 exp_loc
= c_parser_peek_token (parser
)->location
;
5332 op
= c_parser_cast_expression (parser
, NULL
);
5333 op
= default_function_array_conversion (exp_loc
, op
);
5334 return parser_build_unary_op (op_loc
, IMAGPART_EXPR
, op
);
5336 return c_parser_postfix_expression (parser
);
5339 return c_parser_postfix_expression (parser
);
5343 /* Parse a sizeof expression. */
5345 static struct c_expr
5346 c_parser_sizeof_expression (c_parser
*parser
)
5349 location_t expr_loc
;
5350 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_SIZEOF
));
5351 c_parser_consume_token (parser
);
5352 c_inhibit_evaluation_warnings
++;
5354 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
)
5355 && c_token_starts_typename (c_parser_peek_2nd_token (parser
)))
5357 /* Either sizeof ( type-name ) or sizeof unary-expression
5358 starting with a compound literal. */
5359 struct c_type_name
*type_name
;
5360 c_parser_consume_token (parser
);
5361 expr_loc
= c_parser_peek_token (parser
)->location
;
5362 type_name
= c_parser_type_name (parser
);
5363 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
5364 if (type_name
== NULL
)
5367 c_inhibit_evaluation_warnings
--;
5369 ret
.value
= error_mark_node
;
5370 ret
.original_code
= ERROR_MARK
;
5371 ret
.original_type
= NULL
;
5374 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
5376 expr
= c_parser_postfix_expression_after_paren_type (parser
,
5381 /* sizeof ( type-name ). */
5382 c_inhibit_evaluation_warnings
--;
5384 return c_expr_sizeof_type (expr_loc
, type_name
);
5388 expr_loc
= c_parser_peek_token (parser
)->location
;
5389 expr
= c_parser_unary_expression (parser
);
5391 c_inhibit_evaluation_warnings
--;
5393 mark_exp_read (expr
.value
);
5394 if (TREE_CODE (expr
.value
) == COMPONENT_REF
5395 && DECL_C_BIT_FIELD (TREE_OPERAND (expr
.value
, 1)))
5396 error_at (expr_loc
, "%<sizeof%> applied to a bit-field");
5397 return c_expr_sizeof_expr (expr_loc
, expr
);
5401 /* Parse an alignof expression. */
5403 static struct c_expr
5404 c_parser_alignof_expression (c_parser
*parser
)
5407 location_t loc
= c_parser_peek_token (parser
)->location
;
5408 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_ALIGNOF
));
5409 c_parser_consume_token (parser
);
5410 c_inhibit_evaluation_warnings
++;
5412 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
)
5413 && c_token_starts_typename (c_parser_peek_2nd_token (parser
)))
5415 /* Either __alignof__ ( type-name ) or __alignof__
5416 unary-expression starting with a compound literal. */
5418 struct c_type_name
*type_name
;
5420 c_parser_consume_token (parser
);
5421 loc
= c_parser_peek_token (parser
)->location
;
5422 type_name
= c_parser_type_name (parser
);
5423 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
5424 if (type_name
== NULL
)
5427 c_inhibit_evaluation_warnings
--;
5429 ret
.value
= error_mark_node
;
5430 ret
.original_code
= ERROR_MARK
;
5431 ret
.original_type
= NULL
;
5434 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
5436 expr
= c_parser_postfix_expression_after_paren_type (parser
,
5441 /* alignof ( type-name ). */
5442 c_inhibit_evaluation_warnings
--;
5444 ret
.value
= c_alignof (loc
, groktypename (type_name
, NULL
, NULL
));
5445 ret
.original_code
= ERROR_MARK
;
5446 ret
.original_type
= NULL
;
5452 expr
= c_parser_unary_expression (parser
);
5454 mark_exp_read (expr
.value
);
5455 c_inhibit_evaluation_warnings
--;
5457 ret
.value
= c_alignof_expr (loc
, expr
.value
);
5458 ret
.original_code
= ERROR_MARK
;
5459 ret
.original_type
= NULL
;
5464 /* Parse a postfix expression (C90 6.3.1-6.3.2, C99 6.5.1-6.5.2).
5468 postfix-expression [ expression ]
5469 postfix-expression ( argument-expression-list[opt] )
5470 postfix-expression . identifier
5471 postfix-expression -> identifier
5472 postfix-expression ++
5473 postfix-expression --
5474 ( type-name ) { initializer-list }
5475 ( type-name ) { initializer-list , }
5477 argument-expression-list:
5479 argument-expression-list , argument-expression
5491 (treated as a keyword in GNU C)
5494 ( compound-statement )
5495 __builtin_va_arg ( assignment-expression , type-name )
5496 __builtin_offsetof ( type-name , offsetof-member-designator )
5497 __builtin_choose_expr ( assignment-expression ,
5498 assignment-expression ,
5499 assignment-expression )
5500 __builtin_types_compatible_p ( type-name , type-name )
5502 offsetof-member-designator:
5504 offsetof-member-designator . identifier
5505 offsetof-member-designator [ expression ]
5510 [ objc-receiver objc-message-args ]
5511 @selector ( objc-selector-arg )
5512 @protocol ( identifier )
5513 @encode ( type-name )
5517 static struct c_expr
5518 c_parser_postfix_expression (c_parser
*parser
)
5520 struct c_expr expr
, e1
, e2
, e3
;
5521 struct c_type_name
*t1
, *t2
;
5522 location_t loc
= c_parser_peek_token (parser
)->location
;;
5523 expr
.original_code
= ERROR_MARK
;
5524 expr
.original_type
= NULL
;
5525 switch (c_parser_peek_token (parser
)->type
)
5528 expr
.value
= c_parser_peek_token (parser
)->value
;
5529 loc
= c_parser_peek_token (parser
)->location
;
5530 c_parser_consume_token (parser
);
5531 if (TREE_CODE (expr
.value
) == FIXED_CST
5532 && !targetm
.fixed_point_supported_p ())
5534 error_at (loc
, "fixed-point types not supported for this target");
5535 expr
.value
= error_mark_node
;
5542 expr
.value
= c_parser_peek_token (parser
)->value
;
5543 c_parser_consume_token (parser
);
5549 case CPP_UTF8STRING
:
5550 expr
.value
= c_parser_peek_token (parser
)->value
;
5551 expr
.original_code
= STRING_CST
;
5552 c_parser_consume_token (parser
);
5554 case CPP_OBJC_STRING
:
5555 gcc_assert (c_dialect_objc ());
5557 = objc_build_string_object (c_parser_peek_token (parser
)->value
);
5558 c_parser_consume_token (parser
);
5561 if (c_parser_peek_token (parser
)->id_kind
!= C_ID_ID
)
5563 c_parser_error (parser
, "expected expression");
5564 expr
.value
= error_mark_node
;
5568 tree id
= c_parser_peek_token (parser
)->value
;
5569 c_parser_consume_token (parser
);
5570 expr
.value
= build_external_ref (loc
, id
,
5571 (c_parser_peek_token (parser
)->type
5573 &expr
.original_type
);
5576 case CPP_OPEN_PAREN
:
5577 /* A parenthesized expression, statement expression or compound
5579 if (c_parser_peek_2nd_token (parser
)->type
== CPP_OPEN_BRACE
)
5581 /* A statement expression. */
5583 location_t brace_loc
;
5584 c_parser_consume_token (parser
);
5585 brace_loc
= c_parser_peek_token (parser
)->location
;
5586 c_parser_consume_token (parser
);
5587 if (cur_stmt_list
== NULL
)
5589 error_at (loc
, "braced-group within expression allowed "
5590 "only inside a function");
5591 parser
->error
= true;
5592 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
, NULL
);
5593 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5594 expr
.value
= error_mark_node
;
5597 stmt
= c_begin_stmt_expr ();
5598 c_parser_compound_statement_nostart (parser
);
5599 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5601 pedwarn (loc
, OPT_pedantic
,
5602 "ISO C forbids braced-groups within expressions");
5603 expr
.value
= c_finish_stmt_expr (brace_loc
, stmt
);
5604 mark_exp_read (expr
.value
);
5606 else if (c_token_starts_typename (c_parser_peek_2nd_token (parser
)))
5608 /* A compound literal. ??? Can we actually get here rather
5609 than going directly to
5610 c_parser_postfix_expression_after_paren_type from
5613 struct c_type_name
*type_name
;
5614 c_parser_consume_token (parser
);
5615 loc
= c_parser_peek_token (parser
)->location
;
5616 type_name
= c_parser_type_name (parser
);
5617 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5619 if (type_name
== NULL
)
5621 expr
.value
= error_mark_node
;
5624 expr
= c_parser_postfix_expression_after_paren_type (parser
,
5630 /* A parenthesized expression. */
5631 c_parser_consume_token (parser
);
5632 expr
= c_parser_expression (parser
);
5633 if (TREE_CODE (expr
.value
) == MODIFY_EXPR
)
5634 TREE_NO_WARNING (expr
.value
) = 1;
5635 if (expr
.original_code
!= C_MAYBE_CONST_EXPR
)
5636 expr
.original_code
= ERROR_MARK
;
5637 /* Don't change EXPR.ORIGINAL_TYPE. */
5638 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5643 switch (c_parser_peek_token (parser
)->keyword
)
5645 case RID_FUNCTION_NAME
:
5646 case RID_PRETTY_FUNCTION_NAME
:
5647 case RID_C99_FUNCTION_NAME
:
5648 expr
.value
= fname_decl (loc
,
5649 c_parser_peek_token (parser
)->keyword
,
5650 c_parser_peek_token (parser
)->value
);
5651 c_parser_consume_token (parser
);
5654 c_parser_consume_token (parser
);
5655 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
5657 expr
.value
= error_mark_node
;
5660 e1
= c_parser_expr_no_commas (parser
, NULL
);
5661 mark_exp_read (e1
.value
);
5662 e1
.value
= c_fully_fold (e1
.value
, false, NULL
);
5663 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
5665 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5666 expr
.value
= error_mark_node
;
5669 loc
= c_parser_peek_token (parser
)->location
;
5670 t1
= c_parser_type_name (parser
);
5671 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5675 expr
.value
= error_mark_node
;
5679 tree type_expr
= NULL_TREE
;
5680 expr
.value
= c_build_va_arg (loc
, e1
.value
,
5681 groktypename (t1
, &type_expr
, NULL
));
5684 expr
.value
= build2 (C_MAYBE_CONST_EXPR
,
5685 TREE_TYPE (expr
.value
), type_expr
,
5687 C_MAYBE_CONST_EXPR_NON_CONST (expr
.value
) = true;
5692 c_parser_consume_token (parser
);
5693 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
5695 expr
.value
= error_mark_node
;
5698 t1
= c_parser_type_name (parser
);
5701 expr
.value
= error_mark_node
;
5704 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
5706 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5707 expr
.value
= error_mark_node
;
5711 tree type
= groktypename (t1
, NULL
, NULL
);
5713 if (type
== error_mark_node
)
5714 offsetof_ref
= error_mark_node
;
5717 offsetof_ref
= build1 (INDIRECT_REF
, type
, null_pointer_node
);
5718 SET_EXPR_LOCATION (offsetof_ref
, loc
);
5720 /* Parse the second argument to __builtin_offsetof. We
5721 must have one identifier, and beyond that we want to
5722 accept sub structure and sub array references. */
5723 if (c_parser_next_token_is (parser
, CPP_NAME
))
5725 offsetof_ref
= build_component_ref
5726 (loc
, offsetof_ref
, c_parser_peek_token (parser
)->value
);
5727 c_parser_consume_token (parser
);
5728 while (c_parser_next_token_is (parser
, CPP_DOT
)
5729 || c_parser_next_token_is (parser
,
5731 || c_parser_next_token_is (parser
,
5734 if (c_parser_next_token_is (parser
, CPP_DEREF
))
5736 loc
= c_parser_peek_token (parser
)->location
;
5737 offsetof_ref
= build_array_ref (loc
,
5742 else if (c_parser_next_token_is (parser
, CPP_DOT
))
5745 c_parser_consume_token (parser
);
5746 if (c_parser_next_token_is_not (parser
,
5749 c_parser_error (parser
, "expected identifier");
5752 offsetof_ref
= build_component_ref
5754 c_parser_peek_token (parser
)->value
);
5755 c_parser_consume_token (parser
);
5760 loc
= c_parser_peek_token (parser
)->location
;
5761 c_parser_consume_token (parser
);
5762 idx
= c_parser_expression (parser
).value
;
5763 idx
= c_fully_fold (idx
, false, NULL
);
5764 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
5766 offsetof_ref
= build_array_ref (loc
, offsetof_ref
, idx
);
5771 c_parser_error (parser
, "expected identifier");
5772 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5774 expr
.value
= fold_offsetof (offsetof_ref
, NULL_TREE
);
5777 case RID_CHOOSE_EXPR
:
5778 c_parser_consume_token (parser
);
5779 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
5781 expr
.value
= error_mark_node
;
5784 loc
= c_parser_peek_token (parser
)->location
;
5785 e1
= c_parser_expr_no_commas (parser
, NULL
);
5786 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
5788 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5789 expr
.value
= error_mark_node
;
5792 e2
= c_parser_expr_no_commas (parser
, NULL
);
5793 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
5795 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5796 expr
.value
= error_mark_node
;
5799 e3
= c_parser_expr_no_commas (parser
, NULL
);
5800 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5806 mark_exp_read (e2
.value
);
5807 mark_exp_read (e3
.value
);
5808 if (TREE_CODE (c
) != INTEGER_CST
5809 || !INTEGRAL_TYPE_P (TREE_TYPE (c
)))
5811 "first argument to %<__builtin_choose_expr%> not"
5813 constant_expression_warning (c
);
5814 expr
= integer_zerop (c
) ? e3
: e2
;
5817 case RID_TYPES_COMPATIBLE_P
:
5818 c_parser_consume_token (parser
);
5819 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
5821 expr
.value
= error_mark_node
;
5824 t1
= c_parser_type_name (parser
);
5827 expr
.value
= error_mark_node
;
5830 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
5832 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5833 expr
.value
= error_mark_node
;
5836 t2
= c_parser_type_name (parser
);
5839 expr
.value
= error_mark_node
;
5842 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5847 e1
= TYPE_MAIN_VARIANT (groktypename (t1
, NULL
, NULL
));
5848 e2
= TYPE_MAIN_VARIANT (groktypename (t2
, NULL
, NULL
));
5850 expr
.value
= comptypes (e1
, e2
)
5851 ? build_int_cst (NULL_TREE
, 1)
5852 : build_int_cst (NULL_TREE
, 0);
5855 case RID_AT_SELECTOR
:
5856 gcc_assert (c_dialect_objc ());
5857 c_parser_consume_token (parser
);
5858 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
5860 expr
.value
= error_mark_node
;
5864 tree sel
= c_parser_objc_selector_arg (parser
);
5865 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5867 expr
.value
= objc_build_selector_expr (loc
, sel
);
5870 case RID_AT_PROTOCOL
:
5871 gcc_assert (c_dialect_objc ());
5872 c_parser_consume_token (parser
);
5873 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
5875 expr
.value
= error_mark_node
;
5878 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5880 c_parser_error (parser
, "expected identifier");
5881 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5882 expr
.value
= error_mark_node
;
5886 tree id
= c_parser_peek_token (parser
)->value
;
5887 c_parser_consume_token (parser
);
5888 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5890 expr
.value
= objc_build_protocol_expr (id
);
5894 /* Extension to support C-structures in the archiver. */
5895 gcc_assert (c_dialect_objc ());
5896 c_parser_consume_token (parser
);
5897 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
5899 expr
.value
= error_mark_node
;
5902 t1
= c_parser_type_name (parser
);
5905 expr
.value
= error_mark_node
;
5906 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5909 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5912 tree type
= groktypename (t1
, NULL
, NULL
);
5913 expr
.value
= objc_build_encode_expr (type
);
5917 c_parser_error (parser
, "expected expression");
5918 expr
.value
= error_mark_node
;
5922 case CPP_OPEN_SQUARE
:
5923 if (c_dialect_objc ())
5925 tree receiver
, args
;
5926 c_parser_consume_token (parser
);
5927 receiver
= c_parser_objc_receiver (parser
);
5928 args
= c_parser_objc_message_args (parser
);
5929 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
5931 expr
.value
= objc_build_message_expr (build_tree_list (receiver
,
5935 /* Else fall through to report error. */
5937 c_parser_error (parser
, "expected expression");
5938 expr
.value
= error_mark_node
;
5941 return c_parser_postfix_expression_after_primary (parser
, loc
, expr
);
5944 /* Parse a postfix expression after a parenthesized type name: the
5945 brace-enclosed initializer of a compound literal, possibly followed
5946 by some postfix operators. This is separate because it is not
5947 possible to tell until after the type name whether a cast
5948 expression has a cast or a compound literal, or whether the operand
5949 of sizeof is a parenthesized type name or starts with a compound
5950 literal. TYPE_LOC is the location where TYPE_NAME starts--the
5951 location of the first token after the parentheses around the type
5954 static struct c_expr
5955 c_parser_postfix_expression_after_paren_type (c_parser
*parser
,
5956 struct c_type_name
*type_name
,
5957 location_t type_loc
)
5963 location_t start_loc
;
5964 tree type_expr
= NULL_TREE
;
5965 bool type_expr_const
= true;
5966 check_compound_literal_type (type_loc
, type_name
);
5967 start_init (NULL_TREE
, NULL
, 0);
5968 type
= groktypename (type_name
, &type_expr
, &type_expr_const
);
5969 start_loc
= c_parser_peek_token (parser
)->location
;
5970 if (type
!= error_mark_node
&& C_TYPE_VARIABLE_SIZE (type
))
5972 error_at (type_loc
, "compound literal has variable size");
5973 type
= error_mark_node
;
5975 init
= c_parser_braced_init (parser
, type
, false);
5977 maybe_warn_string_init (type
, init
);
5979 if (type
!= error_mark_node
5980 && !ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (type
))
5981 && current_function_decl
)
5983 error ("compound literal qualified by address-space qualifier");
5984 type
= error_mark_node
;
5988 pedwarn (start_loc
, OPT_pedantic
, "ISO C90 forbids compound literals");
5989 non_const
= ((init
.value
&& TREE_CODE (init
.value
) == CONSTRUCTOR
)
5990 ? CONSTRUCTOR_NON_CONST (init
.value
)
5991 : init
.original_code
== C_MAYBE_CONST_EXPR
);
5992 non_const
|= !type_expr_const
;
5993 expr
.value
= build_compound_literal (start_loc
, type
, init
.value
, non_const
);
5994 expr
.original_code
= ERROR_MARK
;
5995 expr
.original_type
= NULL
;
5998 if (TREE_CODE (expr
.value
) == C_MAYBE_CONST_EXPR
)
6000 gcc_assert (C_MAYBE_CONST_EXPR_PRE (expr
.value
) == NULL_TREE
);
6001 C_MAYBE_CONST_EXPR_PRE (expr
.value
) = type_expr
;
6005 gcc_assert (!non_const
);
6006 expr
.value
= build2 (C_MAYBE_CONST_EXPR
, type
,
6007 type_expr
, expr
.value
);
6010 return c_parser_postfix_expression_after_primary (parser
, start_loc
, expr
);
6013 /* Parse a postfix expression after the initial primary or compound
6014 literal; that is, parse a series of postfix operators.
6016 EXPR_LOC is the location of the primary expression. */
6018 static struct c_expr
6019 c_parser_postfix_expression_after_primary (c_parser
*parser
,
6020 location_t expr_loc
,
6023 struct c_expr orig_expr
;
6025 VEC(tree
,gc
) *exprlist
;
6026 VEC(tree
,gc
) *origtypes
;
6029 location_t op_loc
= c_parser_peek_token (parser
)->location
;
6030 switch (c_parser_peek_token (parser
)->type
)
6032 case CPP_OPEN_SQUARE
:
6033 /* Array reference. */
6034 c_parser_consume_token (parser
);
6035 idx
= c_parser_expression (parser
).value
;
6036 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
6038 expr
.value
= build_array_ref (op_loc
, expr
.value
, idx
);
6039 expr
.original_code
= ERROR_MARK
;
6040 expr
.original_type
= NULL
;
6042 case CPP_OPEN_PAREN
:
6043 /* Function call. */
6044 c_parser_consume_token (parser
);
6045 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
6048 exprlist
= c_parser_expr_list (parser
, true, false, &origtypes
);
6049 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
6052 mark_exp_read (expr
.value
);
6053 /* FIXME diagnostics: Ideally we want the FUNCNAME, not the
6054 "(" after the FUNCNAME, which is what we have now. */
6055 expr
.value
= build_function_call_vec (op_loc
, expr
.value
, exprlist
,
6057 expr
.original_code
= ERROR_MARK
;
6058 if (TREE_CODE (expr
.value
) == INTEGER_CST
6059 && TREE_CODE (orig_expr
.value
) == FUNCTION_DECL
6060 && DECL_BUILT_IN_CLASS (orig_expr
.value
) == BUILT_IN_NORMAL
6061 && DECL_FUNCTION_CODE (orig_expr
.value
) == BUILT_IN_CONSTANT_P
)
6062 expr
.original_code
= C_MAYBE_CONST_EXPR
;
6063 expr
.original_type
= NULL
;
6064 if (exprlist
!= NULL
)
6066 release_tree_vector (exprlist
);
6067 release_tree_vector (origtypes
);
6071 /* Structure element reference. */
6072 c_parser_consume_token (parser
);
6073 expr
= default_function_array_conversion (expr_loc
, expr
);
6074 if (c_parser_next_token_is (parser
, CPP_NAME
))
6075 ident
= c_parser_peek_token (parser
)->value
;
6078 c_parser_error (parser
, "expected identifier");
6079 expr
.value
= error_mark_node
;
6080 expr
.original_code
= ERROR_MARK
;
6081 expr
.original_type
= NULL
;
6084 c_parser_consume_token (parser
);
6085 expr
.value
= build_component_ref (op_loc
, expr
.value
, ident
);
6086 expr
.original_code
= ERROR_MARK
;
6087 if (TREE_CODE (expr
.value
) != COMPONENT_REF
)
6088 expr
.original_type
= NULL
;
6091 /* Remember the original type of a bitfield. */
6092 tree field
= TREE_OPERAND (expr
.value
, 1);
6093 if (TREE_CODE (field
) != FIELD_DECL
)
6094 expr
.original_type
= NULL
;
6096 expr
.original_type
= DECL_BIT_FIELD_TYPE (field
);
6100 /* Structure element reference. */
6101 c_parser_consume_token (parser
);
6102 expr
= default_function_array_conversion (expr_loc
, expr
);
6103 if (c_parser_next_token_is (parser
, CPP_NAME
))
6104 ident
= c_parser_peek_token (parser
)->value
;
6107 c_parser_error (parser
, "expected identifier");
6108 expr
.value
= error_mark_node
;
6109 expr
.original_code
= ERROR_MARK
;
6110 expr
.original_type
= NULL
;
6113 c_parser_consume_token (parser
);
6114 expr
.value
= build_component_ref (op_loc
,
6115 build_indirect_ref (op_loc
,
6119 expr
.original_code
= ERROR_MARK
;
6120 if (TREE_CODE (expr
.value
) != COMPONENT_REF
)
6121 expr
.original_type
= NULL
;
6124 /* Remember the original type of a bitfield. */
6125 tree field
= TREE_OPERAND (expr
.value
, 1);
6126 if (TREE_CODE (field
) != FIELD_DECL
)
6127 expr
.original_type
= NULL
;
6129 expr
.original_type
= DECL_BIT_FIELD_TYPE (field
);
6133 /* Postincrement. */
6134 c_parser_consume_token (parser
);
6135 expr
= default_function_array_read_conversion (expr_loc
, expr
);
6136 expr
.value
= build_unary_op (op_loc
,
6137 POSTINCREMENT_EXPR
, expr
.value
, 0);
6138 expr
.original_code
= ERROR_MARK
;
6139 expr
.original_type
= NULL
;
6141 case CPP_MINUS_MINUS
:
6142 /* Postdecrement. */
6143 c_parser_consume_token (parser
);
6144 expr
= default_function_array_read_conversion (expr_loc
, expr
);
6145 expr
.value
= build_unary_op (op_loc
,
6146 POSTDECREMENT_EXPR
, expr
.value
, 0);
6147 expr
.original_code
= ERROR_MARK
;
6148 expr
.original_type
= NULL
;
6156 /* Parse an expression (C90 6.3.17, C99 6.5.17).
6159 assignment-expression
6160 expression , assignment-expression
6163 static struct c_expr
6164 c_parser_expression (c_parser
*parser
)
6167 expr
= c_parser_expr_no_commas (parser
, NULL
);
6168 while (c_parser_next_token_is (parser
, CPP_COMMA
))
6172 location_t loc
= c_parser_peek_token (parser
)->location
;
6173 location_t expr_loc
;
6174 c_parser_consume_token (parser
);
6175 expr_loc
= c_parser_peek_token (parser
)->location
;
6176 lhsval
= expr
.value
;
6177 while (TREE_CODE (lhsval
) == COMPOUND_EXPR
)
6178 lhsval
= TREE_OPERAND (lhsval
, 1);
6179 if (DECL_P (lhsval
) || handled_component_p (lhsval
))
6180 mark_exp_read (lhsval
);
6181 next
= c_parser_expr_no_commas (parser
, NULL
);
6182 next
= default_function_array_conversion (expr_loc
, next
);
6183 expr
.value
= build_compound_expr (loc
, expr
.value
, next
.value
);
6184 expr
.original_code
= COMPOUND_EXPR
;
6185 expr
.original_type
= next
.original_type
;
6190 /* Parse an expression and convert functions or arrays to
6193 static struct c_expr
6194 c_parser_expression_conv (c_parser
*parser
)
6197 location_t loc
= c_parser_peek_token (parser
)->location
;
6198 expr
= c_parser_expression (parser
);
6199 expr
= default_function_array_conversion (loc
, expr
);
6203 /* Parse a non-empty list of expressions. If CONVERT_P, convert
6204 functions and arrays to pointers. If FOLD_P, fold the expressions.
6207 assignment-expression
6208 nonempty-expr-list , assignment-expression
6211 static VEC(tree
,gc
) *
6212 c_parser_expr_list (c_parser
*parser
, bool convert_p
, bool fold_p
,
6213 VEC(tree
,gc
) **p_orig_types
)
6216 VEC(tree
,gc
) *orig_types
;
6218 location_t loc
= c_parser_peek_token (parser
)->location
;
6220 ret
= make_tree_vector ();
6221 if (p_orig_types
== NULL
)
6224 orig_types
= make_tree_vector ();
6226 expr
= c_parser_expr_no_commas (parser
, NULL
);
6228 expr
= default_function_array_read_conversion (loc
, expr
);
6230 expr
.value
= c_fully_fold (expr
.value
, false, NULL
);
6231 VEC_quick_push (tree
, ret
, expr
.value
);
6232 if (orig_types
!= NULL
)
6233 VEC_quick_push (tree
, orig_types
, expr
.original_type
);
6234 while (c_parser_next_token_is (parser
, CPP_COMMA
))
6236 c_parser_consume_token (parser
);
6237 loc
= c_parser_peek_token (parser
)->location
;
6238 expr
= c_parser_expr_no_commas (parser
, NULL
);
6240 expr
= default_function_array_read_conversion (loc
, expr
);
6242 expr
.value
= c_fully_fold (expr
.value
, false, NULL
);
6243 VEC_safe_push (tree
, gc
, ret
, expr
.value
);
6244 if (orig_types
!= NULL
)
6245 VEC_safe_push (tree
, gc
, orig_types
, expr
.original_type
);
6247 if (orig_types
!= NULL
)
6248 *p_orig_types
= orig_types
;
6252 /* Parse Objective-C-specific constructs. */
6254 /* Parse an objc-class-definition.
6256 objc-class-definition:
6257 @interface identifier objc-superclass[opt] objc-protocol-refs[opt]
6258 objc-class-instance-variables[opt] objc-methodprotolist @end
6259 @implementation identifier objc-superclass[opt]
6260 objc-class-instance-variables[opt]
6261 @interface identifier ( identifier ) objc-protocol-refs[opt]
6262 objc-methodprotolist @end
6263 @implementation identifier ( identifier )
6268 "@interface identifier (" must start "@interface identifier (
6269 identifier ) ...": objc-methodprotolist in the first production may
6270 not start with a parenthesized identifier as a declarator of a data
6271 definition with no declaration specifiers if the objc-superclass,
6272 objc-protocol-refs and objc-class-instance-variables are omitted. */
6275 c_parser_objc_class_definition (c_parser
*parser
)
6280 if (c_parser_next_token_is_keyword (parser
, RID_AT_INTERFACE
))
6282 else if (c_parser_next_token_is_keyword (parser
, RID_AT_IMPLEMENTATION
))
6286 c_parser_consume_token (parser
);
6287 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
6289 c_parser_error (parser
, "expected identifier");
6292 id1
= c_parser_peek_token (parser
)->value
;
6293 c_parser_consume_token (parser
);
6294 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
6297 tree proto
= NULL_TREE
;
6298 c_parser_consume_token (parser
);
6299 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
6301 c_parser_error (parser
, "expected identifier");
6302 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
6305 id2
= c_parser_peek_token (parser
)->value
;
6306 c_parser_consume_token (parser
);
6307 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
6310 objc_start_category_implementation (id1
, id2
);
6313 if (c_parser_next_token_is (parser
, CPP_LESS
))
6314 proto
= c_parser_objc_protocol_refs (parser
);
6315 objc_start_category_interface (id1
, id2
, proto
);
6316 c_parser_objc_methodprotolist (parser
);
6317 c_parser_require_keyword (parser
, RID_AT_END
, "expected %<@end%>");
6318 objc_finish_interface ();
6321 if (c_parser_next_token_is (parser
, CPP_COLON
))
6323 c_parser_consume_token (parser
);
6324 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
6326 c_parser_error (parser
, "expected identifier");
6329 superclass
= c_parser_peek_token (parser
)->value
;
6330 c_parser_consume_token (parser
);
6333 superclass
= NULL_TREE
;
6336 tree proto
= NULL_TREE
;
6337 if (c_parser_next_token_is (parser
, CPP_LESS
))
6338 proto
= c_parser_objc_protocol_refs (parser
);
6339 objc_start_class_interface (id1
, superclass
, proto
);
6342 objc_start_class_implementation (id1
, superclass
);
6343 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
6344 c_parser_objc_class_instance_variables (parser
);
6347 objc_continue_interface ();
6348 c_parser_objc_methodprotolist (parser
);
6349 c_parser_require_keyword (parser
, RID_AT_END
, "expected %<@end%>");
6350 objc_finish_interface ();
6354 objc_continue_implementation ();
6359 /* Parse objc-class-instance-variables.
6361 objc-class-instance-variables:
6362 { objc-instance-variable-decl-list[opt] }
6364 objc-instance-variable-decl-list:
6365 objc-visibility-spec
6366 objc-instance-variable-decl ;
6368 objc-instance-variable-decl-list objc-visibility-spec
6369 objc-instance-variable-decl-list objc-instance-variable-decl ;
6370 objc-instance-variable-decl-list ;
6372 objc-visibility-spec:
6377 objc-instance-variable-decl:
6382 c_parser_objc_class_instance_variables (c_parser
*parser
)
6384 gcc_assert (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
));
6385 c_parser_consume_token (parser
);
6386 while (c_parser_next_token_is_not (parser
, CPP_EOF
))
6389 /* Parse any stray semicolon. */
6390 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
6392 pedwarn (c_parser_peek_token (parser
)->location
, OPT_pedantic
,
6393 "extra semicolon in struct or union specified");
6394 c_parser_consume_token (parser
);
6397 /* Stop if at the end of the instance variables. */
6398 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
6400 c_parser_consume_token (parser
);
6403 /* Parse any objc-visibility-spec. */
6404 if (c_parser_next_token_is_keyword (parser
, RID_PRIVATE
))
6406 c_parser_consume_token (parser
);
6407 objc_set_visibility (2);
6410 else if (c_parser_next_token_is_keyword (parser
, RID_PROTECTED
))
6412 c_parser_consume_token (parser
);
6413 objc_set_visibility (0);
6416 else if (c_parser_next_token_is_keyword (parser
, RID_PUBLIC
))
6418 c_parser_consume_token (parser
);
6419 objc_set_visibility (1);
6422 else if (c_parser_next_token_is (parser
, CPP_PRAGMA
))
6424 c_parser_pragma (parser
, pragma_external
);
6428 /* Parse some comma-separated declarations. */
6429 decls
= c_parser_struct_declaration (parser
);
6431 /* Comma-separated instance variables are chained together in
6432 reverse order; add them one by one. */
6433 tree ivar
= nreverse (decls
);
6434 for (; ivar
; ivar
= TREE_CHAIN (ivar
))
6435 objc_add_instance_variable (copy_node (ivar
));
6437 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
6441 /* Parse an objc-class-declaration.
6443 objc-class-declaration:
6444 @class identifier-list ;
6448 c_parser_objc_class_declaration (c_parser
*parser
)
6450 tree list
= NULL_TREE
;
6451 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_CLASS
));
6452 c_parser_consume_token (parser
);
6453 /* Any identifiers, including those declared as type names, are OK
6458 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
6460 c_parser_error (parser
, "expected identifier");
6463 id
= c_parser_peek_token (parser
)->value
;
6464 list
= chainon (list
, build_tree_list (NULL_TREE
, id
));
6465 c_parser_consume_token (parser
);
6466 if (c_parser_next_token_is (parser
, CPP_COMMA
))
6467 c_parser_consume_token (parser
);
6471 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
6472 objc_declare_class (list
);
6475 /* Parse an objc-alias-declaration.
6477 objc-alias-declaration:
6478 @compatibility_alias identifier identifier ;
6482 c_parser_objc_alias_declaration (c_parser
*parser
)
6485 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_AT_ALIAS
));
6486 c_parser_consume_token (parser
);
6487 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
6489 c_parser_error (parser
, "expected identifier");
6490 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, NULL
);
6493 id1
= c_parser_peek_token (parser
)->value
;
6494 c_parser_consume_token (parser
);
6495 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
6497 c_parser_error (parser
, "expected identifier");
6498 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, NULL
);
6501 id2
= c_parser_peek_token (parser
)->value
;
6502 c_parser_consume_token (parser
);
6503 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
6504 objc_declare_alias (id1
, id2
);
6507 /* Parse an objc-protocol-definition.
6509 objc-protocol-definition:
6510 @protocol identifier objc-protocol-refs[opt] objc-methodprotolist @end
6511 @protocol identifier-list ;
6513 "@protocol identifier ;" should be resolved as "@protocol
6514 identifier-list ;": objc-methodprotolist may not start with a
6515 semicolon in the first alternative if objc-protocol-refs are
6519 c_parser_objc_protocol_definition (c_parser
*parser
)
6521 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_AT_PROTOCOL
));
6522 c_parser_consume_token (parser
);
6523 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
6525 c_parser_error (parser
, "expected identifier");
6528 if (c_parser_peek_2nd_token (parser
)->type
== CPP_COMMA
6529 || c_parser_peek_2nd_token (parser
)->type
== CPP_SEMICOLON
)
6531 tree list
= NULL_TREE
;
6532 /* Any identifiers, including those declared as type names, are
6537 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
6539 c_parser_error (parser
, "expected identifier");
6542 id
= c_parser_peek_token (parser
)->value
;
6543 list
= chainon (list
, build_tree_list (NULL_TREE
, id
));
6544 c_parser_consume_token (parser
);
6545 if (c_parser_next_token_is (parser
, CPP_COMMA
))
6546 c_parser_consume_token (parser
);
6550 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
6551 objc_declare_protocols (list
);
6555 tree id
= c_parser_peek_token (parser
)->value
;
6556 tree proto
= NULL_TREE
;
6557 c_parser_consume_token (parser
);
6558 if (c_parser_next_token_is (parser
, CPP_LESS
))
6559 proto
= c_parser_objc_protocol_refs (parser
);
6560 parser
->objc_pq_context
= true;
6561 objc_start_protocol (id
, proto
);
6562 c_parser_objc_methodprotolist (parser
);
6563 c_parser_require_keyword (parser
, RID_AT_END
, "expected %<@end%>");
6564 parser
->objc_pq_context
= false;
6565 objc_finish_interface ();
6569 /* Parse an objc-method-type.
6576 static enum tree_code
6577 c_parser_objc_method_type (c_parser
*parser
)
6579 switch (c_parser_peek_token (parser
)->type
)
6582 c_parser_consume_token (parser
);
6585 c_parser_consume_token (parser
);
6592 /* Parse an objc-method-definition.
6594 objc-method-definition:
6595 objc-method-type objc-method-decl ;[opt] compound-statement
6599 c_parser_objc_method_definition (c_parser
*parser
)
6601 enum tree_code type
= c_parser_objc_method_type (parser
);
6603 objc_set_method_type (type
);
6604 parser
->objc_pq_context
= true;
6605 decl
= c_parser_objc_method_decl (parser
);
6606 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
6608 c_parser_consume_token (parser
);
6609 pedwarn (c_parser_peek_token (parser
)->location
, OPT_pedantic
,
6610 "extra semicolon in method definition specified");
6612 if (!c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
6614 c_parser_error (parser
, "expected %<{%>");
6617 parser
->objc_pq_context
= false;
6618 objc_start_method_definition (decl
);
6619 add_stmt (c_parser_compound_statement (parser
));
6620 objc_finish_method_definition (current_function_decl
);
6623 /* Parse an objc-methodprotolist.
6625 objc-methodprotolist:
6627 objc-methodprotolist objc-methodproto
6628 objc-methodprotolist declaration
6629 objc-methodprotolist ;
6631 The declaration is a data definition, which may be missing
6632 declaration specifiers under the same rules and diagnostics as
6633 other data definitions outside functions, and the stray semicolon
6634 is diagnosed the same way as a stray semicolon outside a
6638 c_parser_objc_methodprotolist (c_parser
*parser
)
6642 /* The list is terminated by @end. */
6643 switch (c_parser_peek_token (parser
)->type
)
6646 pedwarn (c_parser_peek_token (parser
)->location
, OPT_pedantic
,
6647 "ISO C does not allow extra %<;%> outside of a function");
6648 c_parser_consume_token (parser
);
6652 c_parser_objc_methodproto (parser
);
6655 c_parser_pragma (parser
, pragma_external
);
6660 if (c_parser_next_token_is_keyword (parser
, RID_AT_END
))
6662 c_parser_declaration_or_fndef (parser
, false, false, true,
6669 /* Parse an objc-methodproto.
6672 objc-method-type objc-method-decl ;
6676 c_parser_objc_methodproto (c_parser
*parser
)
6678 enum tree_code type
= c_parser_objc_method_type (parser
);
6680 objc_set_method_type (type
);
6681 /* Remember protocol qualifiers in prototypes. */
6682 parser
->objc_pq_context
= true;
6683 decl
= c_parser_objc_method_decl (parser
);
6684 /* Forget protocol qualifiers here. */
6685 parser
->objc_pq_context
= false;
6686 objc_add_method_declaration (decl
);
6687 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
6690 /* Parse an objc-method-decl.
6693 ( objc-type-name ) objc-selector
6695 ( objc-type-name ) objc-keyword-selector objc-optparmlist
6696 objc-keyword-selector objc-optparmlist
6698 objc-keyword-selector:
6700 objc-keyword-selector objc-keyword-decl
6703 objc-selector : ( objc-type-name ) identifier
6704 objc-selector : identifier
6705 : ( objc-type-name ) identifier
6709 objc-optparms objc-optellipsis
6713 objc-opt-parms , parameter-declaration
6721 c_parser_objc_method_decl (c_parser
*parser
)
6723 tree type
= NULL_TREE
;
6725 tree parms
= NULL_TREE
;
6726 bool ellipsis
= false;
6728 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
6730 c_parser_consume_token (parser
);
6731 type
= c_parser_objc_type_name (parser
);
6732 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
6734 sel
= c_parser_objc_selector (parser
);
6735 /* If there is no selector, or a colon follows, we have an
6736 objc-keyword-selector. If there is a selector, and a colon does
6737 not follow, that selector ends the objc-method-decl. */
6738 if (!sel
|| c_parser_next_token_is (parser
, CPP_COLON
))
6741 tree list
= NULL_TREE
;
6744 tree atype
= NULL_TREE
, id
, keyworddecl
;
6745 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
6747 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
6749 c_parser_consume_token (parser
);
6750 atype
= c_parser_objc_type_name (parser
);
6751 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
6754 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
6756 c_parser_error (parser
, "expected identifier");
6757 return error_mark_node
;
6759 id
= c_parser_peek_token (parser
)->value
;
6760 c_parser_consume_token (parser
);
6761 keyworddecl
= objc_build_keyword_decl (tsel
, atype
, id
);
6762 list
= chainon (list
, keyworddecl
);
6763 tsel
= c_parser_objc_selector (parser
);
6764 if (!tsel
&& c_parser_next_token_is_not (parser
, CPP_COLON
))
6767 /* Parse the optional parameter list. Optional Objective-C
6768 method parameters follow the C syntax, and may include '...'
6769 to denote a variable number of arguments. */
6770 parms
= make_node (TREE_LIST
);
6771 while (c_parser_next_token_is (parser
, CPP_COMMA
))
6773 struct c_parm
*parm
;
6774 c_parser_consume_token (parser
);
6775 if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
))
6778 c_parser_consume_token (parser
);
6781 parm
= c_parser_parameter_declaration (parser
, NULL_TREE
);
6784 parms
= chainon (parms
,
6785 build_tree_list (NULL_TREE
, grokparm (parm
)));
6789 return objc_build_method_signature (type
, sel
, parms
, ellipsis
);
6792 /* Parse an objc-type-name.
6795 objc-type-qualifiers[opt] type-name
6796 objc-type-qualifiers[opt]
6798 objc-type-qualifiers:
6800 objc-type-qualifiers objc-type-qualifier
6802 objc-type-qualifier: one of
6803 in out inout bycopy byref oneway
6807 c_parser_objc_type_name (c_parser
*parser
)
6809 tree quals
= NULL_TREE
;
6810 struct c_type_name
*type_name
= NULL
;
6811 tree type
= NULL_TREE
;
6814 c_token
*token
= c_parser_peek_token (parser
);
6815 if (token
->type
== CPP_KEYWORD
6816 && (token
->keyword
== RID_IN
6817 || token
->keyword
== RID_OUT
6818 || token
->keyword
== RID_INOUT
6819 || token
->keyword
== RID_BYCOPY
6820 || token
->keyword
== RID_BYREF
6821 || token
->keyword
== RID_ONEWAY
))
6823 quals
= chainon (quals
, build_tree_list (NULL_TREE
, token
->value
));
6824 c_parser_consume_token (parser
);
6829 if (c_parser_next_token_starts_typename (parser
))
6830 type_name
= c_parser_type_name (parser
);
6832 type
= groktypename (type_name
, NULL
, NULL
);
6833 return build_tree_list (quals
, type
);
6836 /* Parse objc-protocol-refs.
6843 c_parser_objc_protocol_refs (c_parser
*parser
)
6845 tree list
= NULL_TREE
;
6846 gcc_assert (c_parser_next_token_is (parser
, CPP_LESS
));
6847 c_parser_consume_token (parser
);
6848 /* Any identifiers, including those declared as type names, are OK
6853 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
6855 c_parser_error (parser
, "expected identifier");
6858 id
= c_parser_peek_token (parser
)->value
;
6859 list
= chainon (list
, build_tree_list (NULL_TREE
, id
));
6860 c_parser_consume_token (parser
);
6861 if (c_parser_next_token_is (parser
, CPP_COMMA
))
6862 c_parser_consume_token (parser
);
6866 c_parser_require (parser
, CPP_GREATER
, "expected %<>%>");
6870 /* Parse an objc-try-catch-statement.
6872 objc-try-catch-statement:
6873 @try compound-statement objc-catch-list[opt]
6874 @try compound-statement objc-catch-list[opt] @finally compound-statement
6877 @catch ( parameter-declaration ) compound-statement
6878 objc-catch-list @catch ( parameter-declaration ) compound-statement
6882 c_parser_objc_try_catch_statement (c_parser
*parser
)
6886 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_TRY
));
6887 c_parser_consume_token (parser
);
6888 loc
= c_parser_peek_token (parser
)->location
;
6889 stmt
= c_parser_compound_statement (parser
);
6890 objc_begin_try_stmt (loc
, stmt
);
6891 while (c_parser_next_token_is_keyword (parser
, RID_CATCH
))
6893 struct c_parm
*parm
;
6894 c_parser_consume_token (parser
);
6895 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
6897 parm
= c_parser_parameter_declaration (parser
, NULL_TREE
);
6900 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
6903 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
6904 objc_begin_catch_clause (grokparm (parm
));
6905 if (c_parser_require (parser
, CPP_OPEN_BRACE
, "expected %<{%>"))
6906 c_parser_compound_statement_nostart (parser
);
6907 objc_finish_catch_clause ();
6909 if (c_parser_next_token_is_keyword (parser
, RID_AT_FINALLY
))
6913 c_parser_consume_token (parser
);
6914 finloc
= c_parser_peek_token (parser
)->location
;
6915 finstmt
= c_parser_compound_statement (parser
);
6916 objc_build_finally_clause (finloc
, finstmt
);
6918 objc_finish_try_stmt ();
6921 /* Parse an objc-synchronized-statement.
6923 objc-synchronized-statement:
6924 @synchronized ( expression ) compound-statement
6928 c_parser_objc_synchronized_statement (c_parser
*parser
)
6932 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_AT_SYNCHRONIZED
));
6933 c_parser_consume_token (parser
);
6934 loc
= c_parser_peek_token (parser
)->location
;
6935 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
6937 expr
= c_parser_expression (parser
).value
;
6938 expr
= c_fully_fold (expr
, false, NULL
);
6939 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
6942 expr
= error_mark_node
;
6943 stmt
= c_parser_compound_statement (parser
);
6944 objc_build_synchronized (loc
, expr
, stmt
);
6947 /* Parse an objc-selector; return NULL_TREE without an error if the
6948 next token is not an objc-selector.
6953 enum struct union if else while do for switch case default
6954 break continue return goto asm sizeof typeof __alignof
6955 unsigned long const short volatile signed restrict _Complex
6956 in out inout bycopy byref oneway int char float double void _Bool
6958 ??? Why this selection of keywords but not, for example, storage
6959 class specifiers? */
6962 c_parser_objc_selector (c_parser
*parser
)
6964 c_token
*token
= c_parser_peek_token (parser
);
6965 tree value
= token
->value
;
6966 if (token
->type
== CPP_NAME
)
6968 c_parser_consume_token (parser
);
6971 if (token
->type
!= CPP_KEYWORD
)
6973 switch (token
->keyword
)
7015 c_parser_consume_token (parser
);
7022 /* Parse an objc-selector-arg.
7026 objc-keywordname-list
7028 objc-keywordname-list:
7030 objc-keywordname-list objc-keywordname
7038 c_parser_objc_selector_arg (c_parser
*parser
)
7040 tree sel
= c_parser_objc_selector (parser
);
7041 tree list
= NULL_TREE
;
7042 if (sel
&& c_parser_next_token_is_not (parser
, CPP_COLON
))
7046 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
7048 list
= chainon (list
, build_tree_list (sel
, NULL_TREE
));
7049 sel
= c_parser_objc_selector (parser
);
7050 if (!sel
&& c_parser_next_token_is_not (parser
, CPP_COLON
))
7056 /* Parse an objc-receiver.
7065 c_parser_objc_receiver (c_parser
*parser
)
7067 if (c_parser_peek_token (parser
)->type
== CPP_NAME
7068 && (c_parser_peek_token (parser
)->id_kind
== C_ID_TYPENAME
7069 || c_parser_peek_token (parser
)->id_kind
== C_ID_CLASSNAME
))
7071 tree id
= c_parser_peek_token (parser
)->value
;
7072 c_parser_consume_token (parser
);
7073 return objc_get_class_reference (id
);
7075 return c_fully_fold (c_parser_expression (parser
).value
, false, NULL
);
7078 /* Parse objc-message-args.
7082 objc-keywordarg-list
7084 objc-keywordarg-list:
7086 objc-keywordarg-list objc-keywordarg
7089 objc-selector : objc-keywordexpr
7094 c_parser_objc_message_args (c_parser
*parser
)
7096 tree sel
= c_parser_objc_selector (parser
);
7097 tree list
= NULL_TREE
;
7098 if (sel
&& c_parser_next_token_is_not (parser
, CPP_COLON
))
7103 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
7104 return error_mark_node
;
7105 keywordexpr
= c_parser_objc_keywordexpr (parser
);
7106 list
= chainon (list
, build_tree_list (sel
, keywordexpr
));
7107 sel
= c_parser_objc_selector (parser
);
7108 if (!sel
&& c_parser_next_token_is_not (parser
, CPP_COLON
))
7114 /* Parse an objc-keywordexpr.
7121 c_parser_objc_keywordexpr (c_parser
*parser
)
7124 VEC(tree
,gc
) *expr_list
= c_parser_expr_list (parser
, true, true, NULL
);
7125 if (VEC_length (tree
, expr_list
) == 1)
7127 /* Just return the expression, remove a level of
7129 ret
= VEC_index (tree
, expr_list
, 0);
7133 /* We have a comma expression, we will collapse later. */
7134 ret
= build_tree_list_vec (expr_list
);
7136 release_tree_vector (expr_list
);
7141 /* Handle pragmas. Some OpenMP pragmas are associated with, and therefore
7142 should be considered, statements. ALLOW_STMT is true if we're within
7143 the context of a function and such pragmas are to be allowed. Returns
7144 true if we actually parsed such a pragma. */
7147 c_parser_pragma (c_parser
*parser
, enum pragma_context context
)
7151 id
= c_parser_peek_token (parser
)->pragma_kind
;
7152 gcc_assert (id
!= PRAGMA_NONE
);
7156 case PRAGMA_OMP_BARRIER
:
7157 if (context
!= pragma_compound
)
7159 if (context
== pragma_stmt
)
7160 c_parser_error (parser
, "%<#pragma omp barrier%> may only be "
7161 "used in compound statements");
7164 c_parser_omp_barrier (parser
);
7167 case PRAGMA_OMP_FLUSH
:
7168 if (context
!= pragma_compound
)
7170 if (context
== pragma_stmt
)
7171 c_parser_error (parser
, "%<#pragma omp flush%> may only be "
7172 "used in compound statements");
7175 c_parser_omp_flush (parser
);
7178 case PRAGMA_OMP_TASKWAIT
:
7179 if (context
!= pragma_compound
)
7181 if (context
== pragma_stmt
)
7182 c_parser_error (parser
, "%<#pragma omp taskwait%> may only be "
7183 "used in compound statements");
7186 c_parser_omp_taskwait (parser
);
7189 case PRAGMA_OMP_THREADPRIVATE
:
7190 c_parser_omp_threadprivate (parser
);
7193 case PRAGMA_OMP_SECTION
:
7194 error_at (c_parser_peek_token (parser
)->location
,
7195 "%<#pragma omp section%> may only be used in "
7196 "%<#pragma omp sections%> construct");
7197 c_parser_skip_until_found (parser
, CPP_PRAGMA_EOL
, NULL
);
7200 case PRAGMA_GCC_PCH_PREPROCESS
:
7201 c_parser_error (parser
, "%<#pragma GCC pch_preprocess%> must be first");
7202 c_parser_skip_until_found (parser
, CPP_PRAGMA_EOL
, NULL
);
7206 if (id
< PRAGMA_FIRST_EXTERNAL
)
7208 if (context
== pragma_external
)
7211 c_parser_error (parser
, "expected declaration specifiers");
7212 c_parser_skip_until_found (parser
, CPP_PRAGMA_EOL
, NULL
);
7215 c_parser_omp_construct (parser
);
7221 c_parser_consume_pragma (parser
);
7222 c_invoke_pragma_handler (id
);
7224 /* Skip to EOL, but suppress any error message. Those will have been
7225 generated by the handler routine through calling error, as opposed
7226 to calling c_parser_error. */
7227 parser
->error
= true;
7228 c_parser_skip_to_pragma_eol (parser
);
7233 /* The interface the pragma parsers have to the lexer. */
7236 pragma_lex (tree
*value
)
7238 c_token
*tok
= c_parser_peek_token (the_parser
);
7239 enum cpp_ttype ret
= tok
->type
;
7241 *value
= tok
->value
;
7242 if (ret
== CPP_PRAGMA_EOL
|| ret
== CPP_EOF
)
7246 if (ret
== CPP_KEYWORD
)
7248 c_parser_consume_token (the_parser
);
7255 c_parser_pragma_pch_preprocess (c_parser
*parser
)
7259 c_parser_consume_pragma (parser
);
7260 if (c_parser_next_token_is (parser
, CPP_STRING
))
7262 name
= c_parser_peek_token (parser
)->value
;
7263 c_parser_consume_token (parser
);
7266 c_parser_error (parser
, "expected string literal");
7267 c_parser_skip_to_pragma_eol (parser
);
7270 c_common_pch_pragma (parse_in
, TREE_STRING_POINTER (name
));
7273 /* OpenMP 2.5 parsing routines. */
7275 /* Returns name of the next clause.
7276 If the clause is not recognized PRAGMA_OMP_CLAUSE_NONE is returned and
7277 the token is not consumed. Otherwise appropriate pragma_omp_clause is
7278 returned and the token is consumed. */
7280 static pragma_omp_clause
7281 c_parser_omp_clause_name (c_parser
*parser
)
7283 pragma_omp_clause result
= PRAGMA_OMP_CLAUSE_NONE
;
7285 if (c_parser_next_token_is_keyword (parser
, RID_IF
))
7286 result
= PRAGMA_OMP_CLAUSE_IF
;
7287 else if (c_parser_next_token_is_keyword (parser
, RID_DEFAULT
))
7288 result
= PRAGMA_OMP_CLAUSE_DEFAULT
;
7289 else if (c_parser_next_token_is (parser
, CPP_NAME
))
7291 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
7296 if (!strcmp ("collapse", p
))
7297 result
= PRAGMA_OMP_CLAUSE_COLLAPSE
;
7298 else if (!strcmp ("copyin", p
))
7299 result
= PRAGMA_OMP_CLAUSE_COPYIN
;
7300 else if (!strcmp ("copyprivate", p
))
7301 result
= PRAGMA_OMP_CLAUSE_COPYPRIVATE
;
7304 if (!strcmp ("firstprivate", p
))
7305 result
= PRAGMA_OMP_CLAUSE_FIRSTPRIVATE
;
7308 if (!strcmp ("lastprivate", p
))
7309 result
= PRAGMA_OMP_CLAUSE_LASTPRIVATE
;
7312 if (!strcmp ("nowait", p
))
7313 result
= PRAGMA_OMP_CLAUSE_NOWAIT
;
7314 else if (!strcmp ("num_threads", p
))
7315 result
= PRAGMA_OMP_CLAUSE_NUM_THREADS
;
7318 if (!strcmp ("ordered", p
))
7319 result
= PRAGMA_OMP_CLAUSE_ORDERED
;
7322 if (!strcmp ("private", p
))
7323 result
= PRAGMA_OMP_CLAUSE_PRIVATE
;
7326 if (!strcmp ("reduction", p
))
7327 result
= PRAGMA_OMP_CLAUSE_REDUCTION
;
7330 if (!strcmp ("schedule", p
))
7331 result
= PRAGMA_OMP_CLAUSE_SCHEDULE
;
7332 else if (!strcmp ("shared", p
))
7333 result
= PRAGMA_OMP_CLAUSE_SHARED
;
7336 if (!strcmp ("untied", p
))
7337 result
= PRAGMA_OMP_CLAUSE_UNTIED
;
7342 if (result
!= PRAGMA_OMP_CLAUSE_NONE
)
7343 c_parser_consume_token (parser
);
7348 /* Validate that a clause of the given type does not already exist. */
7351 check_no_duplicate_clause (tree clauses
, enum omp_clause_code code
,
7356 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
7357 if (OMP_CLAUSE_CODE (c
) == code
)
7359 location_t loc
= OMP_CLAUSE_LOCATION (c
);
7360 error_at (loc
, "too many %qs clauses", name
);
7368 variable-list , identifier
7370 If KIND is nonzero, create the appropriate node and install the
7371 decl in OMP_CLAUSE_DECL and add the node to the head of the list.
7372 If KIND is nonzero, CLAUSE_LOC is the location of the clause.
7374 If KIND is zero, create a TREE_LIST with the decl in TREE_PURPOSE;
7375 return the list created. */
7378 c_parser_omp_variable_list (c_parser
*parser
,
7379 location_t clause_loc
,
7380 enum omp_clause_code kind
,
7383 if (c_parser_next_token_is_not (parser
, CPP_NAME
)
7384 || c_parser_peek_token (parser
)->id_kind
!= C_ID_ID
)
7385 c_parser_error (parser
, "expected identifier");
7387 while (c_parser_next_token_is (parser
, CPP_NAME
)
7388 && c_parser_peek_token (parser
)->id_kind
== C_ID_ID
)
7390 tree t
= lookup_name (c_parser_peek_token (parser
)->value
);
7393 undeclared_variable (c_parser_peek_token (parser
)->location
,
7394 c_parser_peek_token (parser
)->value
);
7395 else if (t
== error_mark_node
)
7399 tree u
= build_omp_clause (clause_loc
, kind
);
7400 OMP_CLAUSE_DECL (u
) = t
;
7401 OMP_CLAUSE_CHAIN (u
) = list
;
7405 list
= tree_cons (t
, NULL_TREE
, list
);
7407 c_parser_consume_token (parser
);
7409 if (c_parser_next_token_is_not (parser
, CPP_COMMA
))
7412 c_parser_consume_token (parser
);
7418 /* Similarly, but expect leading and trailing parenthesis. This is a very
7419 common case for omp clauses. */
7422 c_parser_omp_var_list_parens (c_parser
*parser
, enum omp_clause_code kind
,
7425 /* The clauses location. */
7426 location_t loc
= c_parser_peek_token (parser
)->location
;
7428 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
7430 list
= c_parser_omp_variable_list (parser
, loc
, kind
, list
);
7431 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
7437 collapse ( constant-expression ) */
7440 c_parser_omp_clause_collapse (c_parser
*parser
, tree list
)
7442 tree c
, num
= error_mark_node
;
7446 check_no_duplicate_clause (list
, OMP_CLAUSE_COLLAPSE
, "collapse");
7448 loc
= c_parser_peek_token (parser
)->location
;
7449 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
7451 num
= c_parser_expr_no_commas (parser
, NULL
).value
;
7452 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
7454 if (num
== error_mark_node
)
7456 if (!INTEGRAL_TYPE_P (TREE_TYPE (num
))
7457 || !host_integerp (num
, 0)
7458 || (n
= tree_low_cst (num
, 0)) <= 0
7462 "collapse argument needs positive constant integer expression");
7465 c
= build_omp_clause (loc
, OMP_CLAUSE_COLLAPSE
);
7466 OMP_CLAUSE_COLLAPSE_EXPR (c
) = num
;
7467 OMP_CLAUSE_CHAIN (c
) = list
;
7472 copyin ( variable-list ) */
7475 c_parser_omp_clause_copyin (c_parser
*parser
, tree list
)
7477 return c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_COPYIN
, list
);
7481 copyprivate ( variable-list ) */
7484 c_parser_omp_clause_copyprivate (c_parser
*parser
, tree list
)
7486 return c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_COPYPRIVATE
, list
);
7490 default ( shared | none ) */
7493 c_parser_omp_clause_default (c_parser
*parser
, tree list
)
7495 enum omp_clause_default_kind kind
= OMP_CLAUSE_DEFAULT_UNSPECIFIED
;
7496 location_t loc
= c_parser_peek_token (parser
)->location
;
7499 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
7501 if (c_parser_next_token_is (parser
, CPP_NAME
))
7503 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
7508 if (strcmp ("none", p
) != 0)
7510 kind
= OMP_CLAUSE_DEFAULT_NONE
;
7514 if (strcmp ("shared", p
) != 0)
7516 kind
= OMP_CLAUSE_DEFAULT_SHARED
;
7523 c_parser_consume_token (parser
);
7528 c_parser_error (parser
, "expected %<none%> or %<shared%>");
7530 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
7532 if (kind
== OMP_CLAUSE_DEFAULT_UNSPECIFIED
)
7535 check_no_duplicate_clause (list
, OMP_CLAUSE_DEFAULT
, "default");
7536 c
= build_omp_clause (loc
, OMP_CLAUSE_DEFAULT
);
7537 OMP_CLAUSE_CHAIN (c
) = list
;
7538 OMP_CLAUSE_DEFAULT_KIND (c
) = kind
;
7544 firstprivate ( variable-list ) */
7547 c_parser_omp_clause_firstprivate (c_parser
*parser
, tree list
)
7549 return c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_FIRSTPRIVATE
, list
);
7553 if ( expression ) */
7556 c_parser_omp_clause_if (c_parser
*parser
, tree list
)
7558 location_t loc
= c_parser_peek_token (parser
)->location
;
7559 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
7561 tree t
= c_parser_paren_condition (parser
);
7564 check_no_duplicate_clause (list
, OMP_CLAUSE_IF
, "if");
7566 c
= build_omp_clause (loc
, OMP_CLAUSE_IF
);
7567 OMP_CLAUSE_IF_EXPR (c
) = t
;
7568 OMP_CLAUSE_CHAIN (c
) = list
;
7572 c_parser_error (parser
, "expected %<(%>");
7578 lastprivate ( variable-list ) */
7581 c_parser_omp_clause_lastprivate (c_parser
*parser
, tree list
)
7583 return c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_LASTPRIVATE
, list
);
7590 c_parser_omp_clause_nowait (c_parser
*parser ATTRIBUTE_UNUSED
, tree list
)
7593 location_t loc
= c_parser_peek_token (parser
)->location
;
7595 check_no_duplicate_clause (list
, OMP_CLAUSE_NOWAIT
, "nowait");
7597 c
= build_omp_clause (loc
, OMP_CLAUSE_NOWAIT
);
7598 OMP_CLAUSE_CHAIN (c
) = list
;
7603 num_threads ( expression ) */
7606 c_parser_omp_clause_num_threads (c_parser
*parser
, tree list
)
7608 location_t num_threads_loc
= c_parser_peek_token (parser
)->location
;
7609 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
7611 location_t expr_loc
= c_parser_peek_token (parser
)->location
;
7612 tree c
, t
= c_parser_expression (parser
).value
;
7613 t
= c_fully_fold (t
, false, NULL
);
7615 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
7617 if (!INTEGRAL_TYPE_P (TREE_TYPE (t
)))
7619 c_parser_error (parser
, "expected integer expression");
7623 /* Attempt to statically determine when the number isn't positive. */
7624 c
= fold_build2_loc (expr_loc
, LE_EXPR
, boolean_type_node
, t
,
7625 build_int_cst (TREE_TYPE (t
), 0));
7626 if (CAN_HAVE_LOCATION_P (c
))
7627 SET_EXPR_LOCATION (c
, expr_loc
);
7628 if (c
== boolean_true_node
)
7630 warning_at (expr_loc
, 0,
7631 "%<num_threads%> value must be positive");
7632 t
= integer_one_node
;
7635 check_no_duplicate_clause (list
, OMP_CLAUSE_NUM_THREADS
, "num_threads");
7637 c
= build_omp_clause (num_threads_loc
, OMP_CLAUSE_NUM_THREADS
);
7638 OMP_CLAUSE_NUM_THREADS_EXPR (c
) = t
;
7639 OMP_CLAUSE_CHAIN (c
) = list
;
7650 c_parser_omp_clause_ordered (c_parser
*parser
, tree list
)
7654 check_no_duplicate_clause (list
, OMP_CLAUSE_ORDERED
, "ordered");
7656 c
= build_omp_clause (c_parser_peek_token (parser
)->location
,
7657 OMP_CLAUSE_ORDERED
);
7658 OMP_CLAUSE_CHAIN (c
) = list
;
7664 private ( variable-list ) */
7667 c_parser_omp_clause_private (c_parser
*parser
, tree list
)
7669 return c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_PRIVATE
, list
);
7673 reduction ( reduction-operator : variable-list )
7676 One of: + * - & ^ | && || */
7679 c_parser_omp_clause_reduction (c_parser
*parser
, tree list
)
7681 location_t clause_loc
= c_parser_peek_token (parser
)->location
;
7682 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
7684 enum tree_code code
;
7686 switch (c_parser_peek_token (parser
)->type
)
7698 code
= BIT_AND_EXPR
;
7701 code
= BIT_XOR_EXPR
;
7704 code
= BIT_IOR_EXPR
;
7707 code
= TRUTH_ANDIF_EXPR
;
7710 code
= TRUTH_ORIF_EXPR
;
7713 c_parser_error (parser
,
7714 "expected %<+%>, %<*%>, %<-%>, %<&%>, "
7715 "%<^%>, %<|%>, %<&&%>, or %<||%>");
7716 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, 0);
7719 c_parser_consume_token (parser
);
7720 if (c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
7724 nl
= c_parser_omp_variable_list (parser
, clause_loc
,
7725 OMP_CLAUSE_REDUCTION
, list
);
7726 for (c
= nl
; c
!= list
; c
= OMP_CLAUSE_CHAIN (c
))
7727 OMP_CLAUSE_REDUCTION_CODE (c
) = code
;
7731 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
7737 schedule ( schedule-kind )
7738 schedule ( schedule-kind , expression )
7741 static | dynamic | guided | runtime | auto
7745 c_parser_omp_clause_schedule (c_parser
*parser
, tree list
)
7748 location_t loc
= c_parser_peek_token (parser
)->location
;
7750 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
7753 c
= build_omp_clause (loc
, OMP_CLAUSE_SCHEDULE
);
7755 if (c_parser_next_token_is (parser
, CPP_NAME
))
7757 tree kind
= c_parser_peek_token (parser
)->value
;
7758 const char *p
= IDENTIFIER_POINTER (kind
);
7763 if (strcmp ("dynamic", p
) != 0)
7765 OMP_CLAUSE_SCHEDULE_KIND (c
) = OMP_CLAUSE_SCHEDULE_DYNAMIC
;
7769 if (strcmp ("guided", p
) != 0)
7771 OMP_CLAUSE_SCHEDULE_KIND (c
) = OMP_CLAUSE_SCHEDULE_GUIDED
;
7775 if (strcmp ("runtime", p
) != 0)
7777 OMP_CLAUSE_SCHEDULE_KIND (c
) = OMP_CLAUSE_SCHEDULE_RUNTIME
;
7784 else if (c_parser_next_token_is_keyword (parser
, RID_STATIC
))
7785 OMP_CLAUSE_SCHEDULE_KIND (c
) = OMP_CLAUSE_SCHEDULE_STATIC
;
7786 else if (c_parser_next_token_is_keyword (parser
, RID_AUTO
))
7787 OMP_CLAUSE_SCHEDULE_KIND (c
) = OMP_CLAUSE_SCHEDULE_AUTO
;
7791 c_parser_consume_token (parser
);
7792 if (c_parser_next_token_is (parser
, CPP_COMMA
))
7795 c_parser_consume_token (parser
);
7797 here
= c_parser_peek_token (parser
)->location
;
7798 t
= c_parser_expr_no_commas (parser
, NULL
).value
;
7799 t
= c_fully_fold (t
, false, NULL
);
7801 if (OMP_CLAUSE_SCHEDULE_KIND (c
) == OMP_CLAUSE_SCHEDULE_RUNTIME
)
7802 error_at (here
, "schedule %<runtime%> does not take "
7803 "a %<chunk_size%> parameter");
7804 else if (OMP_CLAUSE_SCHEDULE_KIND (c
) == OMP_CLAUSE_SCHEDULE_AUTO
)
7806 "schedule %<auto%> does not take "
7807 "a %<chunk_size%> parameter");
7808 else if (TREE_CODE (TREE_TYPE (t
)) == INTEGER_TYPE
)
7809 OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c
) = t
;
7811 c_parser_error (parser
, "expected integer expression");
7813 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
7816 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
7817 "expected %<,%> or %<)%>");
7819 check_no_duplicate_clause (list
, OMP_CLAUSE_SCHEDULE
, "schedule");
7820 OMP_CLAUSE_CHAIN (c
) = list
;
7824 c_parser_error (parser
, "invalid schedule kind");
7825 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, 0);
7830 shared ( variable-list ) */
7833 c_parser_omp_clause_shared (c_parser
*parser
, tree list
)
7835 return c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_SHARED
, list
);
7842 c_parser_omp_clause_untied (c_parser
*parser ATTRIBUTE_UNUSED
, tree list
)
7846 /* FIXME: Should we allow duplicates? */
7847 check_no_duplicate_clause (list
, OMP_CLAUSE_UNTIED
, "untied");
7849 c
= build_omp_clause (c_parser_peek_token (parser
)->location
,
7851 OMP_CLAUSE_CHAIN (c
) = list
;
7856 /* Parse all OpenMP clauses. The set clauses allowed by the directive
7857 is a bitmask in MASK. Return the list of clauses found; the result
7858 of clause default goes in *pdefault. */
7861 c_parser_omp_all_clauses (c_parser
*parser
, unsigned int mask
,
7864 tree clauses
= NULL
;
7867 while (c_parser_next_token_is_not (parser
, CPP_PRAGMA_EOL
))
7870 pragma_omp_clause c_kind
;
7872 tree prev
= clauses
;
7874 if (!first
&& c_parser_next_token_is (parser
, CPP_COMMA
))
7875 c_parser_consume_token (parser
);
7878 here
= c_parser_peek_token (parser
)->location
;
7879 c_kind
= c_parser_omp_clause_name (parser
);
7883 case PRAGMA_OMP_CLAUSE_COLLAPSE
:
7884 clauses
= c_parser_omp_clause_collapse (parser
, clauses
);
7885 c_name
= "collapse";
7887 case PRAGMA_OMP_CLAUSE_COPYIN
:
7888 clauses
= c_parser_omp_clause_copyin (parser
, clauses
);
7891 case PRAGMA_OMP_CLAUSE_COPYPRIVATE
:
7892 clauses
= c_parser_omp_clause_copyprivate (parser
, clauses
);
7893 c_name
= "copyprivate";
7895 case PRAGMA_OMP_CLAUSE_DEFAULT
:
7896 clauses
= c_parser_omp_clause_default (parser
, clauses
);
7899 case PRAGMA_OMP_CLAUSE_FIRSTPRIVATE
:
7900 clauses
= c_parser_omp_clause_firstprivate (parser
, clauses
);
7901 c_name
= "firstprivate";
7903 case PRAGMA_OMP_CLAUSE_IF
:
7904 clauses
= c_parser_omp_clause_if (parser
, clauses
);
7907 case PRAGMA_OMP_CLAUSE_LASTPRIVATE
:
7908 clauses
= c_parser_omp_clause_lastprivate (parser
, clauses
);
7909 c_name
= "lastprivate";
7911 case PRAGMA_OMP_CLAUSE_NOWAIT
:
7912 clauses
= c_parser_omp_clause_nowait (parser
, clauses
);
7915 case PRAGMA_OMP_CLAUSE_NUM_THREADS
:
7916 clauses
= c_parser_omp_clause_num_threads (parser
, clauses
);
7917 c_name
= "num_threads";
7919 case PRAGMA_OMP_CLAUSE_ORDERED
:
7920 clauses
= c_parser_omp_clause_ordered (parser
, clauses
);
7923 case PRAGMA_OMP_CLAUSE_PRIVATE
:
7924 clauses
= c_parser_omp_clause_private (parser
, clauses
);
7927 case PRAGMA_OMP_CLAUSE_REDUCTION
:
7928 clauses
= c_parser_omp_clause_reduction (parser
, clauses
);
7929 c_name
= "reduction";
7931 case PRAGMA_OMP_CLAUSE_SCHEDULE
:
7932 clauses
= c_parser_omp_clause_schedule (parser
, clauses
);
7933 c_name
= "schedule";
7935 case PRAGMA_OMP_CLAUSE_SHARED
:
7936 clauses
= c_parser_omp_clause_shared (parser
, clauses
);
7939 case PRAGMA_OMP_CLAUSE_UNTIED
:
7940 clauses
= c_parser_omp_clause_untied (parser
, clauses
);
7944 c_parser_error (parser
, "expected %<#pragma omp%> clause");
7948 if (((mask
>> c_kind
) & 1) == 0 && !parser
->error
)
7950 /* Remove the invalid clause(s) from the list to avoid
7951 confusing the rest of the compiler. */
7953 error_at (here
, "%qs is not valid for %qs", c_name
, where
);
7958 c_parser_skip_to_pragma_eol (parser
);
7960 return c_finish_omp_clauses (clauses
);
7967 In practice, we're also interested in adding the statement to an
7968 outer node. So it is convenient if we work around the fact that
7969 c_parser_statement calls add_stmt. */
7972 c_parser_omp_structured_block (c_parser
*parser
)
7974 tree stmt
= push_stmt_list ();
7975 c_parser_statement (parser
);
7976 return pop_stmt_list (stmt
);
7980 # pragma omp atomic new-line
7984 x binop= expr | x++ | ++x | x-- | --x
7986 +, *, -, /, &, ^, |, <<, >>
7988 where x is an lvalue expression with scalar type.
7990 LOC is the location of the #pragma token. */
7993 c_parser_omp_atomic (location_t loc
, c_parser
*parser
)
7997 enum tree_code code
;
7998 struct c_expr rhs_expr
;
8000 c_parser_skip_to_pragma_eol (parser
);
8002 lhs
= c_parser_unary_expression (parser
).value
;
8003 lhs
= c_fully_fold (lhs
, false, NULL
);
8004 switch (TREE_CODE (lhs
))
8008 c_parser_skip_to_end_of_block_or_statement (parser
);
8011 case PREINCREMENT_EXPR
:
8012 case POSTINCREMENT_EXPR
:
8013 lhs
= TREE_OPERAND (lhs
, 0);
8015 rhs
= integer_one_node
;
8018 case PREDECREMENT_EXPR
:
8019 case POSTDECREMENT_EXPR
:
8020 lhs
= TREE_OPERAND (lhs
, 0);
8022 rhs
= integer_one_node
;
8026 switch (c_parser_peek_token (parser
)->type
)
8032 code
= TRUNC_DIV_EXPR
;
8047 code
= BIT_AND_EXPR
;
8050 code
= BIT_IOR_EXPR
;
8053 code
= BIT_XOR_EXPR
;
8056 c_parser_error (parser
,
8057 "invalid operator for %<#pragma omp atomic%>");
8061 c_parser_consume_token (parser
);
8063 location_t rhs_loc
= c_parser_peek_token (parser
)->location
;
8064 rhs_expr
= c_parser_expression (parser
);
8065 rhs_expr
= default_function_array_read_conversion (rhs_loc
, rhs_expr
);
8067 rhs
= rhs_expr
.value
;
8068 rhs
= c_fully_fold (rhs
, false, NULL
);
8071 stmt
= c_finish_omp_atomic (loc
, code
, lhs
, rhs
);
8072 if (stmt
!= error_mark_node
)
8074 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
8079 # pragma omp barrier new-line
8083 c_parser_omp_barrier (c_parser
*parser
)
8085 location_t loc
= c_parser_peek_token (parser
)->location
;
8086 c_parser_consume_pragma (parser
);
8087 c_parser_skip_to_pragma_eol (parser
);
8089 c_finish_omp_barrier (loc
);
8093 # pragma omp critical [(name)] new-line
8096 LOC is the location of the #pragma itself. */
8099 c_parser_omp_critical (location_t loc
, c_parser
*parser
)
8101 tree stmt
, name
= NULL
;
8103 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
8105 c_parser_consume_token (parser
);
8106 if (c_parser_next_token_is (parser
, CPP_NAME
))
8108 name
= c_parser_peek_token (parser
)->value
;
8109 c_parser_consume_token (parser
);
8110 c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
8113 c_parser_error (parser
, "expected identifier");
8115 else if (c_parser_next_token_is_not (parser
, CPP_PRAGMA_EOL
))
8116 c_parser_error (parser
, "expected %<(%> or end of line");
8117 c_parser_skip_to_pragma_eol (parser
);
8119 stmt
= c_parser_omp_structured_block (parser
);
8120 return c_finish_omp_critical (loc
, stmt
, name
);
8124 # pragma omp flush flush-vars[opt] new-line
8127 ( variable-list ) */
8130 c_parser_omp_flush (c_parser
*parser
)
8132 location_t loc
= c_parser_peek_token (parser
)->location
;
8133 c_parser_consume_pragma (parser
);
8134 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
8135 c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_ERROR
, NULL
);
8136 else if (c_parser_next_token_is_not (parser
, CPP_PRAGMA_EOL
))
8137 c_parser_error (parser
, "expected %<(%> or end of line");
8138 c_parser_skip_to_pragma_eol (parser
);
8140 c_finish_omp_flush (loc
);
8143 /* Parse the restricted form of the for statement allowed by OpenMP.
8144 The real trick here is to determine the loop control variable early
8145 so that we can push a new decl if necessary to make it private.
8146 LOC is the location of the OMP in "#pragma omp". */
8149 c_parser_omp_for_loop (location_t loc
,
8150 c_parser
*parser
, tree clauses
, tree
*par_clauses
)
8152 tree decl
, cond
, incr
, save_break
, save_cont
, body
, init
, stmt
, cl
;
8153 tree declv
, condv
, incrv
, initv
, for_block
= NULL
, ret
= NULL
;
8154 bool fail
= false, open_brace_parsed
= false;
8155 int i
, collapse
= 1, nbraces
= 0;
8158 for (cl
= clauses
; cl
; cl
= OMP_CLAUSE_CHAIN (cl
))
8159 if (OMP_CLAUSE_CODE (cl
) == OMP_CLAUSE_COLLAPSE
)
8160 collapse
= tree_low_cst (OMP_CLAUSE_COLLAPSE_EXPR (cl
), 0);
8162 gcc_assert (collapse
>= 1);
8164 declv
= make_tree_vec (collapse
);
8165 initv
= make_tree_vec (collapse
);
8166 condv
= make_tree_vec (collapse
);
8167 incrv
= make_tree_vec (collapse
);
8169 if (!c_parser_next_token_is_keyword (parser
, RID_FOR
))
8171 c_parser_error (parser
, "for statement expected");
8174 for_loc
= c_parser_peek_token (parser
)->location
;
8175 c_parser_consume_token (parser
);
8177 for (i
= 0; i
< collapse
; i
++)
8181 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
8184 /* Parse the initialization declaration or expression. */
8185 if (c_parser_next_token_starts_declaration (parser
))
8189 = tree_cons (NULL
, c_begin_compound_stmt (true), for_block
);
8190 c_parser_declaration_or_fndef (parser
, true, true, true, true, true);
8191 decl
= check_for_loop_decls (for_loc
);
8194 if (DECL_INITIAL (decl
) == error_mark_node
)
8195 decl
= error_mark_node
;
8198 else if (c_parser_next_token_is (parser
, CPP_NAME
)
8199 && c_parser_peek_2nd_token (parser
)->type
== CPP_EQ
)
8201 struct c_expr decl_exp
;
8202 struct c_expr init_exp
;
8203 location_t init_loc
;
8205 decl_exp
= c_parser_postfix_expression (parser
);
8206 decl
= decl_exp
.value
;
8208 c_parser_require (parser
, CPP_EQ
, "expected %<=%>");
8210 init_loc
= c_parser_peek_token (parser
)->location
;
8211 init_exp
= c_parser_expr_no_commas (parser
, NULL
);
8212 init_exp
= default_function_array_read_conversion (init_loc
,
8214 init
= build_modify_expr (init_loc
, decl
, decl_exp
.original_type
,
8215 NOP_EXPR
, init_loc
, init_exp
.value
,
8216 init_exp
.original_type
);
8217 init
= c_process_expr_stmt (init_loc
, init
);
8219 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
8224 c_parser_error (parser
,
8225 "expected iteration declaration or initialization");
8226 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
8232 /* Parse the loop condition. */
8234 if (c_parser_next_token_is_not (parser
, CPP_SEMICOLON
))
8236 location_t cond_loc
= c_parser_peek_token (parser
)->location
;
8237 struct c_expr cond_expr
= c_parser_binary_expression (parser
, NULL
);
8239 cond
= cond_expr
.value
;
8240 cond
= c_objc_common_truthvalue_conversion (cond_loc
, cond
);
8241 cond
= c_fully_fold (cond
, false, NULL
);
8242 switch (cond_expr
.original_code
)
8250 /* Can't be cond = error_mark_node, because we want to preserve
8251 the location until c_finish_omp_for. */
8252 cond
= build1 (NOP_EXPR
, boolean_type_node
, error_mark_node
);
8255 protected_set_expr_location (cond
, cond_loc
);
8257 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
8259 /* Parse the increment expression. */
8261 if (c_parser_next_token_is_not (parser
, CPP_CLOSE_PAREN
))
8263 location_t incr_loc
= c_parser_peek_token (parser
)->location
;
8265 incr
= c_process_expr_stmt (incr_loc
,
8266 c_parser_expression (parser
).value
);
8268 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
8270 if (decl
== NULL
|| decl
== error_mark_node
|| init
== error_mark_node
)
8274 TREE_VEC_ELT (declv
, i
) = decl
;
8275 TREE_VEC_ELT (initv
, i
) = init
;
8276 TREE_VEC_ELT (condv
, i
) = cond
;
8277 TREE_VEC_ELT (incrv
, i
) = incr
;
8281 if (i
== collapse
- 1)
8284 /* FIXME: OpenMP 3.0 draft isn't very clear on what exactly is allowed
8285 in between the collapsed for loops to be still considered perfectly
8286 nested. Hopefully the final version clarifies this.
8287 For now handle (multiple) {'s and empty statements. */
8290 if (c_parser_next_token_is_keyword (parser
, RID_FOR
))
8292 c_parser_consume_token (parser
);
8295 else if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
8297 c_parser_consume_token (parser
);
8301 && c_parser_next_token_is (parser
, CPP_SEMICOLON
))
8302 c_parser_consume_token (parser
);
8305 c_parser_error (parser
, "not enough perfectly nested loops");
8308 open_brace_parsed
= true;
8318 nbraces
+= bracecount
;
8321 save_break
= c_break_label
;
8322 c_break_label
= size_one_node
;
8323 save_cont
= c_cont_label
;
8324 c_cont_label
= NULL_TREE
;
8325 body
= push_stmt_list ();
8327 if (open_brace_parsed
)
8329 location_t here
= c_parser_peek_token (parser
)->location
;
8330 stmt
= c_begin_compound_stmt (true);
8331 c_parser_compound_statement_nostart (parser
);
8332 add_stmt (c_end_compound_stmt (here
, stmt
, true));
8335 add_stmt (c_parser_c99_block_statement (parser
));
8338 tree t
= build1 (LABEL_EXPR
, void_type_node
, c_cont_label
);
8339 SET_EXPR_LOCATION (t
, loc
);
8343 body
= pop_stmt_list (body
);
8344 c_break_label
= save_break
;
8345 c_cont_label
= save_cont
;
8349 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
8351 c_parser_consume_token (parser
);
8354 else if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
8355 c_parser_consume_token (parser
);
8358 c_parser_error (parser
, "collapsed loops not perfectly nested");
8361 location_t here
= c_parser_peek_token (parser
)->location
;
8362 stmt
= c_begin_compound_stmt (true);
8364 c_parser_compound_statement_nostart (parser
);
8365 body
= c_end_compound_stmt (here
, stmt
, true);
8372 /* Only bother calling c_finish_omp_for if we haven't already generated
8373 an error from the initialization parsing. */
8376 stmt
= c_finish_omp_for (loc
, declv
, initv
, condv
, incrv
, body
, NULL
);
8379 if (par_clauses
!= NULL
)
8382 for (c
= par_clauses
; *c
; )
8383 if (OMP_CLAUSE_CODE (*c
) != OMP_CLAUSE_FIRSTPRIVATE
8384 && OMP_CLAUSE_CODE (*c
) != OMP_CLAUSE_LASTPRIVATE
)
8385 c
= &OMP_CLAUSE_CHAIN (*c
);
8388 for (i
= 0; i
< collapse
; i
++)
8389 if (TREE_VEC_ELT (declv
, i
) == OMP_CLAUSE_DECL (*c
))
8392 c
= &OMP_CLAUSE_CHAIN (*c
);
8393 else if (OMP_CLAUSE_CODE (*c
) == OMP_CLAUSE_FIRSTPRIVATE
)
8396 "iteration variable %qD should not be firstprivate",
8397 OMP_CLAUSE_DECL (*c
));
8398 *c
= OMP_CLAUSE_CHAIN (*c
);
8402 /* Copy lastprivate (decl) clause to OMP_FOR_CLAUSES,
8403 change it to shared (decl) in
8404 OMP_PARALLEL_CLAUSES. */
8405 tree l
= build_omp_clause (OMP_CLAUSE_LOCATION (*c
),
8406 OMP_CLAUSE_LASTPRIVATE
);
8407 OMP_CLAUSE_DECL (l
) = OMP_CLAUSE_DECL (*c
);
8408 OMP_CLAUSE_CHAIN (l
) = clauses
;
8410 OMP_CLAUSE_SET_CODE (*c
, OMP_CLAUSE_SHARED
);
8414 OMP_FOR_CLAUSES (stmt
) = clauses
;
8421 /* FIXME diagnostics: LOC below should be the actual location of
8422 this particular for block. We need to build a list of
8423 locations to go along with FOR_BLOCK. */
8424 stmt
= c_end_compound_stmt (loc
, TREE_VALUE (for_block
), true);
8426 for_block
= TREE_CHAIN (for_block
);
8432 #pragma omp for for-clause[optseq] new-line
8435 LOC is the location of the #pragma token.
8438 #define OMP_FOR_CLAUSE_MASK \
8439 ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
8440 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
8441 | (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
8442 | (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \
8443 | (1u << PRAGMA_OMP_CLAUSE_ORDERED) \
8444 | (1u << PRAGMA_OMP_CLAUSE_SCHEDULE) \
8445 | (1u << PRAGMA_OMP_CLAUSE_COLLAPSE) \
8446 | (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
8449 c_parser_omp_for (location_t loc
, c_parser
*parser
)
8451 tree block
, clauses
, ret
;
8453 clauses
= c_parser_omp_all_clauses (parser
, OMP_FOR_CLAUSE_MASK
,
8456 block
= c_begin_compound_stmt (true);
8457 ret
= c_parser_omp_for_loop (loc
, parser
, clauses
, NULL
);
8458 block
= c_end_compound_stmt (loc
, block
, true);
8465 # pragma omp master new-line
8468 LOC is the location of the #pragma token.
8472 c_parser_omp_master (location_t loc
, c_parser
*parser
)
8474 c_parser_skip_to_pragma_eol (parser
);
8475 return c_finish_omp_master (loc
, c_parser_omp_structured_block (parser
));
8479 # pragma omp ordered new-line
8482 LOC is the location of the #pragma itself.
8486 c_parser_omp_ordered (location_t loc
, c_parser
*parser
)
8488 c_parser_skip_to_pragma_eol (parser
);
8489 return c_finish_omp_ordered (loc
, c_parser_omp_structured_block (parser
));
8495 { section-sequence }
8498 section-directive[opt] structured-block
8499 section-sequence section-directive structured-block
8501 SECTIONS_LOC is the location of the #pragma omp sections. */
8504 c_parser_omp_sections_scope (location_t sections_loc
, c_parser
*parser
)
8507 bool error_suppress
= false;
8510 loc
= c_parser_peek_token (parser
)->location
;
8511 if (!c_parser_require (parser
, CPP_OPEN_BRACE
, "expected %<{%>"))
8513 /* Avoid skipping until the end of the block. */
8514 parser
->error
= false;
8518 stmt
= push_stmt_list ();
8520 if (c_parser_peek_token (parser
)->pragma_kind
!= PRAGMA_OMP_SECTION
)
8522 substmt
= push_stmt_list ();
8526 c_parser_statement (parser
);
8528 if (c_parser_peek_token (parser
)->pragma_kind
== PRAGMA_OMP_SECTION
)
8530 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
8532 if (c_parser_next_token_is (parser
, CPP_EOF
))
8536 substmt
= pop_stmt_list (substmt
);
8537 substmt
= build1 (OMP_SECTION
, void_type_node
, substmt
);
8538 SET_EXPR_LOCATION (substmt
, loc
);
8544 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
8546 if (c_parser_next_token_is (parser
, CPP_EOF
))
8549 loc
= c_parser_peek_token (parser
)->location
;
8550 if (c_parser_peek_token (parser
)->pragma_kind
== PRAGMA_OMP_SECTION
)
8552 c_parser_consume_pragma (parser
);
8553 c_parser_skip_to_pragma_eol (parser
);
8554 error_suppress
= false;
8556 else if (!error_suppress
)
8558 error_at (loc
, "expected %<#pragma omp section%> or %<}%>");
8559 error_suppress
= true;
8562 substmt
= c_parser_omp_structured_block (parser
);
8563 substmt
= build1 (OMP_SECTION
, void_type_node
, substmt
);
8564 SET_EXPR_LOCATION (substmt
, loc
);
8567 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
,
8568 "expected %<#pragma omp section%> or %<}%>");
8570 substmt
= pop_stmt_list (stmt
);
8572 stmt
= make_node (OMP_SECTIONS
);
8573 SET_EXPR_LOCATION (stmt
, sections_loc
);
8574 TREE_TYPE (stmt
) = void_type_node
;
8575 OMP_SECTIONS_BODY (stmt
) = substmt
;
8577 return add_stmt (stmt
);
8581 # pragma omp sections sections-clause[optseq] newline
8584 LOC is the location of the #pragma token.
8587 #define OMP_SECTIONS_CLAUSE_MASK \
8588 ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
8589 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
8590 | (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
8591 | (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \
8592 | (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
8595 c_parser_omp_sections (location_t loc
, c_parser
*parser
)
8597 tree block
, clauses
, ret
;
8599 clauses
= c_parser_omp_all_clauses (parser
, OMP_SECTIONS_CLAUSE_MASK
,
8600 "#pragma omp sections");
8602 block
= c_begin_compound_stmt (true);
8603 ret
= c_parser_omp_sections_scope (loc
, parser
);
8605 OMP_SECTIONS_CLAUSES (ret
) = clauses
;
8606 block
= c_end_compound_stmt (loc
, block
, true);
8613 # pragma parallel parallel-clause new-line
8614 # pragma parallel for parallel-for-clause new-line
8615 # pragma parallel sections parallel-sections-clause new-line
8617 LOC is the location of the #pragma token.
8620 #define OMP_PARALLEL_CLAUSE_MASK \
8621 ( (1u << PRAGMA_OMP_CLAUSE_IF) \
8622 | (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
8623 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
8624 | (1u << PRAGMA_OMP_CLAUSE_DEFAULT) \
8625 | (1u << PRAGMA_OMP_CLAUSE_SHARED) \
8626 | (1u << PRAGMA_OMP_CLAUSE_COPYIN) \
8627 | (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \
8628 | (1u << PRAGMA_OMP_CLAUSE_NUM_THREADS))
8631 c_parser_omp_parallel (location_t loc
, c_parser
*parser
)
8633 enum pragma_kind p_kind
= PRAGMA_OMP_PARALLEL
;
8634 const char *p_name
= "#pragma omp parallel";
8635 tree stmt
, clauses
, par_clause
, ws_clause
, block
;
8636 unsigned int mask
= OMP_PARALLEL_CLAUSE_MASK
;
8638 if (c_parser_next_token_is_keyword (parser
, RID_FOR
))
8640 c_parser_consume_token (parser
);
8641 p_kind
= PRAGMA_OMP_PARALLEL_FOR
;
8642 p_name
= "#pragma omp parallel for";
8643 mask
|= OMP_FOR_CLAUSE_MASK
;
8644 mask
&= ~(1u << PRAGMA_OMP_CLAUSE_NOWAIT
);
8646 else if (c_parser_next_token_is (parser
, CPP_NAME
))
8648 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
8649 if (strcmp (p
, "sections") == 0)
8651 c_parser_consume_token (parser
);
8652 p_kind
= PRAGMA_OMP_PARALLEL_SECTIONS
;
8653 p_name
= "#pragma omp parallel sections";
8654 mask
|= OMP_SECTIONS_CLAUSE_MASK
;
8655 mask
&= ~(1u << PRAGMA_OMP_CLAUSE_NOWAIT
);
8659 clauses
= c_parser_omp_all_clauses (parser
, mask
, p_name
);
8663 case PRAGMA_OMP_PARALLEL
:
8664 block
= c_begin_omp_parallel ();
8665 c_parser_statement (parser
);
8666 stmt
= c_finish_omp_parallel (loc
, clauses
, block
);
8669 case PRAGMA_OMP_PARALLEL_FOR
:
8670 block
= c_begin_omp_parallel ();
8671 c_split_parallel_clauses (loc
, clauses
, &par_clause
, &ws_clause
);
8672 c_parser_omp_for_loop (loc
, parser
, ws_clause
, &par_clause
);
8673 stmt
= c_finish_omp_parallel (loc
, par_clause
, block
);
8674 OMP_PARALLEL_COMBINED (stmt
) = 1;
8677 case PRAGMA_OMP_PARALLEL_SECTIONS
:
8678 block
= c_begin_omp_parallel ();
8679 c_split_parallel_clauses (loc
, clauses
, &par_clause
, &ws_clause
);
8680 stmt
= c_parser_omp_sections_scope (loc
, parser
);
8682 OMP_SECTIONS_CLAUSES (stmt
) = ws_clause
;
8683 stmt
= c_finish_omp_parallel (loc
, par_clause
, block
);
8684 OMP_PARALLEL_COMBINED (stmt
) = 1;
8695 # pragma omp single single-clause[optseq] new-line
8698 LOC is the location of the #pragma.
8701 #define OMP_SINGLE_CLAUSE_MASK \
8702 ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
8703 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
8704 | (1u << PRAGMA_OMP_CLAUSE_COPYPRIVATE) \
8705 | (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
8708 c_parser_omp_single (location_t loc
, c_parser
*parser
)
8710 tree stmt
= make_node (OMP_SINGLE
);
8711 SET_EXPR_LOCATION (stmt
, loc
);
8712 TREE_TYPE (stmt
) = void_type_node
;
8714 OMP_SINGLE_CLAUSES (stmt
)
8715 = c_parser_omp_all_clauses (parser
, OMP_SINGLE_CLAUSE_MASK
,
8716 "#pragma omp single");
8717 OMP_SINGLE_BODY (stmt
) = c_parser_omp_structured_block (parser
);
8719 return add_stmt (stmt
);
8723 # pragma omp task task-clause[optseq] new-line
8725 LOC is the location of the #pragma.
8728 #define OMP_TASK_CLAUSE_MASK \
8729 ( (1u << PRAGMA_OMP_CLAUSE_IF) \
8730 | (1u << PRAGMA_OMP_CLAUSE_UNTIED) \
8731 | (1u << PRAGMA_OMP_CLAUSE_DEFAULT) \
8732 | (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
8733 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
8734 | (1u << PRAGMA_OMP_CLAUSE_SHARED))
8737 c_parser_omp_task (location_t loc
, c_parser
*parser
)
8739 tree clauses
, block
;
8741 clauses
= c_parser_omp_all_clauses (parser
, OMP_TASK_CLAUSE_MASK
,
8742 "#pragma omp task");
8744 block
= c_begin_omp_task ();
8745 c_parser_statement (parser
);
8746 return c_finish_omp_task (loc
, clauses
, block
);
8750 # pragma omp taskwait new-line
8754 c_parser_omp_taskwait (c_parser
*parser
)
8756 location_t loc
= c_parser_peek_token (parser
)->location
;
8757 c_parser_consume_pragma (parser
);
8758 c_parser_skip_to_pragma_eol (parser
);
8760 c_finish_omp_taskwait (loc
);
8763 /* Main entry point to parsing most OpenMP pragmas. */
8766 c_parser_omp_construct (c_parser
*parser
)
8768 enum pragma_kind p_kind
;
8772 loc
= c_parser_peek_token (parser
)->location
;
8773 p_kind
= c_parser_peek_token (parser
)->pragma_kind
;
8774 c_parser_consume_pragma (parser
);
8778 case PRAGMA_OMP_ATOMIC
:
8779 c_parser_omp_atomic (loc
, parser
);
8781 case PRAGMA_OMP_CRITICAL
:
8782 stmt
= c_parser_omp_critical (loc
, parser
);
8784 case PRAGMA_OMP_FOR
:
8785 stmt
= c_parser_omp_for (loc
, parser
);
8787 case PRAGMA_OMP_MASTER
:
8788 stmt
= c_parser_omp_master (loc
, parser
);
8790 case PRAGMA_OMP_ORDERED
:
8791 stmt
= c_parser_omp_ordered (loc
, parser
);
8793 case PRAGMA_OMP_PARALLEL
:
8794 stmt
= c_parser_omp_parallel (loc
, parser
);
8796 case PRAGMA_OMP_SECTIONS
:
8797 stmt
= c_parser_omp_sections (loc
, parser
);
8799 case PRAGMA_OMP_SINGLE
:
8800 stmt
= c_parser_omp_single (loc
, parser
);
8802 case PRAGMA_OMP_TASK
:
8803 stmt
= c_parser_omp_task (loc
, parser
);
8810 gcc_assert (EXPR_LOCATION (stmt
) != UNKNOWN_LOCATION
);
8815 # pragma omp threadprivate (variable-list) */
8818 c_parser_omp_threadprivate (c_parser
*parser
)
8823 c_parser_consume_pragma (parser
);
8824 loc
= c_parser_peek_token (parser
)->location
;
8825 vars
= c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_ERROR
, NULL
);
8827 /* Mark every variable in VARS to be assigned thread local storage. */
8828 for (t
= vars
; t
; t
= TREE_CHAIN (t
))
8830 tree v
= TREE_PURPOSE (t
);
8832 /* FIXME diagnostics: Ideally we should keep individual
8833 locations for all the variables in the var list to make the
8834 following errors more precise. Perhaps
8835 c_parser_omp_var_list_parens() should construct a list of
8836 locations to go along with the var list. */
8838 /* If V had already been marked threadprivate, it doesn't matter
8839 whether it had been used prior to this point. */
8840 if (TREE_CODE (v
) != VAR_DECL
)
8841 error_at (loc
, "%qD is not a variable", v
);
8842 else if (TREE_USED (v
) && !C_DECL_THREADPRIVATE_P (v
))
8843 error_at (loc
, "%qE declared %<threadprivate%> after first use", v
);
8844 else if (! TREE_STATIC (v
) && ! DECL_EXTERNAL (v
))
8845 error_at (loc
, "automatic variable %qE cannot be %<threadprivate%>", v
);
8846 else if (TREE_TYPE (v
) == error_mark_node
)
8848 else if (! COMPLETE_TYPE_P (TREE_TYPE (v
)))
8849 error_at (loc
, "%<threadprivate%> %qE has incomplete type", v
);
8852 if (! DECL_THREAD_LOCAL_P (v
))
8854 DECL_TLS_MODEL (v
) = decl_default_tls_model (v
);
8855 /* If rtl has been already set for this var, call
8856 make_decl_rtl once again, so that encode_section_info
8857 has a chance to look at the new decl flags. */
8858 if (DECL_RTL_SET_P (v
))
8861 C_DECL_THREADPRIVATE_P (v
) = 1;
8865 c_parser_skip_to_pragma_eol (parser
);
8869 /* Parse a single source file. */
8874 /* Use local storage to begin. If the first token is a pragma, parse it.
8875 If it is #pragma GCC pch_preprocess, then this will load a PCH file
8876 which will cause garbage collection. */
8879 memset (&tparser
, 0, sizeof tparser
);
8880 the_parser
= &tparser
;
8882 if (c_parser_peek_token (&tparser
)->pragma_kind
== PRAGMA_GCC_PCH_PREPROCESS
)
8883 c_parser_pragma_pch_preprocess (&tparser
);
8885 the_parser
= ggc_alloc_c_parser ();
8886 *the_parser
= tparser
;
8888 /* Initialize EH, if we've been told to do so. */
8889 if (flag_exceptions
)
8890 using_eh_for_cleanups ();
8892 c_parser_translation_unit (the_parser
);
8896 #include "gt-c-parser.h"