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
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"
46 #include "langhooks.h"
63 /* Initialization routine for this file. */
68 /* The only initialization required is of the reserved word
79 mask
|= D_ASM
| D_EXT
;
83 if (!c_dialect_objc ())
84 mask
|= D_OBJC
| D_CXX_OBJC
;
86 ridpointers
= GGC_CNEWVEC (tree
, (int) RID_MAX
);
87 for (i
= 0; i
< num_c_common_reswords
; i
++)
89 /* If a keyword is disabled, do not enter it into the table
90 and so create a canonical spelling that isn't a keyword. */
91 if (c_common_reswords
[i
].disable
& mask
)
94 && (c_common_reswords
[i
].disable
& D_CXXWARN
))
96 id
= get_identifier (c_common_reswords
[i
].word
);
97 C_SET_RID_CODE (id
, RID_CXX_COMPAT_WARN
);
98 C_IS_RESERVED_WORD (id
) = 1;
103 id
= get_identifier (c_common_reswords
[i
].word
);
104 C_SET_RID_CODE (id
, c_common_reswords
[i
].rid
);
105 C_IS_RESERVED_WORD (id
) = 1;
106 ridpointers
[(int) c_common_reswords
[i
].rid
] = id
;
110 /* The C lexer intermediates between the lexer in cpplib and c-lex.c
111 and the C parser. Unlike the C++ lexer, the parser structure
112 stores the lexer information instead of using a separate structure.
113 Identifiers are separated into ordinary identifiers, type names,
114 keywords and some other Objective-C types of identifiers, and some
115 look-ahead is maintained.
117 ??? It might be a good idea to lex the whole file up front (as for
118 C++). It would then be possible to share more of the C and C++
119 lexer code, if desired. */
121 /* The following local token type is used. */
124 #define CPP_KEYWORD ((enum cpp_ttype) (N_TTYPES + 1))
126 /* More information about the type of a CPP_NAME token. */
127 typedef enum c_id_kind
{
128 /* An ordinary identifier. */
130 /* An identifier declared as a typedef name. */
132 /* An identifier declared as an Objective-C class name. */
134 /* Not an identifier. */
138 /* A single C token after string literal concatenation and conversion
139 of preprocessing tokens to tokens. */
140 typedef struct GTY (()) c_token
{
141 /* The kind of token. */
142 ENUM_BITFIELD (cpp_ttype
) type
: 8;
143 /* If this token is a CPP_NAME, this value indicates whether also
144 declared as some kind of type. Otherwise, it is C_ID_NONE. */
145 ENUM_BITFIELD (c_id_kind
) id_kind
: 8;
146 /* If this token is a keyword, this value indicates which keyword.
147 Otherwise, this value is RID_MAX. */
148 ENUM_BITFIELD (rid
) keyword
: 8;
149 /* If this token is a CPP_PRAGMA, this indicates the pragma that
150 was seen. Otherwise it is PRAGMA_NONE. */
151 ENUM_BITFIELD (pragma_kind
) pragma_kind
: 8;
152 /* The value associated with this token, if any. */
154 /* The location at which this token was found. */
158 /* A parser structure recording information about the state and
159 context of parsing. Includes lexer information with up to two
160 tokens of look-ahead; more are not needed for C. */
161 typedef struct GTY(()) c_parser
{
162 /* The look-ahead tokens. */
164 /* How many look-ahead tokens are available (0, 1 or 2). */
166 /* True if a syntax error is being recovered from; false otherwise.
167 c_parser_error sets this flag. It should clear this flag when
168 enough tokens have been consumed to recover from the error. */
169 BOOL_BITFIELD error
: 1;
170 /* True if we're processing a pragma, and shouldn't automatically
171 consume CPP_PRAGMA_EOL. */
172 BOOL_BITFIELD in_pragma
: 1;
173 /* True if we're parsing the outermost block of an if statement. */
174 BOOL_BITFIELD in_if_block
: 1;
175 /* True if we want to lex an untranslated string. */
176 BOOL_BITFIELD lex_untranslated_string
: 1;
177 /* Objective-C specific parser/lexer information. */
178 BOOL_BITFIELD objc_pq_context
: 1;
179 /* The following flag is needed to contextualize Objective-C lexical
180 analysis. In some cases (e.g., 'int NSObject;'), it is
181 undesirable to bind an identifier to an Objective-C class, even
182 if a class with that name exists. */
183 BOOL_BITFIELD objc_need_raw_identifier
: 1;
187 /* The actual parser and external interface. ??? Does this need to be
188 garbage-collected? */
190 static GTY (()) c_parser
*the_parser
;
193 /* Read in and lex a single token, storing it in *TOKEN. */
196 c_lex_one_token (c_parser
*parser
, c_token
*token
)
198 timevar_push (TV_LEX
);
200 token
->type
= c_lex_with_flags (&token
->value
, &token
->location
, NULL
,
201 (parser
->lex_untranslated_string
202 ? C_LEX_STRING_NO_TRANSLATE
: 0));
203 token
->id_kind
= C_ID_NONE
;
204 token
->keyword
= RID_MAX
;
205 token
->pragma_kind
= PRAGMA_NONE
;
213 bool objc_force_identifier
= parser
->objc_need_raw_identifier
;
214 if (c_dialect_objc ())
215 parser
->objc_need_raw_identifier
= false;
217 if (C_IS_RESERVED_WORD (token
->value
))
219 enum rid rid_code
= C_RID_CODE (token
->value
);
221 if (rid_code
== RID_CXX_COMPAT_WARN
)
223 warning_at (token
->location
,
225 "identifier %qs conflicts with C++ keyword",
226 IDENTIFIER_POINTER (token
->value
));
228 else if (c_dialect_objc ())
230 if (!objc_is_reserved_word (token
->value
)
231 && (!OBJC_IS_PQ_KEYWORD (rid_code
)
232 || parser
->objc_pq_context
))
234 /* Return the canonical spelling for this keyword. */
235 token
->value
= ridpointers
[(int) rid_code
];
236 token
->type
= CPP_KEYWORD
;
237 token
->keyword
= rid_code
;
243 token
->type
= CPP_KEYWORD
;
244 token
->keyword
= rid_code
;
249 decl
= lookup_name (token
->value
);
252 if (TREE_CODE (decl
) == TYPE_DECL
)
254 token
->id_kind
= C_ID_TYPENAME
;
258 else if (c_dialect_objc ())
260 tree objc_interface_decl
= objc_is_class_name (token
->value
);
261 /* Objective-C class names are in the same namespace as
262 variables and typedefs, and hence are shadowed by local
264 if (objc_interface_decl
265 && (global_bindings_p ()
266 || (!objc_force_identifier
&& !decl
)))
268 token
->value
= objc_interface_decl
;
269 token
->id_kind
= C_ID_CLASSNAME
;
273 token
->id_kind
= C_ID_ID
;
277 /* This only happens in Objective-C; it must be a keyword. */
278 token
->type
= CPP_KEYWORD
;
279 token
->keyword
= C_RID_CODE (token
->value
);
283 case CPP_CLOSE_PAREN
:
285 /* These tokens may affect the interpretation of any identifiers
286 following, if doing Objective-C. */
287 if (c_dialect_objc ())
288 parser
->objc_need_raw_identifier
= false;
291 /* We smuggled the cpp_token->u.pragma value in an INTEGER_CST. */
292 token
->pragma_kind
= (enum pragma_kind
) TREE_INT_CST_LOW (token
->value
);
298 timevar_pop (TV_LEX
);
301 /* Return a pointer to the next token from PARSER, reading it in if
304 static inline c_token
*
305 c_parser_peek_token (c_parser
*parser
)
307 if (parser
->tokens_avail
== 0)
309 c_lex_one_token (parser
, &parser
->tokens
[0]);
310 parser
->tokens_avail
= 1;
312 return &parser
->tokens
[0];
315 /* Return true if the next token from PARSER has the indicated
319 c_parser_next_token_is (c_parser
*parser
, enum cpp_ttype type
)
321 return c_parser_peek_token (parser
)->type
== type
;
324 /* Return true if the next token from PARSER does not have the
328 c_parser_next_token_is_not (c_parser
*parser
, enum cpp_ttype type
)
330 return !c_parser_next_token_is (parser
, type
);
333 /* Return true if the next token from PARSER is the indicated
337 c_parser_next_token_is_keyword (c_parser
*parser
, enum rid keyword
)
339 return c_parser_peek_token (parser
)->keyword
== keyword
;
342 /* Return true if TOKEN can start a type name,
345 c_token_starts_typename (c_token
*token
)
350 switch (token
->id_kind
)
357 gcc_assert (c_dialect_objc ());
363 switch (token
->keyword
)
395 if (c_dialect_objc ())
403 /* Return true if the next token from PARSER can start a type name,
406 c_parser_next_token_starts_typename (c_parser
*parser
)
408 c_token
*token
= c_parser_peek_token (parser
);
409 return c_token_starts_typename (token
);
412 /* Return true if TOKEN can start declaration specifiers, false
415 c_token_starts_declspecs (c_token
*token
)
420 switch (token
->id_kind
)
427 gcc_assert (c_dialect_objc ());
433 switch (token
->keyword
)
472 if (c_dialect_objc ())
480 /* Return true if the next token from PARSER can start declaration
481 specifiers, false otherwise. */
483 c_parser_next_token_starts_declspecs (c_parser
*parser
)
485 c_token
*token
= c_parser_peek_token (parser
);
486 return c_token_starts_declspecs (token
);
489 /* Return a pointer to the next-but-one token from PARSER, reading it
490 in if necessary. The next token is already read in. */
493 c_parser_peek_2nd_token (c_parser
*parser
)
495 if (parser
->tokens_avail
>= 2)
496 return &parser
->tokens
[1];
497 gcc_assert (parser
->tokens_avail
== 1);
498 gcc_assert (parser
->tokens
[0].type
!= CPP_EOF
);
499 gcc_assert (parser
->tokens
[0].type
!= CPP_PRAGMA_EOL
);
500 c_lex_one_token (parser
, &parser
->tokens
[1]);
501 parser
->tokens_avail
= 2;
502 return &parser
->tokens
[1];
505 /* Consume the next token from PARSER. */
508 c_parser_consume_token (c_parser
*parser
)
510 gcc_assert (parser
->tokens_avail
>= 1);
511 gcc_assert (parser
->tokens
[0].type
!= CPP_EOF
);
512 gcc_assert (!parser
->in_pragma
|| parser
->tokens
[0].type
!= CPP_PRAGMA_EOL
);
513 gcc_assert (parser
->error
|| parser
->tokens
[0].type
!= CPP_PRAGMA
);
514 if (parser
->tokens_avail
== 2)
515 parser
->tokens
[0] = parser
->tokens
[1];
516 parser
->tokens_avail
--;
519 /* Expect the current token to be a #pragma. Consume it and remember
520 that we've begun parsing a pragma. */
523 c_parser_consume_pragma (c_parser
*parser
)
525 gcc_assert (!parser
->in_pragma
);
526 gcc_assert (parser
->tokens_avail
>= 1);
527 gcc_assert (parser
->tokens
[0].type
== CPP_PRAGMA
);
528 if (parser
->tokens_avail
== 2)
529 parser
->tokens
[0] = parser
->tokens
[1];
530 parser
->tokens_avail
--;
531 parser
->in_pragma
= true;
534 /* Update the globals input_location and in_system_header from
537 c_parser_set_source_position_from_token (c_token
*token
)
539 if (token
->type
!= CPP_EOF
)
541 input_location
= token
->location
;
545 /* Issue a diagnostic of the form
546 FILE:LINE: MESSAGE before TOKEN
547 where TOKEN is the next token in the input stream of PARSER.
548 MESSAGE (specified by the caller) is usually of the form "expected
551 Do not issue a diagnostic if still recovering from an error.
553 ??? This is taken from the C++ parser, but building up messages in
554 this way is not i18n-friendly and some other approach should be
558 c_parser_error (c_parser
*parser
, const char *gmsgid
)
560 c_token
*token
= c_parser_peek_token (parser
);
563 parser
->error
= true;
566 /* This diagnostic makes more sense if it is tagged to the line of
567 the token we just peeked at. */
568 c_parser_set_source_position_from_token (token
);
569 c_parse_error (gmsgid
,
570 /* Because c_parse_error does not understand
571 CPP_KEYWORD, keywords are treated like
573 (token
->type
== CPP_KEYWORD
? CPP_NAME
: token
->type
),
574 /* ??? The C parser does not save the cpp flags of a
575 token, we need to pass 0 here and we will not get
576 the source spelling of some tokens but rather the
577 canonical spelling. */
578 token
->value
, /*flags=*/0);
581 /* If the next token is of the indicated TYPE, consume it. Otherwise,
582 issue the error MSGID. If MSGID is NULL then a message has already
583 been produced and no message will be produced this time. Returns
584 true if found, false otherwise. */
587 c_parser_require (c_parser
*parser
,
591 if (c_parser_next_token_is (parser
, type
))
593 c_parser_consume_token (parser
);
598 c_parser_error (parser
, msgid
);
603 /* If the next token is the indicated keyword, consume it. Otherwise,
604 issue the error MSGID. Returns true if found, false otherwise. */
607 c_parser_require_keyword (c_parser
*parser
,
611 if (c_parser_next_token_is_keyword (parser
, keyword
))
613 c_parser_consume_token (parser
);
618 c_parser_error (parser
, msgid
);
623 /* Like c_parser_require, except that tokens will be skipped until the
624 desired token is found. An error message is still produced if the
625 next token is not as expected. If MSGID is NULL then a message has
626 already been produced and no message will be produced this
630 c_parser_skip_until_found (c_parser
*parser
,
634 unsigned nesting_depth
= 0;
636 if (c_parser_require (parser
, type
, msgid
))
639 /* Skip tokens until the desired token is found. */
642 /* Peek at the next token. */
643 c_token
*token
= c_parser_peek_token (parser
);
644 /* If we've reached the token we want, consume it and stop. */
645 if (token
->type
== type
&& !nesting_depth
)
647 c_parser_consume_token (parser
);
651 /* If we've run out of tokens, stop. */
652 if (token
->type
== CPP_EOF
)
654 if (token
->type
== CPP_PRAGMA_EOL
&& parser
->in_pragma
)
656 if (token
->type
== CPP_OPEN_BRACE
657 || token
->type
== CPP_OPEN_PAREN
658 || token
->type
== CPP_OPEN_SQUARE
)
660 else if (token
->type
== CPP_CLOSE_BRACE
661 || token
->type
== CPP_CLOSE_PAREN
662 || token
->type
== CPP_CLOSE_SQUARE
)
664 if (nesting_depth
-- == 0)
667 /* Consume this token. */
668 c_parser_consume_token (parser
);
670 parser
->error
= false;
673 /* Skip tokens until the end of a parameter is found, but do not
674 consume the comma, semicolon or closing delimiter. */
677 c_parser_skip_to_end_of_parameter (c_parser
*parser
)
679 unsigned nesting_depth
= 0;
683 c_token
*token
= c_parser_peek_token (parser
);
684 if ((token
->type
== CPP_COMMA
|| token
->type
== CPP_SEMICOLON
)
687 /* If we've run out of tokens, stop. */
688 if (token
->type
== CPP_EOF
)
690 if (token
->type
== CPP_PRAGMA_EOL
&& parser
->in_pragma
)
692 if (token
->type
== CPP_OPEN_BRACE
693 || token
->type
== CPP_OPEN_PAREN
694 || token
->type
== CPP_OPEN_SQUARE
)
696 else if (token
->type
== CPP_CLOSE_BRACE
697 || token
->type
== CPP_CLOSE_PAREN
698 || token
->type
== CPP_CLOSE_SQUARE
)
700 if (nesting_depth
-- == 0)
703 /* Consume this token. */
704 c_parser_consume_token (parser
);
706 parser
->error
= false;
709 /* Expect to be at the end of the pragma directive and consume an
710 end of line marker. */
713 c_parser_skip_to_pragma_eol (c_parser
*parser
)
715 gcc_assert (parser
->in_pragma
);
716 parser
->in_pragma
= false;
718 if (!c_parser_require (parser
, CPP_PRAGMA_EOL
, "expected end of line"))
721 c_token
*token
= c_parser_peek_token (parser
);
722 if (token
->type
== CPP_EOF
)
724 if (token
->type
== CPP_PRAGMA_EOL
)
726 c_parser_consume_token (parser
);
729 c_parser_consume_token (parser
);
732 parser
->error
= false;
735 /* Skip tokens until we have consumed an entire block, or until we
736 have consumed a non-nested ';'. */
739 c_parser_skip_to_end_of_block_or_statement (c_parser
*parser
)
741 unsigned nesting_depth
= 0;
742 bool save_error
= parser
->error
;
748 /* Peek at the next token. */
749 token
= c_parser_peek_token (parser
);
757 if (parser
->in_pragma
)
762 /* If the next token is a ';', we have reached the
763 end of the statement. */
766 /* Consume the ';'. */
767 c_parser_consume_token (parser
);
772 case CPP_CLOSE_BRACE
:
773 /* If the next token is a non-nested '}', then we have
774 reached the end of the current block. */
775 if (nesting_depth
== 0 || --nesting_depth
== 0)
777 c_parser_consume_token (parser
);
783 /* If it the next token is a '{', then we are entering a new
784 block. Consume the entire block. */
789 /* If we see a pragma, consume the whole thing at once. We
790 have some safeguards against consuming pragmas willy-nilly.
791 Normally, we'd expect to be here with parser->error set,
792 which disables these safeguards. But it's possible to get
793 here for secondary error recovery, after parser->error has
795 c_parser_consume_pragma (parser
);
796 c_parser_skip_to_pragma_eol (parser
);
797 parser
->error
= save_error
;
804 c_parser_consume_token (parser
);
808 parser
->error
= false;
811 /* CPP's options (initialized by c-opts.c). */
812 extern cpp_options
*cpp_opts
;
814 /* Save the warning flags which are controlled by __extension__. */
817 disable_extension_diagnostics (void)
820 | (warn_pointer_arith
<< 1)
821 | (warn_traditional
<< 2)
823 | (warn_long_long
<< 4));
824 cpp_opts
->pedantic
= pedantic
= 0;
825 warn_pointer_arith
= 0;
826 cpp_opts
->warn_traditional
= warn_traditional
= 0;
828 cpp_opts
->warn_long_long
= warn_long_long
= 0;
832 /* Restore the warning flags which are controlled by __extension__.
833 FLAGS is the return value from disable_extension_diagnostics. */
836 restore_extension_diagnostics (int flags
)
838 cpp_opts
->pedantic
= pedantic
= flags
& 1;
839 warn_pointer_arith
= (flags
>> 1) & 1;
840 cpp_opts
->warn_traditional
= warn_traditional
= (flags
>> 2) & 1;
841 flag_iso
= (flags
>> 3) & 1;
842 cpp_opts
->warn_long_long
= warn_long_long
= (flags
>> 4) & 1;
845 /* Possibly kinds of declarator to parse. */
846 typedef enum c_dtr_syn
{
847 /* A normal declarator with an identifier. */
849 /* An abstract declarator (maybe empty). */
851 /* A parameter declarator: may be either, but after a type name does
852 not redeclare a typedef name as an identifier if it can
853 alternatively be interpreted as a typedef name; see DR#009,
854 applied in C90 TC1, omitted from C99 and reapplied in C99 TC2
855 following DR#249. For example, given a typedef T, "int T" and
856 "int *T" are valid parameter declarations redeclaring T, while
857 "int (T)" and "int * (T)" and "int (T[])" and "int (T (int))" are
858 abstract declarators rather than involving redundant parentheses;
859 the same applies with attributes inside the parentheses before
864 static void c_parser_external_declaration (c_parser
*);
865 static void c_parser_asm_definition (c_parser
*);
866 static void c_parser_declaration_or_fndef (c_parser
*, bool, bool, bool, bool);
867 static void c_parser_declspecs (c_parser
*, struct c_declspecs
*, bool, bool,
869 static struct c_typespec
c_parser_enum_specifier (c_parser
*);
870 static struct c_typespec
c_parser_struct_or_union_specifier (c_parser
*);
871 static tree
c_parser_struct_declaration (c_parser
*);
872 static struct c_typespec
c_parser_typeof_specifier (c_parser
*);
873 static struct c_declarator
*c_parser_declarator (c_parser
*, bool, c_dtr_syn
,
875 static struct c_declarator
*c_parser_direct_declarator (c_parser
*, bool,
877 static struct c_declarator
*c_parser_direct_declarator_inner (c_parser
*,
879 struct c_declarator
*);
880 static struct c_arg_info
*c_parser_parms_declarator (c_parser
*, bool, tree
);
881 static struct c_arg_info
*c_parser_parms_list_declarator (c_parser
*, tree
);
882 static struct c_parm
*c_parser_parameter_declaration (c_parser
*, tree
);
883 static tree
c_parser_simple_asm_expr (c_parser
*);
884 static tree
c_parser_attributes (c_parser
*);
885 static struct c_type_name
*c_parser_type_name (c_parser
*);
886 static struct c_expr
c_parser_initializer (c_parser
*);
887 static struct c_expr
c_parser_braced_init (c_parser
*, tree
, bool);
888 static void c_parser_initelt (c_parser
*);
889 static void c_parser_initval (c_parser
*, struct c_expr
*);
890 static tree
c_parser_compound_statement (c_parser
*);
891 static void c_parser_compound_statement_nostart (c_parser
*);
892 static void c_parser_label (c_parser
*);
893 static void c_parser_statement (c_parser
*);
894 static void c_parser_statement_after_labels (c_parser
*);
895 static void c_parser_if_statement (c_parser
*);
896 static void c_parser_switch_statement (c_parser
*);
897 static void c_parser_while_statement (c_parser
*);
898 static void c_parser_do_statement (c_parser
*);
899 static void c_parser_for_statement (c_parser
*);
900 static tree
c_parser_asm_statement (c_parser
*);
901 static tree
c_parser_asm_operands (c_parser
*, bool);
902 static tree
c_parser_asm_clobbers (c_parser
*);
903 static struct c_expr
c_parser_expr_no_commas (c_parser
*, struct c_expr
*);
904 static struct c_expr
c_parser_conditional_expression (c_parser
*,
906 static struct c_expr
c_parser_binary_expression (c_parser
*, struct c_expr
*);
907 static struct c_expr
c_parser_cast_expression (c_parser
*, struct c_expr
*);
908 static struct c_expr
c_parser_unary_expression (c_parser
*);
909 static struct c_expr
c_parser_sizeof_expression (c_parser
*);
910 static struct c_expr
c_parser_alignof_expression (c_parser
*);
911 static struct c_expr
c_parser_postfix_expression (c_parser
*);
912 static struct c_expr
c_parser_postfix_expression_after_paren_type (c_parser
*,
913 struct c_type_name
*);
914 static struct c_expr
c_parser_postfix_expression_after_primary (c_parser
*,
916 static struct c_expr
c_parser_expression (c_parser
*);
917 static struct c_expr
c_parser_expression_conv (c_parser
*);
918 static VEC(tree
,gc
) *c_parser_expr_list (c_parser
*, bool, bool,
920 static void c_parser_release_expr_list (VEC(tree
,gc
) *);
921 static tree
c_parser_vec_to_tree_list (VEC(tree
,gc
) *);
922 static void c_parser_omp_construct (c_parser
*);
923 static void c_parser_omp_threadprivate (c_parser
*);
924 static void c_parser_omp_barrier (c_parser
*);
925 static void c_parser_omp_flush (c_parser
*);
926 static void c_parser_omp_taskwait (c_parser
*);
928 enum pragma_context
{ pragma_external
, pragma_stmt
, pragma_compound
};
929 static bool c_parser_pragma (c_parser
*, enum pragma_context
);
931 /* These Objective-C parser functions are only ever called when
932 compiling Objective-C. */
933 static void c_parser_objc_class_definition (c_parser
*);
934 static void c_parser_objc_class_instance_variables (c_parser
*);
935 static void c_parser_objc_class_declaration (c_parser
*);
936 static void c_parser_objc_alias_declaration (c_parser
*);
937 static void c_parser_objc_protocol_definition (c_parser
*);
938 static enum tree_code
c_parser_objc_method_type (c_parser
*);
939 static void c_parser_objc_method_definition (c_parser
*);
940 static void c_parser_objc_methodprotolist (c_parser
*);
941 static void c_parser_objc_methodproto (c_parser
*);
942 static tree
c_parser_objc_method_decl (c_parser
*);
943 static tree
c_parser_objc_type_name (c_parser
*);
944 static tree
c_parser_objc_protocol_refs (c_parser
*);
945 static void c_parser_objc_try_catch_statement (c_parser
*);
946 static void c_parser_objc_synchronized_statement (c_parser
*);
947 static tree
c_parser_objc_selector (c_parser
*);
948 static tree
c_parser_objc_selector_arg (c_parser
*);
949 static tree
c_parser_objc_receiver (c_parser
*);
950 static tree
c_parser_objc_message_args (c_parser
*);
951 static tree
c_parser_objc_keywordexpr (c_parser
*);
953 /* Parse a translation unit (C90 6.7, C99 6.9).
956 external-declarations
958 external-declarations:
960 external-declarations external-declaration
969 c_parser_translation_unit (c_parser
*parser
)
971 if (c_parser_next_token_is (parser
, CPP_EOF
))
973 pedwarn (c_parser_peek_token (parser
)->location
, OPT_pedantic
,
974 "ISO C forbids an empty translation unit");
978 void *obstack_position
= obstack_alloc (&parser_obstack
, 0);
982 c_parser_external_declaration (parser
);
983 obstack_free (&parser_obstack
, obstack_position
);
985 while (c_parser_next_token_is_not (parser
, CPP_EOF
));
989 /* Parse an external declaration (C90 6.7, C99 6.9).
991 external-declaration:
997 external-declaration:
1000 __extension__ external-declaration
1004 external-declaration:
1005 objc-class-definition
1006 objc-class-declaration
1007 objc-alias-declaration
1008 objc-protocol-definition
1009 objc-method-definition
1014 c_parser_external_declaration (c_parser
*parser
)
1017 switch (c_parser_peek_token (parser
)->type
)
1020 switch (c_parser_peek_token (parser
)->keyword
)
1023 ext
= disable_extension_diagnostics ();
1024 c_parser_consume_token (parser
);
1025 c_parser_external_declaration (parser
);
1026 restore_extension_diagnostics (ext
);
1029 c_parser_asm_definition (parser
);
1031 case RID_AT_INTERFACE
:
1032 case RID_AT_IMPLEMENTATION
:
1033 gcc_assert (c_dialect_objc ());
1034 c_parser_objc_class_definition (parser
);
1037 gcc_assert (c_dialect_objc ());
1038 c_parser_objc_class_declaration (parser
);
1041 gcc_assert (c_dialect_objc ());
1042 c_parser_objc_alias_declaration (parser
);
1044 case RID_AT_PROTOCOL
:
1045 gcc_assert (c_dialect_objc ());
1046 c_parser_objc_protocol_definition (parser
);
1049 gcc_assert (c_dialect_objc ());
1050 c_parser_consume_token (parser
);
1051 objc_finish_implementation ();
1058 pedwarn (c_parser_peek_token (parser
)->location
, OPT_pedantic
,
1059 "ISO C does not allow extra %<;%> outside of a function");
1060 c_parser_consume_token (parser
);
1063 c_parser_pragma (parser
, pragma_external
);
1067 if (c_dialect_objc ())
1069 c_parser_objc_method_definition (parser
);
1072 /* Else fall through, and yield a syntax error trying to parse
1073 as a declaration or function definition. */
1076 /* A declaration or a function definition. We can only tell
1077 which after parsing the declaration specifiers, if any, and
1078 the first declarator. */
1079 c_parser_declaration_or_fndef (parser
, true, true, false, true);
1085 /* Parse a declaration or function definition (C90 6.5, 6.7.1, C99
1086 6.7, 6.9.1). If FNDEF_OK is true, a function definition is
1087 accepted; otherwise (old-style parameter declarations) only other
1088 declarations are accepted. If NESTED is true, we are inside a
1089 function or parsing old-style parameter declarations; any functions
1090 encountered are nested functions and declaration specifiers are
1091 required; otherwise we are at top level and functions are normal
1092 functions and declaration specifiers may be optional. If EMPTY_OK
1093 is true, empty declarations are OK (subject to all other
1094 constraints); otherwise (old-style parameter declarations) they are
1095 diagnosed. If START_ATTR_OK is true, the declaration specifiers
1096 may start with attributes; otherwise they may not.
1099 declaration-specifiers init-declarator-list[opt] ;
1101 function-definition:
1102 declaration-specifiers[opt] declarator declaration-list[opt]
1107 declaration-list declaration
1109 init-declarator-list:
1111 init-declarator-list , init-declarator
1114 declarator simple-asm-expr[opt] attributes[opt]
1115 declarator simple-asm-expr[opt] attributes[opt] = initializer
1119 nested-function-definition:
1120 declaration-specifiers declarator declaration-list[opt]
1123 The simple-asm-expr and attributes are GNU extensions.
1125 This function does not handle __extension__; that is handled in its
1126 callers. ??? Following the old parser, __extension__ may start
1127 external declarations, declarations in functions and declarations
1128 at the start of "for" loops, but not old-style parameter
1131 C99 requires declaration specifiers in a function definition; the
1132 absence is diagnosed through the diagnosis of implicit int. In GNU
1133 C we also allow but diagnose declarations without declaration
1134 specifiers, but only at top level (elsewhere they conflict with
1140 threadprivate-directive */
1143 c_parser_declaration_or_fndef (c_parser
*parser
, bool fndef_ok
, bool empty_ok
,
1144 bool nested
, bool start_attr_ok
)
1146 struct c_declspecs
*specs
;
1148 tree all_prefix_attrs
;
1149 bool diagnosed_no_specs
= false;
1150 location_t here
= c_parser_peek_token (parser
)->location
;
1152 specs
= build_null_declspecs ();
1153 c_parser_declspecs (parser
, specs
, true, true, start_attr_ok
);
1156 c_parser_skip_to_end_of_block_or_statement (parser
);
1159 if (nested
&& !specs
->declspecs_seen_p
)
1161 c_parser_error (parser
, "expected declaration specifiers");
1162 c_parser_skip_to_end_of_block_or_statement (parser
);
1165 finish_declspecs (specs
);
1166 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
1172 shadow_tag_warned (specs
, 1);
1173 pedwarn (here
, 0, "empty declaration");
1175 c_parser_consume_token (parser
);
1178 pending_xref_error ();
1179 prefix_attrs
= specs
->attrs
;
1180 all_prefix_attrs
= prefix_attrs
;
1181 specs
->attrs
= NULL_TREE
;
1184 struct c_declarator
*declarator
;
1187 /* Declaring either one or more declarators (in which case we
1188 should diagnose if there were no declaration specifiers) or a
1189 function definition (in which case the diagnostic for
1190 implicit int suffices). */
1191 declarator
= c_parser_declarator (parser
, specs
->type_seen_p
,
1192 C_DTR_NORMAL
, &dummy
);
1193 if (declarator
== NULL
)
1195 c_parser_skip_to_end_of_block_or_statement (parser
);
1198 if (c_parser_next_token_is (parser
, CPP_EQ
)
1199 || c_parser_next_token_is (parser
, CPP_COMMA
)
1200 || c_parser_next_token_is (parser
, CPP_SEMICOLON
)
1201 || c_parser_next_token_is_keyword (parser
, RID_ASM
)
1202 || c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
1204 tree asm_name
= NULL_TREE
;
1205 tree postfix_attrs
= NULL_TREE
;
1206 if (!diagnosed_no_specs
&& !specs
->declspecs_seen_p
)
1208 diagnosed_no_specs
= true;
1209 pedwarn (here
, 0, "data definition has no type or storage class");
1211 /* Having seen a data definition, there cannot now be a
1212 function definition. */
1214 if (c_parser_next_token_is_keyword (parser
, RID_ASM
))
1215 asm_name
= c_parser_simple_asm_expr (parser
);
1216 if (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
1217 postfix_attrs
= c_parser_attributes (parser
);
1218 if (c_parser_next_token_is (parser
, CPP_EQ
))
1222 c_parser_consume_token (parser
);
1223 /* The declaration of the variable is in effect while
1224 its initializer is parsed. */
1225 d
= start_decl (declarator
, specs
, true,
1226 chainon (postfix_attrs
, all_prefix_attrs
));
1228 d
= error_mark_node
;
1229 start_init (d
, asm_name
, global_bindings_p ());
1230 init
= c_parser_initializer (parser
);
1232 if (d
!= error_mark_node
)
1234 maybe_warn_string_init (TREE_TYPE (d
), init
);
1235 finish_decl (d
, init
.value
, init
.original_type
, asm_name
);
1240 tree d
= start_decl (declarator
, specs
, false,
1241 chainon (postfix_attrs
,
1244 finish_decl (d
, NULL_TREE
, NULL_TREE
, asm_name
);
1246 if (c_parser_next_token_is (parser
, CPP_COMMA
))
1248 c_parser_consume_token (parser
);
1249 if (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
1250 all_prefix_attrs
= chainon (c_parser_attributes (parser
),
1253 all_prefix_attrs
= prefix_attrs
;
1256 else if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
1258 c_parser_consume_token (parser
);
1263 c_parser_error (parser
, "expected %<,%> or %<;%>");
1264 c_parser_skip_to_end_of_block_or_statement (parser
);
1270 c_parser_error (parser
, "expected %<=%>, %<,%>, %<;%>, "
1271 "%<asm%> or %<__attribute__%>");
1272 c_parser_skip_to_end_of_block_or_statement (parser
);
1275 /* Function definition (nested or otherwise). */
1278 pedwarn (here
, OPT_pedantic
, "ISO C forbids nested functions");
1279 c_push_function_context ();
1281 if (!start_function (specs
, declarator
, all_prefix_attrs
))
1283 /* This can appear in many cases looking nothing like a
1284 function definition, so we don't give a more specific
1285 error suggesting there was one. */
1286 c_parser_error (parser
, "expected %<=%>, %<,%>, %<;%>, %<asm%> "
1287 "or %<__attribute__%>");
1289 c_pop_function_context ();
1292 /* Parse old-style parameter declarations. ??? Attributes are
1293 not allowed to start declaration specifiers here because of a
1294 syntax conflict between a function declaration with attribute
1295 suffix and a function definition with an attribute prefix on
1296 first old-style parameter declaration. Following the old
1297 parser, they are not accepted on subsequent old-style
1298 parameter declarations either. However, there is no
1299 ambiguity after the first declaration, nor indeed on the
1300 first as long as we don't allow postfix attributes after a
1301 declarator with a nonempty identifier list in a definition;
1302 and postfix attributes have never been accepted here in
1303 function definitions either. */
1304 while (c_parser_next_token_is_not (parser
, CPP_EOF
)
1305 && c_parser_next_token_is_not (parser
, CPP_OPEN_BRACE
))
1306 c_parser_declaration_or_fndef (parser
, false, false, true, false);
1307 store_parm_decls ();
1308 DECL_STRUCT_FUNCTION (current_function_decl
)->function_start_locus
1309 = c_parser_peek_token (parser
)->location
;
1310 fnbody
= c_parser_compound_statement (parser
);
1313 tree decl
= current_function_decl
;
1316 c_pop_function_context ();
1317 add_stmt (build_stmt (DECL_EXPR
, decl
));
1328 /* Parse an asm-definition (asm() outside a function body). This is a
1336 c_parser_asm_definition (c_parser
*parser
)
1338 tree asm_str
= c_parser_simple_asm_expr (parser
);
1340 cgraph_add_asm_node (asm_str
);
1341 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
1344 /* Parse some declaration specifiers (possibly none) (C90 6.5, C99
1345 6.7), adding them to SPECS (which may already include some).
1346 Storage class specifiers are accepted iff SCSPEC_OK; type
1347 specifiers are accepted iff TYPESPEC_OK; attributes are accepted at
1348 the start iff START_ATTR_OK.
1350 declaration-specifiers:
1351 storage-class-specifier declaration-specifiers[opt]
1352 type-specifier declaration-specifiers[opt]
1353 type-qualifier declaration-specifiers[opt]
1354 function-specifier declaration-specifiers[opt]
1356 Function specifiers (inline) are from C99, and are currently
1357 handled as storage class specifiers, as is __thread.
1359 C90 6.5.1, C99 6.7.1:
1360 storage-class-specifier:
1371 C90 6.5.2, C99 6.7.2:
1384 [_Imaginary removed in C99 TC2]
1385 struct-or-union-specifier
1389 (_Bool and _Complex are new in C99.)
1391 C90 6.5.3, C99 6.7.3:
1398 (restrict is new in C99.)
1402 declaration-specifiers:
1403 attributes declaration-specifiers[opt]
1405 storage-class-specifier:
1417 (_Fract, _Accum, and _Sat are new from ISO/IEC DTR 18037:
1418 http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1169.pdf)
1423 class-name objc-protocol-refs[opt]
1424 typedef-name objc-protocol-refs
1429 c_parser_declspecs (c_parser
*parser
, struct c_declspecs
*specs
,
1430 bool scspec_ok
, bool typespec_ok
, bool start_attr_ok
)
1432 bool attrs_ok
= start_attr_ok
;
1433 bool seen_type
= specs
->type_seen_p
;
1434 while (c_parser_next_token_is (parser
, CPP_NAME
)
1435 || c_parser_next_token_is (parser
, CPP_KEYWORD
)
1436 || (c_dialect_objc () && c_parser_next_token_is (parser
, CPP_LESS
)))
1438 struct c_typespec t
;
1440 if (c_parser_next_token_is (parser
, CPP_NAME
))
1442 tree value
= c_parser_peek_token (parser
)->value
;
1443 c_id_kind kind
= c_parser_peek_token (parser
)->id_kind
;
1444 /* This finishes the specifiers unless a type name is OK, it
1445 is declared as a type name and a type name hasn't yet
1447 if (!typespec_ok
|| seen_type
1448 || (kind
!= C_ID_TYPENAME
&& kind
!= C_ID_CLASSNAME
))
1450 c_parser_consume_token (parser
);
1453 if (kind
== C_ID_TYPENAME
1454 && (!c_dialect_objc ()
1455 || c_parser_next_token_is_not (parser
, CPP_LESS
)))
1457 t
.kind
= ctsk_typedef
;
1458 /* For a typedef name, record the meaning, not the name.
1459 In case of 'foo foo, bar;'. */
1460 t
.spec
= lookup_name (value
);
1462 t
.expr_const_operands
= true;
1466 tree proto
= NULL_TREE
;
1467 gcc_assert (c_dialect_objc ());
1469 if (c_parser_next_token_is (parser
, CPP_LESS
))
1470 proto
= c_parser_objc_protocol_refs (parser
);
1471 t
.spec
= objc_get_protocol_qualified_type (value
, proto
);
1473 t
.expr_const_operands
= true;
1475 declspecs_add_type (specs
, t
);
1478 if (c_parser_next_token_is (parser
, CPP_LESS
))
1480 /* Make "<SomeProtocol>" equivalent to "id <SomeProtocol>" -
1481 nisse@lysator.liu.se. */
1483 gcc_assert (c_dialect_objc ());
1484 if (!typespec_ok
|| seen_type
)
1486 proto
= c_parser_objc_protocol_refs (parser
);
1488 t
.spec
= objc_get_protocol_qualified_type (NULL_TREE
, proto
);
1490 t
.expr_const_operands
= true;
1491 declspecs_add_type (specs
, t
);
1494 gcc_assert (c_parser_next_token_is (parser
, CPP_KEYWORD
));
1495 switch (c_parser_peek_token (parser
)->keyword
)
1507 /* TODO: Distinguish between function specifiers (inline)
1508 and storage class specifiers, either here or in
1509 declspecs_add_scspec. */
1510 declspecs_add_scspec (specs
, c_parser_peek_token (parser
)->value
);
1511 c_parser_consume_token (parser
);
1534 if (c_dialect_objc ())
1535 parser
->objc_need_raw_identifier
= true;
1536 t
.kind
= ctsk_resword
;
1537 t
.spec
= c_parser_peek_token (parser
)->value
;
1539 t
.expr_const_operands
= true;
1540 declspecs_add_type (specs
, t
);
1541 c_parser_consume_token (parser
);
1548 t
= c_parser_enum_specifier (parser
);
1549 declspecs_add_type (specs
, t
);
1557 t
= c_parser_struct_or_union_specifier (parser
);
1558 invoke_plugin_callbacks (PLUGIN_FINISH_TYPE
, t
.spec
);
1559 declspecs_add_type (specs
, t
);
1562 /* ??? The old parser rejected typeof after other type
1563 specifiers, but is a syntax error the best way of
1565 if (!typespec_ok
|| seen_type
)
1569 t
= c_parser_typeof_specifier (parser
);
1570 declspecs_add_type (specs
, t
);
1576 declspecs_add_qual (specs
, c_parser_peek_token (parser
)->value
);
1577 c_parser_consume_token (parser
);
1582 attrs
= c_parser_attributes (parser
);
1583 declspecs_add_attrs (specs
, attrs
);
1592 /* Parse an enum specifier (C90 6.5.2.2, C99 6.7.2.2).
1595 enum attributes[opt] identifier[opt] { enumerator-list } attributes[opt]
1596 enum attributes[opt] identifier[opt] { enumerator-list , } attributes[opt]
1597 enum attributes[opt] identifier
1599 The form with trailing comma is new in C99. The forms with
1600 attributes are GNU extensions. In GNU C, we accept any expression
1601 without commas in the syntax (assignment expressions, not just
1602 conditional expressions); assignment expressions will be diagnosed
1607 enumerator-list , enumerator
1610 enumeration-constant
1611 enumeration-constant = constant-expression
1614 static struct c_typespec
1615 c_parser_enum_specifier (c_parser
*parser
)
1617 struct c_typespec ret
;
1619 tree ident
= NULL_TREE
;
1620 location_t ident_loc
= UNKNOWN_LOCATION
; /* Quiet warning. */
1621 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_ENUM
));
1622 c_parser_consume_token (parser
);
1623 attrs
= c_parser_attributes (parser
);
1624 /* Set the location in case we create a decl now. */
1625 c_parser_set_source_position_from_token (c_parser_peek_token (parser
));
1626 if (c_parser_next_token_is (parser
, CPP_NAME
))
1628 ident
= c_parser_peek_token (parser
)->value
;
1629 ident_loc
= c_parser_peek_token (parser
)->location
;
1630 c_parser_consume_token (parser
);
1632 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
1634 /* Parse an enum definition. */
1635 struct c_enum_contents the_enum
;
1636 tree type
= start_enum (&the_enum
, ident
);
1638 /* We chain the enumerators in reverse order, then put them in
1639 forward order at the end. */
1640 tree values
= NULL_TREE
;
1641 c_parser_consume_token (parser
);
1649 location_t comma_loc
= UNKNOWN_LOCATION
; /* Quiet warning. */
1650 location_t value_loc
;
1651 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
1653 c_parser_error (parser
, "expected identifier");
1654 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
, NULL
);
1655 values
= error_mark_node
;
1658 token
= c_parser_peek_token (parser
);
1659 enum_id
= token
->value
;
1660 /* Set the location in case we create a decl now. */
1661 c_parser_set_source_position_from_token (token
);
1662 value_loc
= token
->location
;
1663 c_parser_consume_token (parser
);
1664 if (c_parser_next_token_is (parser
, CPP_EQ
))
1666 c_parser_consume_token (parser
);
1667 value_loc
= c_parser_peek_token (parser
)->location
;
1668 enum_value
= c_parser_expr_no_commas (parser
, NULL
).value
;
1671 enum_value
= NULL_TREE
;
1672 enum_decl
= build_enumerator (&the_enum
, enum_id
, enum_value
,
1674 TREE_CHAIN (enum_decl
) = values
;
1677 if (c_parser_next_token_is (parser
, CPP_COMMA
))
1679 comma_loc
= c_parser_peek_token (parser
)->location
;
1681 c_parser_consume_token (parser
);
1683 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
1685 if (seen_comma
&& !flag_isoc99
)
1686 pedwarn (comma_loc
, OPT_pedantic
, "comma at end of enumerator list");
1687 c_parser_consume_token (parser
);
1692 c_parser_error (parser
, "expected %<,%> or %<}%>");
1693 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
, NULL
);
1694 values
= error_mark_node
;
1698 postfix_attrs
= c_parser_attributes (parser
);
1699 ret
.spec
= finish_enum (type
, nreverse (values
),
1700 chainon (attrs
, postfix_attrs
));
1701 ret
.kind
= ctsk_tagdef
;
1702 ret
.expr
= NULL_TREE
;
1703 ret
.expr_const_operands
= true;
1708 c_parser_error (parser
, "expected %<{%>");
1709 ret
.spec
= error_mark_node
;
1710 ret
.kind
= ctsk_tagref
;
1711 ret
.expr
= NULL_TREE
;
1712 ret
.expr_const_operands
= true;
1715 ret
= parser_xref_tag (ENUMERAL_TYPE
, ident
);
1716 /* In ISO C, enumerated types can be referred to only if already
1718 if (pedantic
&& !COMPLETE_TYPE_P (ret
.spec
))
1721 pedwarn (ident_loc
, OPT_pedantic
,
1722 "ISO C forbids forward references to %<enum%> types");
1727 /* Parse a struct or union specifier (C90 6.5.2.1, C99 6.7.2.1).
1729 struct-or-union-specifier:
1730 struct-or-union attributes[opt] identifier[opt]
1731 { struct-contents } attributes[opt]
1732 struct-or-union attributes[opt] identifier
1735 struct-declaration-list
1737 struct-declaration-list:
1738 struct-declaration ;
1739 struct-declaration-list struct-declaration ;
1746 struct-declaration-list struct-declaration
1748 struct-declaration-list:
1749 struct-declaration-list ;
1752 (Note that in the syntax here, unlike that in ISO C, the semicolons
1753 are included here rather than in struct-declaration, in order to
1754 describe the syntax with extra semicolons and missing semicolon at
1759 struct-declaration-list:
1760 @defs ( class-name )
1762 (Note this does not include a trailing semicolon, but can be
1763 followed by further declarations, and gets a pedwarn-if-pedantic
1764 when followed by a semicolon.) */
1766 static struct c_typespec
1767 c_parser_struct_or_union_specifier (c_parser
*parser
)
1769 struct c_typespec ret
;
1771 tree ident
= NULL_TREE
;
1772 enum tree_code code
;
1773 switch (c_parser_peek_token (parser
)->keyword
)
1784 c_parser_consume_token (parser
);
1785 attrs
= c_parser_attributes (parser
);
1786 /* Set the location in case we create a decl now. */
1787 c_parser_set_source_position_from_token (c_parser_peek_token (parser
));
1788 if (c_parser_next_token_is (parser
, CPP_NAME
))
1790 ident
= c_parser_peek_token (parser
)->value
;
1791 c_parser_consume_token (parser
);
1793 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
1795 /* Parse a struct or union definition. Start the scope of the
1796 tag before parsing components. */
1797 tree type
= start_struct (code
, ident
);
1799 /* We chain the components in reverse order, then put them in
1800 forward order at the end. Each struct-declaration may
1801 declare multiple components (comma-separated), so we must use
1802 chainon to join them, although when parsing each
1803 struct-declaration we can use TREE_CHAIN directly.
1805 The theory behind all this is that there will be more
1806 semicolon separated fields than comma separated fields, and
1807 so we'll be minimizing the number of node traversals required
1809 tree contents
= NULL_TREE
;
1810 c_parser_consume_token (parser
);
1811 /* Handle the Objective-C @defs construct,
1812 e.g. foo(sizeof(struct{ @defs(ClassName) }));. */
1813 if (c_parser_next_token_is_keyword (parser
, RID_AT_DEFS
))
1816 gcc_assert (c_dialect_objc ());
1817 c_parser_consume_token (parser
);
1818 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1820 if (c_parser_next_token_is (parser
, CPP_NAME
)
1821 && c_parser_peek_token (parser
)->id_kind
== C_ID_CLASSNAME
)
1823 name
= c_parser_peek_token (parser
)->value
;
1824 c_parser_consume_token (parser
);
1828 c_parser_error (parser
, "expected class name");
1829 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
1832 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
1834 contents
= nreverse (objc_get_class_ivars (name
));
1837 /* Parse the struct-declarations and semicolons. Problems with
1838 semicolons are diagnosed here; empty structures are diagnosed
1843 /* Parse any stray semicolon. */
1844 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
1846 pedwarn (c_parser_peek_token (parser
)->location
, OPT_pedantic
,
1847 "extra semicolon in struct or union specified");
1848 c_parser_consume_token (parser
);
1851 /* Stop if at the end of the struct or union contents. */
1852 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
1854 c_parser_consume_token (parser
);
1857 /* Accept #pragmas at struct scope. */
1858 if (c_parser_next_token_is (parser
, CPP_PRAGMA
))
1860 c_parser_pragma (parser
, pragma_external
);
1863 /* Parse some comma-separated declarations, but not the
1864 trailing semicolon if any. */
1865 decls
= c_parser_struct_declaration (parser
);
1866 contents
= chainon (decls
, contents
);
1867 /* If no semicolon follows, either we have a parse error or
1868 are at the end of the struct or union and should
1870 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
1871 c_parser_consume_token (parser
);
1874 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
1875 pedwarn (c_parser_peek_token (parser
)->location
, 0,
1876 "no semicolon at end of struct or union");
1879 c_parser_error (parser
, "expected %<;%>");
1880 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
, NULL
);
1885 postfix_attrs
= c_parser_attributes (parser
);
1886 ret
.spec
= finish_struct (type
, nreverse (contents
),
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 (code
, ident
);
1906 /* Parse a struct-declaration (C90 6.5.2.1, C99 6.7.2.1), *without*
1907 the trailing semicolon.
1910 specifier-qualifier-list struct-declarator-list
1912 specifier-qualifier-list:
1913 type-specifier specifier-qualifier-list[opt]
1914 type-qualifier specifier-qualifier-list[opt]
1915 attributes specifier-qualifier-list[opt]
1917 struct-declarator-list:
1919 struct-declarator-list , attributes[opt] struct-declarator
1922 declarator attributes[opt]
1923 declarator[opt] : constant-expression attributes[opt]
1928 __extension__ struct-declaration
1929 specifier-qualifier-list
1931 Unlike the ISO C syntax, semicolons are handled elsewhere. The use
1932 of attributes where shown is a GNU extension. In GNU C, we accept
1933 any expression without commas in the syntax (assignment
1934 expressions, not just conditional expressions); assignment
1935 expressions will be diagnosed as non-constant. */
1938 c_parser_struct_declaration (c_parser
*parser
)
1940 struct c_declspecs
*specs
;
1942 tree all_prefix_attrs
;
1944 location_t decl_loc
;
1945 if (c_parser_next_token_is_keyword (parser
, RID_EXTENSION
))
1949 ext
= disable_extension_diagnostics ();
1950 c_parser_consume_token (parser
);
1951 decl
= c_parser_struct_declaration (parser
);
1952 restore_extension_diagnostics (ext
);
1955 specs
= build_null_declspecs ();
1956 decl_loc
= c_parser_peek_token (parser
)->location
;
1957 c_parser_declspecs (parser
, specs
, false, true, true);
1960 if (!specs
->declspecs_seen_p
)
1962 c_parser_error (parser
, "expected specifier-qualifier-list");
1965 finish_declspecs (specs
);
1966 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
1969 if (!specs
->type_seen_p
)
1971 pedwarn (decl_loc
, OPT_pedantic
,
1972 "ISO C forbids member declarations with no members");
1973 shadow_tag_warned (specs
, pedantic
);
1978 /* Support for unnamed structs or unions as members of
1979 structs or unions (which is [a] useful and [b] supports
1983 ret
= grokfield (c_parser_peek_token (parser
)->location
,
1984 build_id_declarator (NULL_TREE
), specs
,
1987 decl_attributes (&ret
, attrs
, 0);
1991 pending_xref_error ();
1992 prefix_attrs
= specs
->attrs
;
1993 all_prefix_attrs
= prefix_attrs
;
1994 specs
->attrs
= NULL_TREE
;
1998 /* Declaring one or more declarators or un-named bit-fields. */
1999 struct c_declarator
*declarator
;
2001 if (c_parser_next_token_is (parser
, CPP_COLON
))
2002 declarator
= build_id_declarator (NULL_TREE
);
2004 declarator
= c_parser_declarator (parser
, specs
->type_seen_p
,
2005 C_DTR_NORMAL
, &dummy
);
2006 if (declarator
== NULL
)
2008 c_parser_skip_to_end_of_block_or_statement (parser
);
2011 if (c_parser_next_token_is (parser
, CPP_COLON
)
2012 || c_parser_next_token_is (parser
, CPP_COMMA
)
2013 || c_parser_next_token_is (parser
, CPP_SEMICOLON
)
2014 || c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
)
2015 || c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
2017 tree postfix_attrs
= NULL_TREE
;
2018 tree width
= NULL_TREE
;
2020 if (c_parser_next_token_is (parser
, CPP_COLON
))
2022 c_parser_consume_token (parser
);
2023 width
= c_parser_expr_no_commas (parser
, NULL
).value
;
2025 if (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
2026 postfix_attrs
= c_parser_attributes (parser
);
2027 d
= grokfield (c_parser_peek_token (parser
)->location
,
2028 declarator
, specs
, width
, &all_prefix_attrs
);
2029 decl_attributes (&d
, chainon (postfix_attrs
,
2030 all_prefix_attrs
), 0);
2031 TREE_CHAIN (d
) = decls
;
2033 if (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
2034 all_prefix_attrs
= chainon (c_parser_attributes (parser
),
2037 all_prefix_attrs
= prefix_attrs
;
2038 if (c_parser_next_token_is (parser
, CPP_COMMA
))
2039 c_parser_consume_token (parser
);
2040 else if (c_parser_next_token_is (parser
, CPP_SEMICOLON
)
2041 || c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
2043 /* Semicolon consumed in caller. */
2048 c_parser_error (parser
, "expected %<,%>, %<;%> or %<}%>");
2054 c_parser_error (parser
,
2055 "expected %<:%>, %<,%>, %<;%>, %<}%> or "
2056 "%<__attribute__%>");
2063 /* Parse a typeof specifier (a GNU extension).
2066 typeof ( expression )
2067 typeof ( type-name )
2070 static struct c_typespec
2071 c_parser_typeof_specifier (c_parser
*parser
)
2073 struct c_typespec ret
;
2074 ret
.kind
= ctsk_typeof
;
2075 ret
.spec
= error_mark_node
;
2076 ret
.expr
= NULL_TREE
;
2077 ret
.expr_const_operands
= true;
2078 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_TYPEOF
));
2079 c_parser_consume_token (parser
);
2082 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
2088 if (c_parser_next_token_starts_typename (parser
))
2090 struct c_type_name
*type
= c_parser_type_name (parser
);
2095 ret
.spec
= groktypename (type
, &ret
.expr
, &ret
.expr_const_operands
);
2096 pop_maybe_used (variably_modified_type_p (ret
.spec
, NULL_TREE
));
2102 location_t here
= c_parser_peek_token (parser
)->location
;
2103 struct c_expr expr
= c_parser_expression (parser
);
2106 if (TREE_CODE (expr
.value
) == COMPONENT_REF
2107 && DECL_C_BIT_FIELD (TREE_OPERAND (expr
.value
, 1)))
2108 error_at (here
, "%<typeof%> applied to a bit-field");
2109 ret
.spec
= TREE_TYPE (expr
.value
);
2110 was_vm
= variably_modified_type_p (ret
.spec
, NULL_TREE
);
2111 /* This is returned with the type so that when the type is
2112 evaluated, this can be evaluated. */
2114 ret
.expr
= c_fully_fold (expr
.value
, false, &ret
.expr_const_operands
);
2115 pop_maybe_used (was_vm
);
2117 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
2121 /* Parse a declarator, possibly an abstract declarator (C90 6.5.4,
2122 6.5.5, C99 6.7.5, 6.7.6). If TYPE_SEEN_P then a typedef name may
2123 be redeclared; otherwise it may not. KIND indicates which kind of
2124 declarator is wanted. Returns a valid declarator except in the
2125 case of a syntax error in which case NULL is returned. *SEEN_ID is
2126 set to true if an identifier being declared is seen; this is used
2127 to diagnose bad forms of abstract array declarators and to
2128 determine whether an identifier list is syntactically permitted.
2131 pointer[opt] direct-declarator
2135 ( attributes[opt] declarator )
2136 direct-declarator array-declarator
2137 direct-declarator ( parameter-type-list )
2138 direct-declarator ( identifier-list[opt] )
2141 * type-qualifier-list[opt]
2142 * type-qualifier-list[opt] pointer
2144 type-qualifier-list:
2147 type-qualifier-list type-qualifier
2148 type-qualifier-list attributes
2150 parameter-type-list:
2152 parameter-list , ...
2155 parameter-declaration
2156 parameter-list , parameter-declaration
2158 parameter-declaration:
2159 declaration-specifiers declarator attributes[opt]
2160 declaration-specifiers abstract-declarator[opt] attributes[opt]
2164 identifier-list , identifier
2166 abstract-declarator:
2168 pointer[opt] direct-abstract-declarator
2170 direct-abstract-declarator:
2171 ( attributes[opt] abstract-declarator )
2172 direct-abstract-declarator[opt] array-declarator
2173 direct-abstract-declarator[opt] ( parameter-type-list[opt] )
2178 direct-declarator ( parameter-forward-declarations
2179 parameter-type-list[opt] )
2181 direct-abstract-declarator:
2182 direct-abstract-declarator[opt] ( parameter-forward-declarations
2183 parameter-type-list[opt] )
2185 parameter-forward-declarations:
2187 parameter-forward-declarations parameter-list ;
2189 The uses of attributes shown above are GNU extensions.
2191 Some forms of array declarator are not included in C99 in the
2192 syntax for abstract declarators; these are disallowed elsewhere.
2193 This may be a defect (DR#289).
2195 This function also accepts an omitted abstract declarator as being
2196 an abstract declarator, although not part of the formal syntax. */
2198 static struct c_declarator
*
2199 c_parser_declarator (c_parser
*parser
, bool type_seen_p
, c_dtr_syn kind
,
2202 /* Parse any initial pointer part. */
2203 if (c_parser_next_token_is (parser
, CPP_MULT
))
2205 struct c_declspecs
*quals_attrs
= build_null_declspecs ();
2206 struct c_declarator
*inner
;
2207 c_parser_consume_token (parser
);
2208 c_parser_declspecs (parser
, quals_attrs
, false, false, true);
2209 inner
= c_parser_declarator (parser
, type_seen_p
, kind
, seen_id
);
2213 return make_pointer_declarator (quals_attrs
, inner
);
2215 /* Now we have a direct declarator, direct abstract declarator or
2216 nothing (which counts as a direct abstract declarator here). */
2217 return c_parser_direct_declarator (parser
, type_seen_p
, kind
, seen_id
);
2220 /* Parse a direct declarator or direct abstract declarator; arguments
2221 as c_parser_declarator. */
2223 static struct c_declarator
*
2224 c_parser_direct_declarator (c_parser
*parser
, bool type_seen_p
, c_dtr_syn kind
,
2227 /* The direct declarator must start with an identifier (possibly
2228 omitted) or a parenthesized declarator (possibly abstract). In
2229 an ordinary declarator, initial parentheses must start a
2230 parenthesized declarator. In an abstract declarator or parameter
2231 declarator, they could start a parenthesized declarator or a
2232 parameter list. To tell which, the open parenthesis and any
2233 following attributes must be read. If a declaration specifier
2234 follows, then it is a parameter list; if the specifier is a
2235 typedef name, there might be an ambiguity about redeclaring it,
2236 which is resolved in the direction of treating it as a typedef
2237 name. If a close parenthesis follows, it is also an empty
2238 parameter list, as the syntax does not permit empty abstract
2239 declarators. Otherwise, it is a parenthesized declarator (in
2240 which case the analysis may be repeated inside it, recursively).
2242 ??? There is an ambiguity in a parameter declaration "int
2243 (__attribute__((foo)) x)", where x is not a typedef name: it
2244 could be an abstract declarator for a function, or declare x with
2245 parentheses. The proper resolution of this ambiguity needs
2246 documenting. At present we follow an accident of the old
2247 parser's implementation, whereby the first parameter must have
2248 some declaration specifiers other than just attributes. Thus as
2249 a parameter declaration it is treated as a parenthesized
2250 parameter named x, and as an abstract declarator it is
2253 ??? Also following the old parser, attributes inside an empty
2254 parameter list are ignored, making it a list not yielding a
2255 prototype, rather than giving an error or making it have one
2256 parameter with implicit type int.
2258 ??? Also following the old parser, typedef names may be
2259 redeclared in declarators, but not Objective-C class names. */
2261 if (kind
!= C_DTR_ABSTRACT
2262 && c_parser_next_token_is (parser
, CPP_NAME
)
2264 && c_parser_peek_token (parser
)->id_kind
== C_ID_TYPENAME
)
2265 || c_parser_peek_token (parser
)->id_kind
== C_ID_ID
))
2267 struct c_declarator
*inner
2268 = build_id_declarator (c_parser_peek_token (parser
)->value
);
2270 inner
->id_loc
= c_parser_peek_token (parser
)->location
;
2271 c_parser_consume_token (parser
);
2272 return c_parser_direct_declarator_inner (parser
, *seen_id
, inner
);
2275 if (kind
!= C_DTR_NORMAL
2276 && c_parser_next_token_is (parser
, CPP_OPEN_SQUARE
))
2278 struct c_declarator
*inner
= build_id_declarator (NULL_TREE
);
2279 return c_parser_direct_declarator_inner (parser
, *seen_id
, inner
);
2282 /* Either we are at the end of an abstract declarator, or we have
2285 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
2288 struct c_declarator
*inner
;
2289 c_parser_consume_token (parser
);
2290 attrs
= c_parser_attributes (parser
);
2291 if (kind
!= C_DTR_NORMAL
2292 && (c_parser_next_token_starts_declspecs (parser
)
2293 || c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
)))
2295 struct c_arg_info
*args
2296 = c_parser_parms_declarator (parser
, kind
== C_DTR_NORMAL
,
2303 = build_function_declarator (args
,
2304 build_id_declarator (NULL_TREE
));
2305 return c_parser_direct_declarator_inner (parser
, *seen_id
,
2309 /* A parenthesized declarator. */
2310 inner
= c_parser_declarator (parser
, type_seen_p
, kind
, seen_id
);
2311 if (inner
!= NULL
&& attrs
!= NULL
)
2312 inner
= build_attrs_declarator (attrs
, inner
);
2313 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2315 c_parser_consume_token (parser
);
2319 return c_parser_direct_declarator_inner (parser
, *seen_id
, inner
);
2323 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
2330 if (kind
== C_DTR_NORMAL
)
2332 c_parser_error (parser
, "expected identifier or %<(%>");
2336 return build_id_declarator (NULL_TREE
);
2340 /* Parse part of a direct declarator or direct abstract declarator,
2341 given that some (in INNER) has already been parsed; ID_PRESENT is
2342 true if an identifier is present, false for an abstract
2345 static struct c_declarator
*
2346 c_parser_direct_declarator_inner (c_parser
*parser
, bool id_present
,
2347 struct c_declarator
*inner
)
2349 /* Parse a sequence of array declarators and parameter lists. */
2350 if (c_parser_next_token_is (parser
, CPP_OPEN_SQUARE
))
2352 struct c_declarator
*declarator
;
2353 struct c_declspecs
*quals_attrs
= build_null_declspecs ();
2357 c_parser_consume_token (parser
);
2358 c_parser_declspecs (parser
, quals_attrs
, false, false, true);
2359 static_seen
= c_parser_next_token_is_keyword (parser
, RID_STATIC
);
2361 c_parser_consume_token (parser
);
2362 if (static_seen
&& !quals_attrs
->declspecs_seen_p
)
2363 c_parser_declspecs (parser
, quals_attrs
, false, false, true);
2364 if (!quals_attrs
->declspecs_seen_p
)
2366 /* If "static" is present, there must be an array dimension.
2367 Otherwise, there may be a dimension, "*", or no
2372 dimen
= c_parser_expr_no_commas (parser
, NULL
).value
;
2376 if (c_parser_next_token_is (parser
, CPP_CLOSE_SQUARE
))
2381 else if (c_parser_next_token_is (parser
, CPP_MULT
))
2383 if (c_parser_peek_2nd_token (parser
)->type
== CPP_CLOSE_SQUARE
)
2387 c_parser_consume_token (parser
);
2392 dimen
= c_parser_expr_no_commas (parser
, NULL
).value
;
2398 dimen
= c_parser_expr_no_commas (parser
, NULL
).value
;
2401 if (c_parser_next_token_is (parser
, CPP_CLOSE_SQUARE
))
2402 c_parser_consume_token (parser
);
2405 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
2409 declarator
= build_array_declarator (dimen
, quals_attrs
, static_seen
,
2411 if (declarator
== NULL
)
2413 inner
= set_array_declarator_inner (declarator
, inner
);
2414 return c_parser_direct_declarator_inner (parser
, id_present
, inner
);
2416 else if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
2419 struct c_arg_info
*args
;
2420 c_parser_consume_token (parser
);
2421 attrs
= c_parser_attributes (parser
);
2422 args
= c_parser_parms_declarator (parser
, id_present
, attrs
);
2427 inner
= build_function_declarator (args
, inner
);
2428 return c_parser_direct_declarator_inner (parser
, id_present
, inner
);
2434 /* Parse a parameter list or identifier list, including the closing
2435 parenthesis but not the opening one. ATTRS are the attributes at
2436 the start of the list. ID_LIST_OK is true if an identifier list is
2437 acceptable; such a list must not have attributes at the start. */
2439 static struct c_arg_info
*
2440 c_parser_parms_declarator (c_parser
*parser
, bool id_list_ok
, tree attrs
)
2443 declare_parm_level ();
2444 /* If the list starts with an identifier, it is an identifier list.
2445 Otherwise, it is either a prototype list or an empty list. */
2448 && c_parser_next_token_is (parser
, CPP_NAME
)
2449 && c_parser_peek_token (parser
)->id_kind
== C_ID_ID
)
2451 tree list
= NULL_TREE
, *nextp
= &list
;
2452 while (c_parser_next_token_is (parser
, CPP_NAME
)
2453 && c_parser_peek_token (parser
)->id_kind
== C_ID_ID
)
2455 *nextp
= build_tree_list (NULL_TREE
,
2456 c_parser_peek_token (parser
)->value
);
2457 nextp
= & TREE_CHAIN (*nextp
);
2458 c_parser_consume_token (parser
);
2459 if (c_parser_next_token_is_not (parser
, CPP_COMMA
))
2461 c_parser_consume_token (parser
);
2462 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2464 c_parser_error (parser
, "expected identifier");
2468 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2470 struct c_arg_info
*ret
= XOBNEW (&parser_obstack
, struct c_arg_info
);
2475 ret
->pending_sizes
= 0;
2476 ret
->had_vla_unspec
= 0;
2477 c_parser_consume_token (parser
);
2483 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
2491 struct c_arg_info
*ret
= c_parser_parms_list_declarator (parser
, attrs
);
2497 /* Parse a parameter list (possibly empty), including the closing
2498 parenthesis but not the opening one. ATTRS are the attributes at
2499 the start of the list. */
2501 static struct c_arg_info
*
2502 c_parser_parms_list_declarator (c_parser
*parser
, tree attrs
)
2504 bool good_parm
= false;
2505 /* ??? Following the old parser, forward parameter declarations may
2506 use abstract declarators, and if no real parameter declarations
2507 follow the forward declarations then this is not diagnosed. Also
2508 note as above that attributes are ignored as the only contents of
2509 the parentheses, or as the only contents after forward
2511 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2513 struct c_arg_info
*ret
= XOBNEW (&parser_obstack
, struct c_arg_info
);
2518 ret
->pending_sizes
= 0;
2519 ret
->had_vla_unspec
= 0;
2520 c_parser_consume_token (parser
);
2523 if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
))
2525 struct c_arg_info
*ret
= XOBNEW (&parser_obstack
, struct c_arg_info
);
2529 ret
->pending_sizes
= 0;
2530 ret
->had_vla_unspec
= 0;
2531 /* Suppress -Wold-style-definition for this case. */
2532 ret
->types
= error_mark_node
;
2533 error_at (c_parser_peek_token (parser
)->location
,
2534 "ISO C requires a named argument before %<...%>");
2535 c_parser_consume_token (parser
);
2536 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2538 c_parser_consume_token (parser
);
2543 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
2548 /* Nonempty list of parameters, either terminated with semicolon
2549 (forward declarations; recurse) or with close parenthesis (normal
2550 function) or with ", ... )" (variadic function). */
2553 /* Parse a parameter. */
2554 struct c_parm
*parm
= c_parser_parameter_declaration (parser
, attrs
);
2559 push_parm_decl (parm
);
2561 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
2564 c_parser_consume_token (parser
);
2565 mark_forward_parm_decls ();
2566 new_attrs
= c_parser_attributes (parser
);
2567 return c_parser_parms_list_declarator (parser
, new_attrs
);
2569 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2571 c_parser_consume_token (parser
);
2573 return get_parm_info (false);
2576 struct c_arg_info
*ret
2577 = XOBNEW (&parser_obstack
, struct c_arg_info
);
2582 ret
->pending_sizes
= 0;
2583 ret
->had_vla_unspec
= 0;
2587 if (!c_parser_require (parser
, CPP_COMMA
,
2588 "expected %<;%>, %<,%> or %<)%>"))
2590 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
2591 get_pending_sizes ();
2594 if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
))
2596 c_parser_consume_token (parser
);
2597 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2599 c_parser_consume_token (parser
);
2601 return get_parm_info (true);
2604 struct c_arg_info
*ret
2605 = XOBNEW (&parser_obstack
, struct c_arg_info
);
2610 ret
->pending_sizes
= 0;
2611 ret
->had_vla_unspec
= 0;
2617 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
2619 get_pending_sizes ();
2626 /* Parse a parameter declaration. ATTRS are the attributes at the
2627 start of the declaration if it is the first parameter. */
2629 static struct c_parm
*
2630 c_parser_parameter_declaration (c_parser
*parser
, tree attrs
)
2632 struct c_declspecs
*specs
;
2633 struct c_declarator
*declarator
;
2635 tree postfix_attrs
= NULL_TREE
;
2637 if (!c_parser_next_token_starts_declspecs (parser
))
2639 /* ??? In some Objective-C cases '...' isn't applicable so there
2640 should be a different message. */
2641 c_parser_error (parser
,
2642 "expected declaration specifiers or %<...%>");
2643 c_parser_skip_to_end_of_parameter (parser
);
2646 specs
= build_null_declspecs ();
2649 declspecs_add_attrs (specs
, attrs
);
2652 c_parser_declspecs (parser
, specs
, true, true, true);
2653 finish_declspecs (specs
);
2654 pending_xref_error ();
2655 prefix_attrs
= specs
->attrs
;
2656 specs
->attrs
= NULL_TREE
;
2657 declarator
= c_parser_declarator (parser
, specs
->type_seen_p
,
2658 C_DTR_PARM
, &dummy
);
2659 if (declarator
== NULL
)
2661 c_parser_skip_until_found (parser
, CPP_COMMA
, NULL
);
2664 if (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
2665 postfix_attrs
= c_parser_attributes (parser
);
2666 return build_c_parm (specs
, chainon (postfix_attrs
, prefix_attrs
),
2670 /* Parse a string literal in an asm expression. It should not be
2671 translated, and wide string literals are an error although
2672 permitted by the syntax. This is a GNU extension.
2677 ??? At present, following the old parser, the caller needs to have
2678 set lex_untranslated_string to 1. It would be better to follow the
2679 C++ parser rather than using this kludge. */
2682 c_parser_asm_string_literal (c_parser
*parser
)
2685 if (c_parser_next_token_is (parser
, CPP_STRING
))
2687 str
= c_parser_peek_token (parser
)->value
;
2688 c_parser_consume_token (parser
);
2690 else if (c_parser_next_token_is (parser
, CPP_WSTRING
))
2692 error_at (c_parser_peek_token (parser
)->location
,
2693 "wide string literal in %<asm%>");
2694 str
= build_string (1, "");
2695 c_parser_consume_token (parser
);
2699 c_parser_error (parser
, "expected string literal");
2705 /* Parse a simple asm expression. This is used in restricted
2706 contexts, where a full expression with inputs and outputs does not
2707 make sense. This is a GNU extension.
2710 asm ( asm-string-literal )
2714 c_parser_simple_asm_expr (c_parser
*parser
)
2717 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_ASM
));
2718 /* ??? Follow the C++ parser rather than using the
2719 lex_untranslated_string kludge. */
2720 parser
->lex_untranslated_string
= true;
2721 c_parser_consume_token (parser
);
2722 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
2724 parser
->lex_untranslated_string
= false;
2727 str
= c_parser_asm_string_literal (parser
);
2728 parser
->lex_untranslated_string
= false;
2729 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
2731 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
2737 /* Parse (possibly empty) attributes. This is a GNU extension.
2741 attributes attribute
2744 __attribute__ ( ( attribute-list ) )
2748 attribute_list , attrib
2753 any-word ( identifier )
2754 any-word ( identifier , nonempty-expr-list )
2755 any-word ( expr-list )
2757 where the "identifier" must not be declared as a type, and
2758 "any-word" may be any identifier (including one declared as a
2759 type), a reserved word storage class specifier, type specifier or
2760 type qualifier. ??? This still leaves out most reserved keywords
2761 (following the old parser), shouldn't we include them, and why not
2762 allow identifiers declared as types to start the arguments? */
2765 c_parser_attributes (c_parser
*parser
)
2767 tree attrs
= NULL_TREE
;
2768 while (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
2770 /* ??? Follow the C++ parser rather than using the
2771 lex_untranslated_string kludge. */
2772 parser
->lex_untranslated_string
= true;
2773 c_parser_consume_token (parser
);
2774 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
2776 parser
->lex_untranslated_string
= false;
2779 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
2781 parser
->lex_untranslated_string
= false;
2782 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
2785 /* Parse the attribute list. */
2786 while (c_parser_next_token_is (parser
, CPP_COMMA
)
2787 || c_parser_next_token_is (parser
, CPP_NAME
)
2788 || c_parser_next_token_is (parser
, CPP_KEYWORD
))
2790 tree attr
, attr_name
, attr_args
;
2791 VEC(tree
,gc
) *expr_list
;
2792 if (c_parser_next_token_is (parser
, CPP_COMMA
))
2794 c_parser_consume_token (parser
);
2797 if (c_parser_next_token_is (parser
, CPP_KEYWORD
))
2799 /* ??? See comment above about what keywords are
2802 switch (c_parser_peek_token (parser
)->keyword
)
2839 /* Accept __attribute__((__const)) as __attribute__((const))
2842 = ridpointers
[(int) c_parser_peek_token (parser
)->keyword
];
2845 attr_name
= c_parser_peek_token (parser
)->value
;
2846 c_parser_consume_token (parser
);
2847 if (c_parser_next_token_is_not (parser
, CPP_OPEN_PAREN
))
2849 attr
= build_tree_list (attr_name
, NULL_TREE
);
2850 attrs
= chainon (attrs
, attr
);
2853 c_parser_consume_token (parser
);
2854 /* Parse the attribute contents. If they start with an
2855 identifier which is followed by a comma or close
2856 parenthesis, then the arguments start with that
2857 identifier; otherwise they are an expression list. */
2858 if (c_parser_next_token_is (parser
, CPP_NAME
)
2859 && c_parser_peek_token (parser
)->id_kind
== C_ID_ID
2860 && ((c_parser_peek_2nd_token (parser
)->type
== CPP_COMMA
)
2861 || (c_parser_peek_2nd_token (parser
)->type
2862 == CPP_CLOSE_PAREN
)))
2864 tree arg1
= c_parser_peek_token (parser
)->value
;
2865 c_parser_consume_token (parser
);
2866 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2867 attr_args
= build_tree_list (NULL_TREE
, arg1
);
2871 c_parser_consume_token (parser
);
2872 expr_list
= c_parser_expr_list (parser
, false, true, NULL
);
2873 tree_list
= c_parser_vec_to_tree_list (expr_list
);
2874 attr_args
= tree_cons (NULL_TREE
, arg1
, tree_list
);
2875 c_parser_release_expr_list (expr_list
);
2880 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2881 attr_args
= NULL_TREE
;
2884 expr_list
= c_parser_expr_list (parser
, false, true, NULL
);
2885 attr_args
= c_parser_vec_to_tree_list (expr_list
);
2886 c_parser_release_expr_list (expr_list
);
2889 attr
= build_tree_list (attr_name
, attr_args
);
2890 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2891 c_parser_consume_token (parser
);
2894 parser
->lex_untranslated_string
= false;
2895 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
2899 attrs
= chainon (attrs
, attr
);
2901 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2902 c_parser_consume_token (parser
);
2905 parser
->lex_untranslated_string
= false;
2906 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
2910 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2911 c_parser_consume_token (parser
);
2914 parser
->lex_untranslated_string
= false;
2915 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
2919 parser
->lex_untranslated_string
= false;
2924 /* Parse a type name (C90 6.5.5, C99 6.7.6).
2927 specifier-qualifier-list abstract-declarator[opt]
2930 static struct c_type_name
*
2931 c_parser_type_name (c_parser
*parser
)
2933 struct c_declspecs
*specs
= build_null_declspecs ();
2934 struct c_declarator
*declarator
;
2935 struct c_type_name
*ret
;
2937 c_parser_declspecs (parser
, specs
, false, true, true);
2938 if (!specs
->declspecs_seen_p
)
2940 c_parser_error (parser
, "expected specifier-qualifier-list");
2943 pending_xref_error ();
2944 finish_declspecs (specs
);
2945 declarator
= c_parser_declarator (parser
, specs
->type_seen_p
,
2946 C_DTR_ABSTRACT
, &dummy
);
2947 if (declarator
== NULL
)
2949 ret
= XOBNEW (&parser_obstack
, struct c_type_name
);
2951 ret
->declarator
= declarator
;
2955 /* Parse an initializer (C90 6.5.7, C99 6.7.8).
2958 assignment-expression
2959 { initializer-list }
2960 { initializer-list , }
2963 designation[opt] initializer
2964 initializer-list , designation[opt] initializer
2971 designator-list designator
2978 [ constant-expression ]
2990 [ constant-expression ... constant-expression ]
2992 Any expression without commas is accepted in the syntax for the
2993 constant-expressions, with non-constant expressions rejected later.
2995 This function is only used for top-level initializers; for nested
2996 ones, see c_parser_initval. */
2998 static struct c_expr
2999 c_parser_initializer (c_parser
*parser
)
3001 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
3002 return c_parser_braced_init (parser
, NULL_TREE
, false);
3006 ret
= c_parser_expr_no_commas (parser
, NULL
);
3007 if (TREE_CODE (ret
.value
) != STRING_CST
3008 && TREE_CODE (ret
.value
) != COMPOUND_LITERAL_EXPR
)
3009 ret
= default_function_array_conversion (ret
);
3014 /* Parse a braced initializer list. TYPE is the type specified for a
3015 compound literal, and NULL_TREE for other initializers and for
3016 nested braced lists. NESTED_P is true for nested braced lists,
3017 false for the list of a compound literal or the list that is the
3018 top-level initializer in a declaration. */
3020 static struct c_expr
3021 c_parser_braced_init (c_parser
*parser
, tree type
, bool nested_p
)
3023 location_t brace_loc
= c_parser_peek_token (parser
)->location
;
3024 gcc_assert (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
));
3025 c_parser_consume_token (parser
);
3027 push_init_level (0);
3029 really_start_incremental_init (type
);
3030 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
3032 pedwarn (brace_loc
, OPT_pedantic
, "ISO C forbids empty initializer braces");
3036 /* Parse a non-empty initializer list, possibly with a trailing
3040 c_parser_initelt (parser
);
3043 if (c_parser_next_token_is (parser
, CPP_COMMA
))
3044 c_parser_consume_token (parser
);
3047 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
3051 if (c_parser_next_token_is_not (parser
, CPP_CLOSE_BRACE
))
3054 ret
.value
= error_mark_node
;
3055 ret
.original_code
= ERROR_MARK
;
3056 ret
.original_type
= NULL
;
3057 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
, "expected %<}%>");
3061 c_parser_consume_token (parser
);
3062 return pop_init_level (0);
3065 /* Parse a nested initializer, including designators. */
3068 c_parser_initelt (c_parser
*parser
)
3070 /* Parse any designator or designator list. A single array
3071 designator may have the subsequent "=" omitted in GNU C, but a
3072 longer list or a structure member designator may not. */
3073 if (c_parser_next_token_is (parser
, CPP_NAME
)
3074 && c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
)
3076 /* Old-style structure member designator. */
3077 set_init_label (c_parser_peek_token (parser
)->value
);
3078 /* Use the colon as the error location. */
3079 pedwarn (c_parser_peek_2nd_token (parser
)->location
, OPT_pedantic
,
3080 "obsolete use of designated initializer with %<:%>");
3081 c_parser_consume_token (parser
);
3082 c_parser_consume_token (parser
);
3086 /* des_seen is 0 if there have been no designators, 1 if there
3087 has been a single array designator and 2 otherwise. */
3089 /* Location of a designator. */
3090 location_t des_loc
= UNKNOWN_LOCATION
; /* Quiet warning. */
3091 while (c_parser_next_token_is (parser
, CPP_OPEN_SQUARE
)
3092 || c_parser_next_token_is (parser
, CPP_DOT
))
3094 int des_prev
= des_seen
;
3096 des_loc
= c_parser_peek_token (parser
)->location
;
3099 if (c_parser_next_token_is (parser
, CPP_DOT
))
3102 c_parser_consume_token (parser
);
3103 if (c_parser_next_token_is (parser
, CPP_NAME
))
3105 set_init_label (c_parser_peek_token (parser
)->value
);
3106 c_parser_consume_token (parser
);
3111 init
.value
= error_mark_node
;
3112 init
.original_code
= ERROR_MARK
;
3113 init
.original_type
= NULL
;
3114 c_parser_error (parser
, "expected identifier");
3115 c_parser_skip_until_found (parser
, CPP_COMMA
, NULL
);
3116 process_init_element (init
, false);
3123 location_t ellipsis_loc
= UNKNOWN_LOCATION
; /* Quiet warning. */
3124 /* ??? Following the old parser, [ objc-receiver
3125 objc-message-args ] is accepted as an initializer,
3126 being distinguished from a designator by what follows
3127 the first assignment expression inside the square
3128 brackets, but after a first array designator a
3129 subsequent square bracket is for Objective-C taken to
3130 start an expression, using the obsolete form of
3131 designated initializer without '=', rather than
3132 possibly being a second level of designation: in LALR
3133 terms, the '[' is shifted rather than reducing
3134 designator to designator-list. */
3135 if (des_prev
== 1 && c_dialect_objc ())
3137 des_seen
= des_prev
;
3140 if (des_prev
== 0 && c_dialect_objc ())
3142 /* This might be an array designator or an
3143 Objective-C message expression. If the former,
3144 continue parsing here; if the latter, parse the
3145 remainder of the initializer given the starting
3146 primary-expression. ??? It might make sense to
3147 distinguish when des_prev == 1 as well; see
3148 previous comment. */
3150 struct c_expr mexpr
;
3151 c_parser_consume_token (parser
);
3152 if (c_parser_peek_token (parser
)->type
== CPP_NAME
3153 && ((c_parser_peek_token (parser
)->id_kind
3155 || (c_parser_peek_token (parser
)->id_kind
3156 == C_ID_CLASSNAME
)))
3158 /* Type name receiver. */
3159 tree id
= c_parser_peek_token (parser
)->value
;
3160 c_parser_consume_token (parser
);
3161 rec
= objc_get_class_reference (id
);
3162 goto parse_message_args
;
3164 first
= c_parser_expr_no_commas (parser
, NULL
).value
;
3165 if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
)
3166 || c_parser_next_token_is (parser
, CPP_CLOSE_SQUARE
))
3167 goto array_desig_after_first
;
3168 /* Expression receiver. So far only one part
3169 without commas has been parsed; there might be
3170 more of the expression. */
3172 while (c_parser_next_token_is (parser
, CPP_COMMA
))
3175 c_parser_consume_token (parser
);
3176 next
= c_parser_expr_no_commas (parser
, NULL
);
3177 next
= default_function_array_conversion (next
);
3178 rec
= build_compound_expr (rec
, next
.value
);
3181 /* Now parse the objc-message-args. */
3182 args
= c_parser_objc_message_args (parser
);
3183 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
3186 = objc_build_message_expr (build_tree_list (rec
, args
));
3187 mexpr
.original_code
= ERROR_MARK
;
3188 mexpr
.original_type
= NULL
;
3189 /* Now parse and process the remainder of the
3190 initializer, starting with this message
3191 expression as a primary-expression. */
3192 c_parser_initval (parser
, &mexpr
);
3195 c_parser_consume_token (parser
);
3196 first
= c_parser_expr_no_commas (parser
, NULL
).value
;
3197 array_desig_after_first
:
3198 if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
))
3200 ellipsis_loc
= c_parser_peek_token (parser
)->location
;
3201 c_parser_consume_token (parser
);
3202 second
= c_parser_expr_no_commas (parser
, NULL
).value
;
3206 if (c_parser_next_token_is (parser
, CPP_CLOSE_SQUARE
))
3208 c_parser_consume_token (parser
);
3209 set_init_index (first
, second
);
3211 pedwarn (ellipsis_loc
, OPT_pedantic
,
3212 "ISO C forbids specifying range of elements to initialize");
3215 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
3221 if (c_parser_next_token_is (parser
, CPP_EQ
))
3224 pedwarn (des_loc
, OPT_pedantic
,
3225 "ISO C90 forbids specifying subobject to initialize");
3226 c_parser_consume_token (parser
);
3231 pedwarn (c_parser_peek_token (parser
)->location
, OPT_pedantic
,
3232 "obsolete use of designated initializer without %<=%>");
3236 init
.value
= error_mark_node
;
3237 init
.original_code
= ERROR_MARK
;
3238 init
.original_type
= NULL
;
3239 c_parser_error (parser
, "expected %<=%>");
3240 c_parser_skip_until_found (parser
, CPP_COMMA
, NULL
);
3241 process_init_element (init
, false);
3247 c_parser_initval (parser
, NULL
);
3250 /* Parse a nested initializer; as c_parser_initializer but parses
3251 initializers within braced lists, after any designators have been
3252 applied. If AFTER is not NULL then it is an Objective-C message
3253 expression which is the primary-expression starting the
3257 c_parser_initval (c_parser
*parser
, struct c_expr
*after
)
3260 gcc_assert (!after
|| c_dialect_objc ());
3261 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
) && !after
)
3262 init
= c_parser_braced_init (parser
, NULL_TREE
, true);
3265 init
= c_parser_expr_no_commas (parser
, after
);
3266 if (init
.value
!= NULL_TREE
3267 && TREE_CODE (init
.value
) != STRING_CST
3268 && TREE_CODE (init
.value
) != COMPOUND_LITERAL_EXPR
)
3269 init
= default_function_array_conversion (init
);
3271 process_init_element (init
, false);
3274 /* Parse a compound statement (possibly a function body) (C90 6.6.2,
3278 { block-item-list[opt] }
3279 { label-declarations block-item-list }
3283 block-item-list block-item
3295 { label-declarations block-item-list }
3298 __extension__ nested-declaration
3299 nested-function-definition
3303 label-declarations label-declaration
3306 __label__ identifier-list ;
3308 Allowing the mixing of declarations and code is new in C99. The
3309 GNU syntax also permits (not shown above) labels at the end of
3310 compound statements, which yield an error. We don't allow labels
3311 on declarations; this might seem like a natural extension, but
3312 there would be a conflict between attributes on the label and
3313 prefix attributes on the declaration. ??? The syntax follows the
3314 old parser in requiring something after label declarations.
3315 Although they are erroneous if the labels declared aren't defined,
3316 is it useful for the syntax to be this way?
3328 c_parser_compound_statement (c_parser
*parser
)
3331 if (!c_parser_require (parser
, CPP_OPEN_BRACE
, "expected %<{%>"))
3333 /* Ensure a scope is entered and left anyway to avoid confusion
3334 if we have just prepared to enter a function body. */
3335 stmt
= c_begin_compound_stmt (true);
3336 c_end_compound_stmt (stmt
, true);
3337 return error_mark_node
;
3339 stmt
= c_begin_compound_stmt (true);
3340 c_parser_compound_statement_nostart (parser
);
3341 return c_end_compound_stmt (stmt
, true);
3344 /* Parse a compound statement except for the opening brace. This is
3345 used for parsing both compound statements and statement expressions
3346 (which follow different paths to handling the opening). */
3349 c_parser_compound_statement_nostart (c_parser
*parser
)
3351 bool last_stmt
= false;
3352 bool last_label
= false;
3353 location_t label_loc
= UNKNOWN_LOCATION
; /* Quiet warning. */
3354 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
3356 c_parser_consume_token (parser
);
3359 if (c_parser_next_token_is_keyword (parser
, RID_LABEL
))
3361 location_t err_loc
= c_parser_peek_token (parser
)->location
;
3362 /* Read zero or more forward-declarations for labels that nested
3363 functions can jump to. */
3364 while (c_parser_next_token_is_keyword (parser
, RID_LABEL
))
3366 c_parser_consume_token (parser
);
3367 /* Any identifiers, including those declared as type names,
3372 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
3374 c_parser_error (parser
, "expected identifier");
3378 = declare_label (c_parser_peek_token (parser
)->value
);
3379 C_DECLARED_LABEL_FLAG (label
) = 1;
3380 add_stmt (build_stmt (DECL_EXPR
, label
));
3381 c_parser_consume_token (parser
);
3382 if (c_parser_next_token_is (parser
, CPP_COMMA
))
3383 c_parser_consume_token (parser
);
3387 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
3389 pedwarn (err_loc
, OPT_pedantic
, "ISO C forbids label declarations");
3391 /* We must now have at least one statement, label or declaration. */
3392 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
3394 c_parser_error (parser
, "expected declaration or statement");
3395 c_parser_consume_token (parser
);
3398 while (c_parser_next_token_is_not (parser
, CPP_CLOSE_BRACE
))
3400 location_t loc
= c_parser_peek_token (parser
)->location
;
3401 if (c_parser_next_token_is_keyword (parser
, RID_CASE
)
3402 || c_parser_next_token_is_keyword (parser
, RID_DEFAULT
)
3403 || (c_parser_next_token_is (parser
, CPP_NAME
)
3404 && c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
))
3406 if (c_parser_next_token_is_keyword (parser
, RID_CASE
))
3407 label_loc
= c_parser_peek_2nd_token (parser
)->location
;
3409 label_loc
= c_parser_peek_token (parser
)->location
;
3412 c_parser_label (parser
);
3414 else if (!last_label
3415 && c_parser_next_token_starts_declspecs (parser
))
3418 c_parser_declaration_or_fndef (parser
, true, true, true, true);
3421 (pedantic
&& !flag_isoc99
)
3423 : OPT_Wdeclaration_after_statement
,
3424 "ISO C90 forbids mixed declarations and code");
3427 else if (!last_label
3428 && c_parser_next_token_is_keyword (parser
, RID_EXTENSION
))
3430 /* __extension__ can start a declaration, but is also an
3431 unary operator that can start an expression. Consume all
3432 but the last of a possible series of __extension__ to
3434 while (c_parser_peek_2nd_token (parser
)->type
== CPP_KEYWORD
3435 && (c_parser_peek_2nd_token (parser
)->keyword
3437 c_parser_consume_token (parser
);
3438 if (c_token_starts_declspecs (c_parser_peek_2nd_token (parser
)))
3441 ext
= disable_extension_diagnostics ();
3442 c_parser_consume_token (parser
);
3444 c_parser_declaration_or_fndef (parser
, true, true, true, true);
3445 /* Following the old parser, __extension__ does not
3446 disable this diagnostic. */
3447 restore_extension_diagnostics (ext
);
3449 pedwarn_c90 (loc
, (pedantic
&& !flag_isoc99
)
3451 : OPT_Wdeclaration_after_statement
,
3452 "ISO C90 forbids mixed declarations and code");
3458 else if (c_parser_next_token_is (parser
, CPP_PRAGMA
))
3460 /* External pragmas, and some omp pragmas, are not associated
3461 with regular c code, and so are not to be considered statements
3462 syntactically. This ensures that the user doesn't put them
3463 places that would turn into syntax errors if the directive
3465 if (c_parser_pragma (parser
, pragma_compound
))
3466 last_label
= false, last_stmt
= true;
3468 else if (c_parser_next_token_is (parser
, CPP_EOF
))
3470 c_parser_error (parser
, "expected declaration or statement");
3473 else if (c_parser_next_token_is_keyword (parser
, RID_ELSE
))
3475 if (parser
->in_if_block
)
3477 error_at (loc
, """expected %<}%> before %<else%>");
3482 error_at (loc
, "%<else%> without a previous %<if%>");
3483 c_parser_consume_token (parser
);
3492 c_parser_statement_after_labels (parser
);
3495 parser
->error
= false;
3498 error_at (label_loc
, "label at end of compound statement");
3499 c_parser_consume_token (parser
);
3502 /* Parse a label (C90 6.6.1, C99 6.8.1).
3505 identifier : attributes[opt]
3506 case constant-expression :
3512 case constant-expression ... constant-expression :
3514 The use of attributes on labels is a GNU extension. The syntax in
3515 GNU C accepts any expressions without commas, non-constant
3516 expressions being rejected later. */
3519 c_parser_label (c_parser
*parser
)
3521 location_t loc1
= c_parser_peek_token (parser
)->location
;
3522 tree label
= NULL_TREE
;
3523 if (c_parser_next_token_is_keyword (parser
, RID_CASE
))
3526 c_parser_consume_token (parser
);
3527 exp1
= c_parser_expr_no_commas (parser
, NULL
).value
;
3528 if (c_parser_next_token_is (parser
, CPP_COLON
))
3530 c_parser_consume_token (parser
);
3531 label
= do_case (exp1
, NULL_TREE
);
3533 else if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
))
3535 c_parser_consume_token (parser
);
3536 exp2
= c_parser_expr_no_commas (parser
, NULL
).value
;
3537 if (c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
3538 label
= do_case (exp1
, exp2
);
3541 c_parser_error (parser
, "expected %<:%> or %<...%>");
3543 else if (c_parser_next_token_is_keyword (parser
, RID_DEFAULT
))
3545 c_parser_consume_token (parser
);
3546 if (c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
3547 label
= do_case (NULL_TREE
, NULL_TREE
);
3551 tree name
= c_parser_peek_token (parser
)->value
;
3554 location_t loc2
= c_parser_peek_token (parser
)->location
;
3555 gcc_assert (c_parser_next_token_is (parser
, CPP_NAME
));
3556 c_parser_consume_token (parser
);
3557 gcc_assert (c_parser_next_token_is (parser
, CPP_COLON
));
3558 c_parser_consume_token (parser
);
3559 attrs
= c_parser_attributes (parser
);
3560 tlab
= define_label (loc2
, name
);
3563 decl_attributes (&tlab
, attrs
, 0);
3564 label
= add_stmt (build_stmt (LABEL_EXPR
, tlab
));
3569 SET_EXPR_LOCATION (label
, loc1
);
3570 if (c_parser_next_token_starts_declspecs (parser
)
3571 && !(c_parser_next_token_is (parser
, CPP_NAME
)
3572 && c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
))
3574 error_at (c_parser_peek_token (parser
)->location
,
3575 "a label can only be part of a statement and "
3576 "a declaration is not a statement");
3577 c_parser_declaration_or_fndef (parser
, /*fndef_ok*/ false,
3578 /*nested*/ true, /*empty_ok*/ false,
3579 /*start_attr_ok*/ true);
3584 /* Parse a statement (C90 6.6, C99 6.8).
3589 expression-statement
3597 expression-statement:
3600 selection-statement:
3604 iteration-statement:
3613 return expression[opt] ;
3626 objc-throw-statement
3627 objc-try-catch-statement
3628 objc-synchronized-statement
3630 objc-throw-statement:
3644 parallel-for-construct
3645 parallel-sections-construct
3652 parallel-directive structured-block
3655 for-directive iteration-statement
3658 sections-directive section-scope
3661 single-directive structured-block
3663 parallel-for-construct:
3664 parallel-for-directive iteration-statement
3666 parallel-sections-construct:
3667 parallel-sections-directive section-scope
3670 master-directive structured-block
3673 critical-directive structured-block
3676 atomic-directive expression-statement
3679 ordered-directive structured-block */
3682 c_parser_statement (c_parser
*parser
)
3684 while (c_parser_next_token_is_keyword (parser
, RID_CASE
)
3685 || c_parser_next_token_is_keyword (parser
, RID_DEFAULT
)
3686 || (c_parser_next_token_is (parser
, CPP_NAME
)
3687 && c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
))
3688 c_parser_label (parser
);
3689 c_parser_statement_after_labels (parser
);
3692 /* Parse a statement, other than a labeled statement. */
3695 c_parser_statement_after_labels (c_parser
*parser
)
3697 location_t loc
= c_parser_peek_token (parser
)->location
;
3698 tree stmt
= NULL_TREE
;
3699 bool in_if_block
= parser
->in_if_block
;
3700 parser
->in_if_block
= false;
3701 switch (c_parser_peek_token (parser
)->type
)
3703 case CPP_OPEN_BRACE
:
3704 add_stmt (c_parser_compound_statement (parser
));
3707 switch (c_parser_peek_token (parser
)->keyword
)
3710 c_parser_if_statement (parser
);
3713 c_parser_switch_statement (parser
);
3716 c_parser_while_statement (parser
);
3719 c_parser_do_statement (parser
);
3722 c_parser_for_statement (parser
);
3725 c_parser_consume_token (parser
);
3726 if (c_parser_next_token_is (parser
, CPP_NAME
))
3728 stmt
= c_finish_goto_label (c_parser_peek_token (parser
)->value
);
3729 c_parser_consume_token (parser
);
3731 else if (c_parser_next_token_is (parser
, CPP_MULT
))
3733 c_parser_consume_token (parser
);
3734 stmt
= c_finish_goto_ptr (c_parser_expression (parser
).value
);
3737 c_parser_error (parser
, "expected identifier or %<*%>");
3738 goto expect_semicolon
;
3740 c_parser_consume_token (parser
);
3741 stmt
= c_finish_bc_stmt (&c_cont_label
, false);
3742 goto expect_semicolon
;
3744 c_parser_consume_token (parser
);
3745 stmt
= c_finish_bc_stmt (&c_break_label
, true);
3746 goto expect_semicolon
;
3748 c_parser_consume_token (parser
);
3749 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
3751 stmt
= c_finish_return (NULL_TREE
, NULL_TREE
);
3752 c_parser_consume_token (parser
);
3756 struct c_expr expr
= c_parser_expression_conv (parser
);
3757 stmt
= c_finish_return (expr
.value
, expr
.original_type
);
3758 goto expect_semicolon
;
3762 stmt
= c_parser_asm_statement (parser
);
3765 gcc_assert (c_dialect_objc ());
3766 c_parser_consume_token (parser
);
3767 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
3769 stmt
= objc_build_throw_stmt (NULL_TREE
);
3770 c_parser_consume_token (parser
);
3774 tree expr
= c_parser_expression (parser
).value
;
3775 expr
= c_fully_fold (expr
, false, NULL
);
3776 stmt
= objc_build_throw_stmt (expr
);
3777 goto expect_semicolon
;
3781 gcc_assert (c_dialect_objc ());
3782 c_parser_objc_try_catch_statement (parser
);
3784 case RID_AT_SYNCHRONIZED
:
3785 gcc_assert (c_dialect_objc ());
3786 c_parser_objc_synchronized_statement (parser
);
3793 c_parser_consume_token (parser
);
3795 case CPP_CLOSE_PAREN
:
3796 case CPP_CLOSE_SQUARE
:
3797 /* Avoid infinite loop in error recovery:
3798 c_parser_skip_until_found stops at a closing nesting
3799 delimiter without consuming it, but here we need to consume
3800 it to proceed further. */
3801 c_parser_error (parser
, "expected statement");
3802 c_parser_consume_token (parser
);
3805 c_parser_pragma (parser
, pragma_stmt
);
3809 stmt
= c_finish_expr_stmt (c_parser_expression_conv (parser
).value
);
3811 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
3814 /* Two cases cannot and do not have line numbers associated: If stmt
3815 is degenerate, such as "2;", then stmt is an INTEGER_CST, which
3816 cannot hold line numbers. But that's OK because the statement
3817 will either be changed to a MODIFY_EXPR during gimplification of
3818 the statement expr, or discarded. If stmt was compound, but
3819 without new variables, we will have skipped the creation of a
3820 BIND and will have a bare STATEMENT_LIST. But that's OK because
3821 (recursively) all of the component statements should already have
3822 line numbers assigned. ??? Can we discard no-op statements
3824 protected_set_expr_location (stmt
, loc
);
3826 parser
->in_if_block
= in_if_block
;
3829 /* Parse the condition from an if, do, while or for statements. */
3832 c_parser_condition (c_parser
*parser
)
3836 loc
= c_parser_peek_token (parser
)->location
;
3837 cond
= c_parser_expression_conv (parser
).value
;
3838 cond
= c_objc_common_truthvalue_conversion (loc
, cond
);
3839 cond
= c_fully_fold (cond
, false, NULL
);
3840 if (warn_sequence_point
)
3841 verify_sequence_points (cond
);
3845 /* Parse a parenthesized condition from an if, do or while statement.
3851 c_parser_paren_condition (c_parser
*parser
)
3854 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
3855 return error_mark_node
;
3856 cond
= c_parser_condition (parser
);
3857 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
3861 /* Parse a statement which is a block in C99. */
3864 c_parser_c99_block_statement (c_parser
*parser
)
3866 tree block
= c_begin_compound_stmt (flag_isoc99
);
3867 c_parser_statement (parser
);
3868 return c_end_compound_stmt (block
, flag_isoc99
);
3871 /* Parse the body of an if statement. This is just parsing a
3872 statement but (a) it is a block in C99, (b) we track whether the
3873 body is an if statement for the sake of -Wparentheses warnings, (c)
3874 we handle an empty body specially for the sake of -Wempty-body
3875 warnings, and (d) we call parser_compound_statement directly
3876 because c_parser_statement_after_labels resets
3877 parser->in_if_block. */
3880 c_parser_if_body (c_parser
*parser
, bool *if_p
)
3882 tree block
= c_begin_compound_stmt (flag_isoc99
);
3883 while (c_parser_next_token_is_keyword (parser
, RID_CASE
)
3884 || c_parser_next_token_is_keyword (parser
, RID_DEFAULT
)
3885 || (c_parser_next_token_is (parser
, CPP_NAME
)
3886 && c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
))
3887 c_parser_label (parser
);
3888 *if_p
= c_parser_next_token_is_keyword (parser
, RID_IF
);
3889 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
3891 location_t loc
= c_parser_peek_token (parser
)->location
;
3892 add_stmt (build_empty_stmt ());
3893 c_parser_consume_token (parser
);
3894 if (!c_parser_next_token_is_keyword (parser
, RID_ELSE
))
3895 warning_at (loc
, OPT_Wempty_body
,
3896 "suggest braces around empty body in an %<if%> statement");
3898 else if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
3899 add_stmt (c_parser_compound_statement (parser
));
3901 c_parser_statement_after_labels (parser
);
3902 return c_end_compound_stmt (block
, flag_isoc99
);
3905 /* Parse the else body of an if statement. This is just parsing a
3906 statement but (a) it is a block in C99, (b) we handle an empty body
3907 specially for the sake of -Wempty-body warnings. */
3910 c_parser_else_body (c_parser
*parser
)
3912 tree block
= c_begin_compound_stmt (flag_isoc99
);
3913 while (c_parser_next_token_is_keyword (parser
, RID_CASE
)
3914 || c_parser_next_token_is_keyword (parser
, RID_DEFAULT
)
3915 || (c_parser_next_token_is (parser
, CPP_NAME
)
3916 && c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
))
3917 c_parser_label (parser
);
3918 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
3920 warning_at (c_parser_peek_token (parser
)->location
,
3922 "suggest braces around empty body in an %<else%> statement");
3923 add_stmt (build_empty_stmt ());
3924 c_parser_consume_token (parser
);
3927 c_parser_statement_after_labels (parser
);
3928 return c_end_compound_stmt (block
, flag_isoc99
);
3931 /* Parse an if statement (C90 6.6.4, C99 6.8.4).
3934 if ( expression ) statement
3935 if ( expression ) statement else statement
3939 c_parser_if_statement (c_parser
*parser
)
3944 bool first_if
= false;
3945 tree first_body
, second_body
;
3948 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_IF
));
3949 c_parser_consume_token (parser
);
3950 block
= c_begin_compound_stmt (flag_isoc99
);
3951 loc
= c_parser_peek_token (parser
)->location
;
3952 cond
= c_parser_paren_condition (parser
);
3953 in_if_block
= parser
->in_if_block
;
3954 parser
->in_if_block
= true;
3955 first_body
= c_parser_if_body (parser
, &first_if
);
3956 parser
->in_if_block
= in_if_block
;
3957 if (c_parser_next_token_is_keyword (parser
, RID_ELSE
))
3959 c_parser_consume_token (parser
);
3960 second_body
= c_parser_else_body (parser
);
3963 second_body
= NULL_TREE
;
3964 c_finish_if_stmt (loc
, cond
, first_body
, second_body
, first_if
);
3965 add_stmt (c_end_compound_stmt (block
, flag_isoc99
));
3968 /* Parse a switch statement (C90 6.6.4, C99 6.8.4).
3971 switch (expression) statement
3975 c_parser_switch_statement (c_parser
*parser
)
3977 tree block
, expr
, body
, save_break
;
3978 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_SWITCH
));
3979 c_parser_consume_token (parser
);
3980 block
= c_begin_compound_stmt (flag_isoc99
);
3981 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
3983 expr
= c_parser_expression (parser
).value
;
3984 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
3987 expr
= error_mark_node
;
3988 c_start_case (expr
);
3989 save_break
= c_break_label
;
3990 c_break_label
= NULL_TREE
;
3991 body
= c_parser_c99_block_statement (parser
);
3992 c_finish_case (body
);
3994 add_stmt (build1 (LABEL_EXPR
, void_type_node
, c_break_label
));
3995 c_break_label
= save_break
;
3996 add_stmt (c_end_compound_stmt (block
, flag_isoc99
));
3999 /* Parse a while statement (C90 6.6.5, C99 6.8.5).
4002 while (expression) statement
4006 c_parser_while_statement (c_parser
*parser
)
4008 tree block
, cond
, body
, save_break
, save_cont
;
4010 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_WHILE
));
4011 c_parser_consume_token (parser
);
4012 block
= c_begin_compound_stmt (flag_isoc99
);
4013 loc
= c_parser_peek_token (parser
)->location
;
4014 cond
= c_parser_paren_condition (parser
);
4015 save_break
= c_break_label
;
4016 c_break_label
= NULL_TREE
;
4017 save_cont
= c_cont_label
;
4018 c_cont_label
= NULL_TREE
;
4019 body
= c_parser_c99_block_statement (parser
);
4020 c_finish_loop (loc
, cond
, NULL
, body
, c_break_label
, c_cont_label
, true);
4021 add_stmt (c_end_compound_stmt (block
, flag_isoc99
));
4022 c_break_label
= save_break
;
4023 c_cont_label
= save_cont
;
4026 /* Parse a do statement (C90 6.6.5, C99 6.8.5).
4029 do statement while ( expression ) ;
4033 c_parser_do_statement (c_parser
*parser
)
4035 tree block
, cond
, body
, save_break
, save_cont
, new_break
, new_cont
;
4037 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_DO
));
4038 c_parser_consume_token (parser
);
4039 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
4040 warning_at (c_parser_peek_token (parser
)->location
,
4042 "suggest braces around empty body in %<do%> statement");
4043 block
= c_begin_compound_stmt (flag_isoc99
);
4044 loc
= c_parser_peek_token (parser
)->location
;
4045 save_break
= c_break_label
;
4046 c_break_label
= NULL_TREE
;
4047 save_cont
= c_cont_label
;
4048 c_cont_label
= NULL_TREE
;
4049 body
= c_parser_c99_block_statement (parser
);
4050 c_parser_require_keyword (parser
, RID_WHILE
, "expected %<while%>");
4051 new_break
= c_break_label
;
4052 c_break_label
= save_break
;
4053 new_cont
= c_cont_label
;
4054 c_cont_label
= save_cont
;
4055 cond
= c_parser_paren_condition (parser
);
4056 if (!c_parser_require (parser
, CPP_SEMICOLON
, "expected %<;%>"))
4057 c_parser_skip_to_end_of_block_or_statement (parser
);
4058 c_finish_loop (loc
, cond
, NULL
, body
, new_break
, new_cont
, false);
4059 add_stmt (c_end_compound_stmt (block
, flag_isoc99
));
4062 /* Parse a for statement (C90 6.6.5, C99 6.8.5).
4065 for ( expression[opt] ; expression[opt] ; expression[opt] ) statement
4066 for ( nested-declaration expression[opt] ; expression[opt] ) statement
4068 The form with a declaration is new in C99.
4070 ??? In accordance with the old parser, the declaration may be a
4071 nested function, which is then rejected in check_for_loop_decls,
4072 but does it make any sense for this to be included in the grammar?
4073 Note in particular that the nested function does not include a
4074 trailing ';', whereas the "declaration" production includes one.
4075 Also, can we reject bad declarations earlier and cheaper than
4076 check_for_loop_decls? */
4079 c_parser_for_statement (c_parser
*parser
)
4081 tree block
, cond
, incr
, save_break
, save_cont
, body
;
4083 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_FOR
));
4084 loc
= c_parser_peek_token (parser
)->location
;
4085 c_parser_consume_token (parser
);
4086 block
= c_begin_compound_stmt (flag_isoc99
);
4087 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
4089 /* Parse the initialization declaration or expression. */
4090 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
4092 c_parser_consume_token (parser
);
4093 c_finish_expr_stmt (NULL_TREE
);
4095 else if (c_parser_next_token_starts_declspecs (parser
))
4097 c_parser_declaration_or_fndef (parser
, true, true, true, true);
4098 check_for_loop_decls ();
4100 else if (c_parser_next_token_is_keyword (parser
, RID_EXTENSION
))
4102 /* __extension__ can start a declaration, but is also an
4103 unary operator that can start an expression. Consume all
4104 but the last of a possible series of __extension__ to
4106 while (c_parser_peek_2nd_token (parser
)->type
== CPP_KEYWORD
4107 && (c_parser_peek_2nd_token (parser
)->keyword
4109 c_parser_consume_token (parser
);
4110 if (c_token_starts_declspecs (c_parser_peek_2nd_token (parser
)))
4113 ext
= disable_extension_diagnostics ();
4114 c_parser_consume_token (parser
);
4115 c_parser_declaration_or_fndef (parser
, true, true, true, true);
4116 restore_extension_diagnostics (ext
);
4117 check_for_loop_decls ();
4125 c_finish_expr_stmt (c_parser_expression (parser
).value
);
4126 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
4128 /* Parse the loop condition. */
4129 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
4131 c_parser_consume_token (parser
);
4136 cond
= c_parser_condition (parser
);
4137 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
4139 /* Parse the increment expression. */
4140 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
4141 incr
= c_process_expr_stmt (NULL_TREE
);
4143 incr
= c_process_expr_stmt (c_parser_expression (parser
).value
);
4144 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
4148 cond
= error_mark_node
;
4149 incr
= error_mark_node
;
4151 save_break
= c_break_label
;
4152 c_break_label
= NULL_TREE
;
4153 save_cont
= c_cont_label
;
4154 c_cont_label
= NULL_TREE
;
4155 body
= c_parser_c99_block_statement (parser
);
4156 c_finish_loop (loc
, cond
, incr
, body
, c_break_label
, c_cont_label
, true);
4157 add_stmt (c_end_compound_stmt (block
, flag_isoc99
));
4158 c_break_label
= save_break
;
4159 c_cont_label
= save_cont
;
4162 /* Parse an asm statement, a GNU extension. This is a full-blown asm
4163 statement with inputs, outputs, clobbers, and volatile tag
4167 asm type-qualifier[opt] ( asm-argument ) ;
4171 asm-string-literal : asm-operands[opt]
4172 asm-string-literal : asm-operands[opt] : asm-operands[opt]
4173 asm-string-literal : asm-operands[opt] : asm-operands[opt] : asm-clobbers
4175 Qualifiers other than volatile are accepted in the syntax but
4179 c_parser_asm_statement (c_parser
*parser
)
4181 tree quals
, str
, outputs
, inputs
, clobbers
, ret
;
4183 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_ASM
));
4184 c_parser_consume_token (parser
);
4185 if (c_parser_next_token_is_keyword (parser
, RID_VOLATILE
))
4187 quals
= c_parser_peek_token (parser
)->value
;
4188 c_parser_consume_token (parser
);
4190 else if (c_parser_next_token_is_keyword (parser
, RID_CONST
)
4191 || c_parser_next_token_is_keyword (parser
, RID_RESTRICT
))
4193 warning_at (c_parser_peek_token (parser
)->location
,
4195 "%E qualifier ignored on asm",
4196 c_parser_peek_token (parser
)->value
);
4198 c_parser_consume_token (parser
);
4202 /* ??? Follow the C++ parser rather than using the
4203 lex_untranslated_string kludge. */
4204 parser
->lex_untranslated_string
= true;
4205 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
4207 parser
->lex_untranslated_string
= false;
4210 str
= c_parser_asm_string_literal (parser
);
4211 if (str
== NULL_TREE
)
4213 parser
->lex_untranslated_string
= false;
4214 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
4217 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
4220 outputs
= NULL_TREE
;
4222 clobbers
= NULL_TREE
;
4225 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%> or %<)%>"))
4227 parser
->lex_untranslated_string
= false;
4228 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
4232 /* Parse outputs. */
4233 if (c_parser_next_token_is (parser
, CPP_COLON
)
4234 || c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
4235 outputs
= NULL_TREE
;
4237 outputs
= c_parser_asm_operands (parser
, false);
4238 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
4241 clobbers
= NULL_TREE
;
4244 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%> or %<)%>"))
4246 parser
->lex_untranslated_string
= false;
4247 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
4251 if (c_parser_next_token_is (parser
, CPP_COLON
)
4252 || c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
4255 inputs
= c_parser_asm_operands (parser
, true);
4256 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
4258 clobbers
= NULL_TREE
;
4261 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%> or %<)%>"))
4263 parser
->lex_untranslated_string
= false;
4264 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
4267 /* Parse clobbers. */
4268 clobbers
= c_parser_asm_clobbers (parser
);
4270 parser
->lex_untranslated_string
= false;
4271 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
4273 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
4276 if (!c_parser_require (parser
, CPP_SEMICOLON
, "expected %<;%>"))
4277 c_parser_skip_to_end_of_block_or_statement (parser
);
4278 ret
= build_asm_stmt (quals
, build_asm_expr (str
, outputs
, inputs
,
4283 /* Parse asm operands, a GNU extension. If CONVERT_P (for inputs but
4284 not outputs), apply the default conversion of functions and arrays
4289 asm-operands , asm-operand
4292 asm-string-literal ( expression )
4293 [ identifier ] asm-string-literal ( expression )
4297 c_parser_asm_operands (c_parser
*parser
, bool convert_p
)
4299 tree list
= NULL_TREE
;
4304 if (c_parser_next_token_is (parser
, CPP_OPEN_SQUARE
))
4306 c_parser_consume_token (parser
);
4307 if (c_parser_next_token_is (parser
, CPP_NAME
))
4309 tree id
= c_parser_peek_token (parser
)->value
;
4310 c_parser_consume_token (parser
);
4311 name
= build_string (IDENTIFIER_LENGTH (id
),
4312 IDENTIFIER_POINTER (id
));
4316 c_parser_error (parser
, "expected identifier");
4317 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
, NULL
);
4320 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
4325 str
= c_parser_asm_string_literal (parser
);
4326 if (str
== NULL_TREE
)
4328 parser
->lex_untranslated_string
= false;
4329 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
4331 parser
->lex_untranslated_string
= true;
4334 expr
= c_parser_expression (parser
);
4336 expr
= default_function_array_conversion (expr
);
4337 expr
.value
= c_fully_fold (expr
.value
, false, NULL
);
4338 parser
->lex_untranslated_string
= true;
4339 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
4341 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
4344 list
= chainon (list
, build_tree_list (build_tree_list (name
, str
),
4346 if (c_parser_next_token_is (parser
, CPP_COMMA
))
4347 c_parser_consume_token (parser
);
4354 /* Parse asm clobbers, a GNU extension.
4358 asm-clobbers , asm-string-literal
4362 c_parser_asm_clobbers (c_parser
*parser
)
4364 tree list
= NULL_TREE
;
4367 tree str
= c_parser_asm_string_literal (parser
);
4369 list
= tree_cons (NULL_TREE
, str
, list
);
4372 if (c_parser_next_token_is (parser
, CPP_COMMA
))
4373 c_parser_consume_token (parser
);
4380 /* Parse an expression other than a compound expression; that is, an
4381 assignment expression (C90 6.3.16, C99 6.5.16). If AFTER is not
4382 NULL then it is an Objective-C message expression which is the
4383 primary-expression starting the expression as an initializer.
4385 assignment-expression:
4386 conditional-expression
4387 unary-expression assignment-operator assignment-expression
4389 assignment-operator: one of
4390 = *= /= %= += -= <<= >>= &= ^= |=
4392 In GNU C we accept any conditional expression on the LHS and
4393 diagnose the invalid lvalue rather than producing a syntax
4396 static struct c_expr
4397 c_parser_expr_no_commas (c_parser
*parser
, struct c_expr
*after
)
4399 struct c_expr lhs
, rhs
, ret
;
4400 enum tree_code code
;
4401 location_t op_location
;
4402 gcc_assert (!after
|| c_dialect_objc ());
4403 lhs
= c_parser_conditional_expression (parser
, after
);
4404 op_location
= c_parser_peek_token (parser
)->location
;
4405 switch (c_parser_peek_token (parser
)->type
)
4414 code
= TRUNC_DIV_EXPR
;
4417 code
= TRUNC_MOD_EXPR
;
4432 code
= BIT_AND_EXPR
;
4435 code
= BIT_XOR_EXPR
;
4438 code
= BIT_IOR_EXPR
;
4443 c_parser_consume_token (parser
);
4444 rhs
= c_parser_expr_no_commas (parser
, NULL
);
4445 rhs
= default_function_array_conversion (rhs
);
4446 ret
.value
= build_modify_expr (op_location
, lhs
.value
, code
, rhs
.value
,
4448 if (code
== NOP_EXPR
)
4449 ret
.original_code
= MODIFY_EXPR
;
4452 TREE_NO_WARNING (ret
.value
) = 1;
4453 ret
.original_code
= ERROR_MARK
;
4455 ret
.original_type
= NULL
;
4459 /* Parse a conditional expression (C90 6.3.15, C99 6.5.15). If AFTER
4460 is not NULL then it is an Objective-C message expression which is
4461 the primary-expression starting the expression as an initializer.
4463 conditional-expression:
4464 logical-OR-expression
4465 logical-OR-expression ? expression : conditional-expression
4469 conditional-expression:
4470 logical-OR-expression ? : conditional-expression
4473 static struct c_expr
4474 c_parser_conditional_expression (c_parser
*parser
, struct c_expr
*after
)
4476 struct c_expr cond
, exp1
, exp2
, ret
;
4477 location_t cond_loc
;
4479 gcc_assert (!after
|| c_dialect_objc ());
4481 cond_loc
= c_parser_peek_token (parser
)->location
;
4482 cond
= c_parser_binary_expression (parser
, after
);
4484 if (c_parser_next_token_is_not (parser
, CPP_QUERY
))
4486 cond
= default_function_array_conversion (cond
);
4487 c_parser_consume_token (parser
);
4488 if (c_parser_next_token_is (parser
, CPP_COLON
))
4490 tree eptype
= NULL_TREE
;
4491 pedwarn (c_parser_peek_token (parser
)->location
, OPT_pedantic
,
4492 "ISO C forbids omitting the middle term of a ?: expression");
4493 if (TREE_CODE (cond
.value
) == EXCESS_PRECISION_EXPR
)
4495 eptype
= TREE_TYPE (cond
.value
);
4496 cond
.value
= TREE_OPERAND (cond
.value
, 0);
4498 /* Make sure first operand is calculated only once. */
4499 exp1
.value
= c_save_expr (default_conversion (cond
.value
));
4501 exp1
.value
= build1 (EXCESS_PRECISION_EXPR
, eptype
, exp1
.value
);
4502 exp1
.original_type
= NULL
;
4503 cond
.value
= c_objc_common_truthvalue_conversion (cond_loc
, exp1
.value
);
4504 skip_evaluation
+= cond
.value
== truthvalue_true_node
;
4509 = c_objc_common_truthvalue_conversion
4510 (cond_loc
, default_conversion (cond
.value
));
4511 skip_evaluation
+= cond
.value
== truthvalue_false_node
;
4512 exp1
= c_parser_expression_conv (parser
);
4513 skip_evaluation
+= ((cond
.value
== truthvalue_true_node
)
4514 - (cond
.value
== truthvalue_false_node
));
4516 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
4518 skip_evaluation
-= cond
.value
== truthvalue_true_node
;
4519 ret
.value
= error_mark_node
;
4520 ret
.original_code
= ERROR_MARK
;
4521 ret
.original_type
= NULL
;
4524 exp2
= c_parser_conditional_expression (parser
, NULL
);
4525 exp2
= default_function_array_conversion (exp2
);
4526 skip_evaluation
-= cond
.value
== truthvalue_true_node
;
4527 ret
.value
= build_conditional_expr (cond
.value
,
4528 cond
.original_code
== C_MAYBE_CONST_EXPR
,
4529 exp1
.value
, exp2
.value
);
4530 ret
.original_code
= ERROR_MARK
;
4531 if (exp1
.value
== error_mark_node
|| exp2
.value
== error_mark_node
)
4532 ret
.original_type
= NULL
;
4537 /* If both sides are enum type, the default conversion will have
4538 made the type of the result be an integer type. We want to
4539 remember the enum types we started with. */
4540 t1
= exp1
.original_type
? exp1
.original_type
: TREE_TYPE (exp1
.value
);
4541 t2
= exp2
.original_type
? exp2
.original_type
: TREE_TYPE (exp2
.value
);
4542 ret
.original_type
= ((t1
!= error_mark_node
4543 && t2
!= error_mark_node
4544 && (TYPE_MAIN_VARIANT (t1
)
4545 == TYPE_MAIN_VARIANT (t2
)))
4552 /* Parse a binary expression; that is, a logical-OR-expression (C90
4553 6.3.5-6.3.14, C99 6.5.5-6.5.14). If AFTER is not NULL then it is
4554 an Objective-C message expression which is the primary-expression
4555 starting the expression as an initializer.
4557 multiplicative-expression:
4559 multiplicative-expression * cast-expression
4560 multiplicative-expression / cast-expression
4561 multiplicative-expression % cast-expression
4563 additive-expression:
4564 multiplicative-expression
4565 additive-expression + multiplicative-expression
4566 additive-expression - multiplicative-expression
4570 shift-expression << additive-expression
4571 shift-expression >> additive-expression
4573 relational-expression:
4575 relational-expression < shift-expression
4576 relational-expression > shift-expression
4577 relational-expression <= shift-expression
4578 relational-expression >= shift-expression
4580 equality-expression:
4581 relational-expression
4582 equality-expression == relational-expression
4583 equality-expression != relational-expression
4587 AND-expression & equality-expression
4589 exclusive-OR-expression:
4591 exclusive-OR-expression ^ AND-expression
4593 inclusive-OR-expression:
4594 exclusive-OR-expression
4595 inclusive-OR-expression | exclusive-OR-expression
4597 logical-AND-expression:
4598 inclusive-OR-expression
4599 logical-AND-expression && inclusive-OR-expression
4601 logical-OR-expression:
4602 logical-AND-expression
4603 logical-OR-expression || logical-AND-expression
4606 static struct c_expr
4607 c_parser_binary_expression (c_parser
*parser
, struct c_expr
*after
)
4609 /* A binary expression is parsed using operator-precedence parsing,
4610 with the operands being cast expressions. All the binary
4611 operators are left-associative. Thus a binary expression is of
4614 E0 op1 E1 op2 E2 ...
4616 which we represent on a stack. On the stack, the precedence
4617 levels are strictly increasing. When a new operator is
4618 encountered of higher precedence than that at the top of the
4619 stack, it is pushed; its LHS is the top expression, and its RHS
4620 is everything parsed until it is popped. When a new operator is
4621 encountered with precedence less than or equal to that at the top
4622 of the stack, triples E[i-1] op[i] E[i] are popped and replaced
4623 by the result of the operation until the operator at the top of
4624 the stack has lower precedence than the new operator or there is
4625 only one element on the stack; then the top expression is the LHS
4626 of the new operator. In the case of logical AND and OR
4627 expressions, we also need to adjust skip_evaluation as
4628 appropriate when the operators are pushed and popped. */
4630 /* The precedence levels, where 0 is a dummy lowest level used for
4631 the bottom of the stack. */
4647 /* The expression at this stack level. */
4649 /* The precedence of the operator on its left, PREC_NONE at the
4650 bottom of the stack. */
4652 /* The operation on its left. */
4654 /* The source location of this operation. */
4658 /* Location of the binary operator. */
4659 location_t binary_loc
= UNKNOWN_LOCATION
; /* Quiet warning. */
4662 switch (stack[sp].op) \
4664 case TRUTH_ANDIF_EXPR: \
4665 skip_evaluation -= stack[sp - 1].expr.value == truthvalue_false_node; \
4667 case TRUTH_ORIF_EXPR: \
4668 skip_evaluation -= stack[sp - 1].expr.value == truthvalue_true_node; \
4673 stack[sp - 1].expr \
4674 = default_function_array_conversion (stack[sp - 1].expr); \
4676 = default_function_array_conversion (stack[sp].expr); \
4677 stack[sp - 1].expr = parser_build_binary_op (stack[sp].loc, \
4679 stack[sp - 1].expr, \
4683 gcc_assert (!after
|| c_dialect_objc ());
4684 stack
[0].loc
= c_parser_peek_token (parser
)->location
;
4685 stack
[0].expr
= c_parser_cast_expression (parser
, after
);
4686 stack
[0].prec
= PREC_NONE
;
4691 enum tree_code ocode
;
4694 switch (c_parser_peek_token (parser
)->type
)
4702 ocode
= TRUNC_DIV_EXPR
;
4706 ocode
= TRUNC_MOD_EXPR
;
4718 ocode
= LSHIFT_EXPR
;
4722 ocode
= RSHIFT_EXPR
;
4736 case CPP_GREATER_EQ
:
4749 oprec
= PREC_BITAND
;
4750 ocode
= BIT_AND_EXPR
;
4753 oprec
= PREC_BITXOR
;
4754 ocode
= BIT_XOR_EXPR
;
4758 ocode
= BIT_IOR_EXPR
;
4761 oprec
= PREC_LOGAND
;
4762 ocode
= TRUTH_ANDIF_EXPR
;
4766 ocode
= TRUTH_ORIF_EXPR
;
4769 /* Not a binary operator, so end of the binary
4773 binary_loc
= c_parser_peek_token (parser
)->location
;
4774 c_parser_consume_token (parser
);
4775 while (oprec
<= stack
[sp
].prec
)
4779 case TRUTH_ANDIF_EXPR
:
4781 = default_function_array_conversion (stack
[sp
].expr
);
4782 stack
[sp
].expr
.value
= c_objc_common_truthvalue_conversion
4783 (stack
[sp
].loc
, default_conversion (stack
[sp
].expr
.value
));
4784 skip_evaluation
+= stack
[sp
].expr
.value
== truthvalue_false_node
;
4786 case TRUTH_ORIF_EXPR
:
4788 = default_function_array_conversion (stack
[sp
].expr
);
4789 stack
[sp
].expr
.value
= c_objc_common_truthvalue_conversion
4790 (stack
[sp
].loc
, default_conversion (stack
[sp
].expr
.value
));
4791 skip_evaluation
+= stack
[sp
].expr
.value
== truthvalue_true_node
;
4797 stack
[sp
].loc
= binary_loc
;
4798 stack
[sp
].expr
= c_parser_cast_expression (parser
, NULL
);
4799 stack
[sp
].prec
= oprec
;
4800 stack
[sp
].op
= ocode
;
4805 return stack
[0].expr
;
4809 /* Parse a cast expression (C90 6.3.4, C99 6.5.4). If AFTER is not
4810 NULL then it is an Objective-C message expression which is the
4811 primary-expression starting the expression as an initializer.
4815 ( type-name ) unary-expression
4818 static struct c_expr
4819 c_parser_cast_expression (c_parser
*parser
, struct c_expr
*after
)
4821 gcc_assert (!after
|| c_dialect_objc ());
4823 return c_parser_postfix_expression_after_primary (parser
, *after
);
4824 /* If the expression begins with a parenthesized type name, it may
4825 be either a cast or a compound literal; we need to see whether
4826 the next character is '{' to tell the difference. If not, it is
4827 an unary expression. */
4828 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
)
4829 && c_token_starts_typename (c_parser_peek_2nd_token (parser
)))
4831 struct c_type_name
*type_name
;
4834 c_parser_consume_token (parser
);
4835 type_name
= c_parser_type_name (parser
);
4836 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
4837 if (type_name
== NULL
)
4839 ret
.value
= error_mark_node
;
4840 ret
.original_code
= ERROR_MARK
;
4841 ret
.original_type
= NULL
;
4845 /* Save casted types in the function's used types hash table. */
4846 used_types_insert (type_name
->specs
->type
);
4848 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
4849 return c_parser_postfix_expression_after_paren_type (parser
,
4851 expr
= c_parser_cast_expression (parser
, NULL
);
4852 expr
= default_function_array_conversion (expr
);
4853 ret
.value
= c_cast_expr (type_name
, expr
.value
);
4854 ret
.original_code
= ERROR_MARK
;
4855 ret
.original_type
= NULL
;
4859 return c_parser_unary_expression (parser
);
4862 /* Parse an unary expression (C90 6.3.3, C99 6.5.3).
4868 unary-operator cast-expression
4869 sizeof unary-expression
4870 sizeof ( type-name )
4872 unary-operator: one of
4878 __alignof__ unary-expression
4879 __alignof__ ( type-name )
4882 unary-operator: one of
4883 __extension__ __real__ __imag__
4885 In addition, the GNU syntax treats ++ and -- as unary operators, so
4886 they may be applied to cast expressions with errors for non-lvalues
4889 static struct c_expr
4890 c_parser_unary_expression (c_parser
*parser
)
4893 struct c_expr ret
, op
;
4894 location_t loc
= c_parser_peek_token (parser
)->location
;
4895 ret
.original_code
= ERROR_MARK
;
4896 ret
.original_type
= NULL
;
4897 switch (c_parser_peek_token (parser
)->type
)
4900 c_parser_consume_token (parser
);
4901 op
= c_parser_cast_expression (parser
, NULL
);
4902 op
= default_function_array_conversion (op
);
4903 return parser_build_unary_op (PREINCREMENT_EXPR
, op
, loc
);
4904 case CPP_MINUS_MINUS
:
4905 c_parser_consume_token (parser
);
4906 op
= c_parser_cast_expression (parser
, NULL
);
4907 op
= default_function_array_conversion (op
);
4908 return parser_build_unary_op (PREDECREMENT_EXPR
, op
, loc
);
4910 c_parser_consume_token (parser
);
4911 return parser_build_unary_op (ADDR_EXPR
,
4912 c_parser_cast_expression (parser
, NULL
),
4915 c_parser_consume_token (parser
);
4916 op
= c_parser_cast_expression (parser
, NULL
);
4917 op
= default_function_array_conversion (op
);
4918 ret
.value
= build_indirect_ref (loc
, op
.value
, "unary *");
4921 if (!c_dialect_objc () && !in_system_header
)
4922 warning_at (c_parser_peek_token (parser
)->location
,
4924 "traditional C rejects the unary plus operator");
4925 c_parser_consume_token (parser
);
4926 op
= c_parser_cast_expression (parser
, NULL
);
4927 op
= default_function_array_conversion (op
);
4928 return parser_build_unary_op (CONVERT_EXPR
, op
, loc
);
4930 c_parser_consume_token (parser
);
4931 op
= c_parser_cast_expression (parser
, NULL
);
4932 op
= default_function_array_conversion (op
);
4933 return parser_build_unary_op (NEGATE_EXPR
, op
, loc
);
4935 c_parser_consume_token (parser
);
4936 op
= c_parser_cast_expression (parser
, NULL
);
4937 op
= default_function_array_conversion (op
);
4938 return parser_build_unary_op (BIT_NOT_EXPR
, op
, loc
);
4940 c_parser_consume_token (parser
);
4941 op
= c_parser_cast_expression (parser
, NULL
);
4942 op
= default_function_array_conversion (op
);
4943 return parser_build_unary_op (TRUTH_NOT_EXPR
, op
, loc
);
4945 /* Refer to the address of a label as a pointer. */
4946 c_parser_consume_token (parser
);
4947 if (c_parser_next_token_is (parser
, CPP_NAME
))
4949 ret
.value
= finish_label_address_expr
4950 (c_parser_peek_token (parser
)->value
, loc
);
4951 c_parser_consume_token (parser
);
4955 c_parser_error (parser
, "expected identifier");
4956 ret
.value
= error_mark_node
;
4960 switch (c_parser_peek_token (parser
)->keyword
)
4963 return c_parser_sizeof_expression (parser
);
4965 return c_parser_alignof_expression (parser
);
4967 c_parser_consume_token (parser
);
4968 ext
= disable_extension_diagnostics ();
4969 ret
= c_parser_cast_expression (parser
, NULL
);
4970 restore_extension_diagnostics (ext
);
4973 c_parser_consume_token (parser
);
4974 op
= c_parser_cast_expression (parser
, NULL
);
4975 op
= default_function_array_conversion (op
);
4976 return parser_build_unary_op (REALPART_EXPR
, op
, loc
);
4978 c_parser_consume_token (parser
);
4979 op
= c_parser_cast_expression (parser
, NULL
);
4980 op
= default_function_array_conversion (op
);
4981 return parser_build_unary_op (IMAGPART_EXPR
, op
, loc
);
4983 return c_parser_postfix_expression (parser
);
4986 return c_parser_postfix_expression (parser
);
4990 /* Parse a sizeof expression. */
4992 static struct c_expr
4993 c_parser_sizeof_expression (c_parser
*parser
)
4996 location_t expr_loc
;
4997 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_SIZEOF
));
4998 c_parser_consume_token (parser
);
5001 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
)
5002 && c_token_starts_typename (c_parser_peek_2nd_token (parser
)))
5004 /* Either sizeof ( type-name ) or sizeof unary-expression
5005 starting with a compound literal. */
5006 struct c_type_name
*type_name
;
5007 c_parser_consume_token (parser
);
5008 expr_loc
= c_parser_peek_token (parser
)->location
;
5009 type_name
= c_parser_type_name (parser
);
5010 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
5011 if (type_name
== NULL
)
5016 ret
.value
= error_mark_node
;
5017 ret
.original_code
= ERROR_MARK
;
5018 ret
.original_type
= NULL
;
5021 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
5023 expr
= c_parser_postfix_expression_after_paren_type (parser
,
5027 /* sizeof ( type-name ). */
5030 return c_expr_sizeof_type (type_name
);
5034 expr_loc
= c_parser_peek_token (parser
)->location
;
5035 expr
= c_parser_unary_expression (parser
);
5039 if (TREE_CODE (expr
.value
) == COMPONENT_REF
5040 && DECL_C_BIT_FIELD (TREE_OPERAND (expr
.value
, 1)))
5041 error_at (expr_loc
, "%<sizeof%> applied to a bit-field");
5042 return c_expr_sizeof_expr (expr
);
5046 /* Parse an alignof expression. */
5048 static struct c_expr
5049 c_parser_alignof_expression (c_parser
*parser
)
5052 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_ALIGNOF
));
5053 c_parser_consume_token (parser
);
5056 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
)
5057 && c_token_starts_typename (c_parser_peek_2nd_token (parser
)))
5059 /* Either __alignof__ ( type-name ) or __alignof__
5060 unary-expression starting with a compound literal. */
5061 struct c_type_name
*type_name
;
5063 c_parser_consume_token (parser
);
5064 type_name
= c_parser_type_name (parser
);
5065 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
5066 if (type_name
== NULL
)
5071 ret
.value
= error_mark_node
;
5072 ret
.original_code
= ERROR_MARK
;
5073 ret
.original_type
= NULL
;
5076 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
5078 expr
= c_parser_postfix_expression_after_paren_type (parser
,
5082 /* alignof ( type-name ). */
5085 ret
.value
= c_alignof (groktypename (type_name
, NULL
, NULL
));
5086 ret
.original_code
= ERROR_MARK
;
5087 ret
.original_type
= NULL
;
5093 expr
= c_parser_unary_expression (parser
);
5097 ret
.value
= c_alignof_expr (expr
.value
);
5098 ret
.original_code
= ERROR_MARK
;
5099 ret
.original_type
= NULL
;
5104 /* Parse a postfix expression (C90 6.3.1-6.3.2, C99 6.5.1-6.5.2).
5108 postfix-expression [ expression ]
5109 postfix-expression ( argument-expression-list[opt] )
5110 postfix-expression . identifier
5111 postfix-expression -> identifier
5112 postfix-expression ++
5113 postfix-expression --
5114 ( type-name ) { initializer-list }
5115 ( type-name ) { initializer-list , }
5117 argument-expression-list:
5119 argument-expression-list , argument-expression
5131 (treated as a keyword in GNU C)
5134 ( compound-statement )
5135 __builtin_va_arg ( assignment-expression , type-name )
5136 __builtin_offsetof ( type-name , offsetof-member-designator )
5137 __builtin_choose_expr ( assignment-expression ,
5138 assignment-expression ,
5139 assignment-expression )
5140 __builtin_types_compatible_p ( type-name , type-name )
5142 offsetof-member-designator:
5144 offsetof-member-designator . identifier
5145 offsetof-member-designator [ expression ]
5150 [ objc-receiver objc-message-args ]
5151 @selector ( objc-selector-arg )
5152 @protocol ( identifier )
5153 @encode ( type-name )
5157 static struct c_expr
5158 c_parser_postfix_expression (c_parser
*parser
)
5160 struct c_expr expr
, e1
, e2
, e3
;
5161 struct c_type_name
*t1
, *t2
;
5163 expr
.original_code
= ERROR_MARK
;
5164 expr
.original_type
= NULL
;
5165 switch (c_parser_peek_token (parser
)->type
)
5168 expr
.value
= c_parser_peek_token (parser
)->value
;
5169 loc
= c_parser_peek_token (parser
)->location
;
5170 c_parser_consume_token (parser
);
5171 if (TREE_CODE (expr
.value
) == FIXED_CST
5172 && !targetm
.fixed_point_supported_p ())
5174 error_at (loc
, "fixed-point types not supported for this target");
5175 expr
.value
= error_mark_node
;
5182 expr
.value
= c_parser_peek_token (parser
)->value
;
5183 c_parser_consume_token (parser
);
5189 expr
.value
= c_parser_peek_token (parser
)->value
;
5190 expr
.original_code
= STRING_CST
;
5191 c_parser_consume_token (parser
);
5193 case CPP_OBJC_STRING
:
5194 gcc_assert (c_dialect_objc ());
5196 = objc_build_string_object (c_parser_peek_token (parser
)->value
);
5197 c_parser_consume_token (parser
);
5200 if (c_parser_peek_token (parser
)->id_kind
!= C_ID_ID
)
5202 c_parser_error (parser
, "expected expression");
5203 expr
.value
= error_mark_node
;
5207 tree id
= c_parser_peek_token (parser
)->value
;
5208 location_t loc
= c_parser_peek_token (parser
)->location
;
5209 c_parser_consume_token (parser
);
5210 expr
.value
= build_external_ref (id
,
5211 (c_parser_peek_token (parser
)->type
5212 == CPP_OPEN_PAREN
), loc
,
5213 &expr
.original_type
);
5216 case CPP_OPEN_PAREN
:
5217 /* A parenthesized expression, statement expression or compound
5219 if (c_parser_peek_2nd_token (parser
)->type
== CPP_OPEN_BRACE
)
5221 /* A statement expression. */
5223 location_t here
= c_parser_peek_token (parser
)->location
;
5224 c_parser_consume_token (parser
);
5225 c_parser_consume_token (parser
);
5226 if (cur_stmt_list
== NULL
)
5228 error_at (here
, "braced-group within expression allowed "
5229 "only inside a function");
5230 parser
->error
= true;
5231 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
, NULL
);
5232 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5233 expr
.value
= error_mark_node
;
5236 stmt
= c_begin_stmt_expr ();
5237 c_parser_compound_statement_nostart (parser
);
5238 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5240 pedwarn (here
, OPT_pedantic
,
5241 "ISO C forbids braced-groups within expressions");
5242 expr
.value
= c_finish_stmt_expr (stmt
);
5244 else if (c_token_starts_typename (c_parser_peek_2nd_token (parser
)))
5246 /* A compound literal. ??? Can we actually get here rather
5247 than going directly to
5248 c_parser_postfix_expression_after_paren_type from
5250 struct c_type_name
*type_name
;
5251 c_parser_consume_token (parser
);
5252 type_name
= c_parser_type_name (parser
);
5253 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5255 if (type_name
== NULL
)
5257 expr
.value
= error_mark_node
;
5260 expr
= c_parser_postfix_expression_after_paren_type (parser
,
5265 /* A parenthesized expression. */
5266 c_parser_consume_token (parser
);
5267 expr
= c_parser_expression (parser
);
5268 if (TREE_CODE (expr
.value
) == MODIFY_EXPR
)
5269 TREE_NO_WARNING (expr
.value
) = 1;
5270 if (expr
.original_code
!= C_MAYBE_CONST_EXPR
)
5271 expr
.original_code
= ERROR_MARK
;
5272 /* Don't change EXPR.ORIGINAL_TYPE. */
5273 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5278 switch (c_parser_peek_token (parser
)->keyword
)
5280 case RID_FUNCTION_NAME
:
5281 case RID_PRETTY_FUNCTION_NAME
:
5282 case RID_C99_FUNCTION_NAME
:
5283 expr
.value
= fname_decl (c_parser_peek_token (parser
)->location
,
5284 c_parser_peek_token (parser
)->keyword
,
5285 c_parser_peek_token (parser
)->value
);
5286 c_parser_consume_token (parser
);
5289 c_parser_consume_token (parser
);
5290 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
5292 expr
.value
= error_mark_node
;
5295 e1
= c_parser_expr_no_commas (parser
, NULL
);
5296 e1
.value
= c_fully_fold (e1
.value
, false, NULL
);
5297 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
5299 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5300 expr
.value
= error_mark_node
;
5303 t1
= c_parser_type_name (parser
);
5304 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5308 expr
.value
= error_mark_node
;
5312 tree type_expr
= NULL_TREE
;
5313 expr
.value
= build_va_arg (e1
.value
, groktypename (t1
,
5318 expr
.value
= build2 (C_MAYBE_CONST_EXPR
,
5319 TREE_TYPE (expr
.value
), type_expr
,
5321 C_MAYBE_CONST_EXPR_NON_CONST (expr
.value
) = true;
5326 c_parser_consume_token (parser
);
5327 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
5329 expr
.value
= error_mark_node
;
5332 t1
= c_parser_type_name (parser
);
5335 expr
.value
= error_mark_node
;
5338 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
5340 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5341 expr
.value
= error_mark_node
;
5345 tree type
= groktypename (t1
, NULL
, NULL
);
5347 if (type
== error_mark_node
)
5348 offsetof_ref
= error_mark_node
;
5350 offsetof_ref
= build1 (INDIRECT_REF
, type
, null_pointer_node
);
5351 /* Parse the second argument to __builtin_offsetof. We
5352 must have one identifier, and beyond that we want to
5353 accept sub structure and sub array references. */
5354 if (c_parser_next_token_is (parser
, CPP_NAME
))
5356 offsetof_ref
= build_component_ref
5357 (offsetof_ref
, c_parser_peek_token (parser
)->value
);
5358 c_parser_consume_token (parser
);
5359 while (c_parser_next_token_is (parser
, CPP_DOT
)
5360 || c_parser_next_token_is (parser
,
5362 || c_parser_next_token_is (parser
,
5365 if (c_parser_next_token_is (parser
, CPP_DEREF
))
5367 loc
= c_parser_peek_token (parser
)->location
;
5368 offsetof_ref
= build_array_ref (offsetof_ref
,
5373 else if (c_parser_next_token_is (parser
, CPP_DOT
))
5376 c_parser_consume_token (parser
);
5377 if (c_parser_next_token_is_not (parser
,
5380 c_parser_error (parser
, "expected identifier");
5383 offsetof_ref
= build_component_ref
5385 c_parser_peek_token (parser
)->value
);
5386 c_parser_consume_token (parser
);
5391 loc
= c_parser_peek_token (parser
)->location
;
5392 c_parser_consume_token (parser
);
5393 idx
= c_parser_expression (parser
).value
;
5394 idx
= c_fully_fold (idx
, false, NULL
);
5395 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
5397 offsetof_ref
= build_array_ref (offsetof_ref
, idx
, loc
);
5402 c_parser_error (parser
, "expected identifier");
5403 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5405 expr
.value
= fold_offsetof (offsetof_ref
, NULL_TREE
);
5408 case RID_CHOOSE_EXPR
:
5409 c_parser_consume_token (parser
);
5410 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
5412 expr
.value
= error_mark_node
;
5415 loc
= c_parser_peek_token (parser
)->location
;
5416 e1
= c_parser_expr_no_commas (parser
, NULL
);
5417 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
5419 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5420 expr
.value
= error_mark_node
;
5423 e2
= c_parser_expr_no_commas (parser
, NULL
);
5424 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
5426 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5427 expr
.value
= error_mark_node
;
5430 e3
= c_parser_expr_no_commas (parser
, NULL
);
5431 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5437 if (TREE_CODE (c
) != INTEGER_CST
5438 || !INTEGRAL_TYPE_P (TREE_TYPE (c
)))
5440 "first argument to %<__builtin_choose_expr%> not"
5442 constant_expression_warning (c
);
5443 expr
= integer_zerop (c
) ? e3
: e2
;
5446 case RID_TYPES_COMPATIBLE_P
:
5447 c_parser_consume_token (parser
);
5448 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
5450 expr
.value
= error_mark_node
;
5453 t1
= c_parser_type_name (parser
);
5456 expr
.value
= error_mark_node
;
5459 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
5461 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5462 expr
.value
= error_mark_node
;
5465 t2
= c_parser_type_name (parser
);
5468 expr
.value
= error_mark_node
;
5471 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5476 e1
= TYPE_MAIN_VARIANT (groktypename (t1
, NULL
, NULL
));
5477 e2
= TYPE_MAIN_VARIANT (groktypename (t2
, NULL
, NULL
));
5479 expr
.value
= comptypes (e1
, e2
)
5480 ? build_int_cst (NULL_TREE
, 1)
5481 : build_int_cst (NULL_TREE
, 0);
5484 case RID_AT_SELECTOR
:
5485 gcc_assert (c_dialect_objc ());
5486 c_parser_consume_token (parser
);
5487 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
5489 expr
.value
= error_mark_node
;
5493 tree sel
= c_parser_objc_selector_arg (parser
);
5494 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5496 expr
.value
= objc_build_selector_expr (sel
);
5499 case RID_AT_PROTOCOL
:
5500 gcc_assert (c_dialect_objc ());
5501 c_parser_consume_token (parser
);
5502 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
5504 expr
.value
= error_mark_node
;
5507 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5509 c_parser_error (parser
, "expected identifier");
5510 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5511 expr
.value
= error_mark_node
;
5515 tree id
= c_parser_peek_token (parser
)->value
;
5516 c_parser_consume_token (parser
);
5517 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5519 expr
.value
= objc_build_protocol_expr (id
);
5523 /* Extension to support C-structures in the archiver. */
5524 gcc_assert (c_dialect_objc ());
5525 c_parser_consume_token (parser
);
5526 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
5528 expr
.value
= error_mark_node
;
5531 t1
= c_parser_type_name (parser
);
5534 expr
.value
= error_mark_node
;
5535 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5538 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5541 tree type
= groktypename (t1
, NULL
, NULL
);
5542 expr
.value
= objc_build_encode_expr (type
);
5546 c_parser_error (parser
, "expected expression");
5547 expr
.value
= error_mark_node
;
5551 case CPP_OPEN_SQUARE
:
5552 if (c_dialect_objc ())
5554 tree receiver
, args
;
5555 c_parser_consume_token (parser
);
5556 receiver
= c_parser_objc_receiver (parser
);
5557 args
= c_parser_objc_message_args (parser
);
5558 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
5560 expr
.value
= objc_build_message_expr (build_tree_list (receiver
,
5564 /* Else fall through to report error. */
5566 c_parser_error (parser
, "expected expression");
5567 expr
.value
= error_mark_node
;
5570 return c_parser_postfix_expression_after_primary (parser
, expr
);
5573 /* Parse a postfix expression after a parenthesized type name: the
5574 brace-enclosed initializer of a compound literal, possibly followed
5575 by some postfix operators. This is separate because it is not
5576 possible to tell until after the type name whether a cast
5577 expression has a cast or a compound literal, or whether the operand
5578 of sizeof is a parenthesized type name or starts with a compound
5581 static struct c_expr
5582 c_parser_postfix_expression_after_paren_type (c_parser
*parser
,
5583 struct c_type_name
*type_name
)
5589 location_t start_loc
;
5590 tree type_expr
= NULL_TREE
;
5591 bool type_expr_const
= true;
5592 start_init (NULL_TREE
, NULL
, 0);
5593 type
= groktypename (type_name
, &type_expr
, &type_expr_const
);
5594 start_loc
= c_parser_peek_token (parser
)->location
;
5595 if (type
!= error_mark_node
&& C_TYPE_VARIABLE_SIZE (type
))
5597 error_at (start_loc
, "compound literal has variable size");
5598 type
= error_mark_node
;
5600 init
= c_parser_braced_init (parser
, type
, false);
5602 maybe_warn_string_init (type
, init
);
5605 pedwarn (start_loc
, OPT_pedantic
, "ISO C90 forbids compound literals");
5606 non_const
= ((init
.value
&& TREE_CODE (init
.value
) == CONSTRUCTOR
)
5607 ? CONSTRUCTOR_NON_CONST (init
.value
)
5608 : init
.original_code
== C_MAYBE_CONST_EXPR
);
5609 non_const
|= !type_expr_const
;
5610 expr
.value
= build_compound_literal (type
, init
.value
, non_const
);
5611 expr
.original_code
= ERROR_MARK
;
5612 expr
.original_type
= NULL
;
5615 if (TREE_CODE (expr
.value
) == C_MAYBE_CONST_EXPR
)
5617 gcc_assert (C_MAYBE_CONST_EXPR_PRE (expr
.value
) == NULL_TREE
);
5618 C_MAYBE_CONST_EXPR_PRE (expr
.value
) = type_expr
;
5622 gcc_assert (!non_const
);
5623 expr
.value
= build2 (C_MAYBE_CONST_EXPR
, type
,
5624 type_expr
, expr
.value
);
5627 return c_parser_postfix_expression_after_primary (parser
, expr
);
5630 /* Parse a postfix expression after the initial primary or compound
5631 literal; that is, parse a series of postfix operators. */
5633 static struct c_expr
5634 c_parser_postfix_expression_after_primary (c_parser
*parser
,
5637 struct c_expr orig_expr
;
5639 VEC(tree
,gc
) *exprlist
;
5640 VEC(tree
,gc
) *origtypes
;
5641 location_t loc
= c_parser_peek_token (parser
)->location
;
5644 switch (c_parser_peek_token (parser
)->type
)
5646 case CPP_OPEN_SQUARE
:
5647 /* Array reference. */
5648 loc
= c_parser_peek_token (parser
)->location
;
5649 c_parser_consume_token (parser
);
5650 idx
= c_parser_expression (parser
).value
;
5651 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
5653 expr
.value
= build_array_ref (expr
.value
, idx
, loc
);
5654 expr
.original_code
= ERROR_MARK
;
5655 expr
.original_type
= NULL
;
5657 case CPP_OPEN_PAREN
:
5658 /* Function call. */
5659 c_parser_consume_token (parser
);
5660 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
5663 exprlist
= c_parser_expr_list (parser
, true, false, &origtypes
);
5664 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5667 expr
.value
= build_function_call_vec (expr
.value
, exprlist
,
5669 expr
.original_code
= ERROR_MARK
;
5670 if (TREE_CODE (expr
.value
) == INTEGER_CST
5671 && TREE_CODE (orig_expr
.value
) == FUNCTION_DECL
5672 && DECL_BUILT_IN_CLASS (orig_expr
.value
) == BUILT_IN_NORMAL
5673 && DECL_FUNCTION_CODE (orig_expr
.value
) == BUILT_IN_CONSTANT_P
)
5674 expr
.original_code
= C_MAYBE_CONST_EXPR
;
5675 expr
.original_type
= NULL
;
5676 if (exprlist
!= NULL
)
5678 c_parser_release_expr_list (exprlist
);
5679 c_parser_release_expr_list (origtypes
);
5683 /* Structure element reference. */
5684 c_parser_consume_token (parser
);
5685 expr
= default_function_array_conversion (expr
);
5686 if (c_parser_next_token_is (parser
, CPP_NAME
))
5687 ident
= c_parser_peek_token (parser
)->value
;
5690 c_parser_error (parser
, "expected identifier");
5691 expr
.value
= error_mark_node
;
5692 expr
.original_code
= ERROR_MARK
;
5693 expr
.original_type
= NULL
;
5696 c_parser_consume_token (parser
);
5697 expr
.value
= build_component_ref (expr
.value
, ident
);
5698 expr
.original_code
= ERROR_MARK
;
5699 if (TREE_CODE (expr
.value
) != COMPONENT_REF
)
5700 expr
.original_type
= NULL
;
5703 /* Remember the original type of a bitfield. */
5704 tree field
= TREE_OPERAND (expr
.value
, 1);
5705 if (TREE_CODE (field
) != FIELD_DECL
)
5706 expr
.original_type
= NULL
;
5708 expr
.original_type
= DECL_BIT_FIELD_TYPE (field
);
5712 /* Structure element reference. */
5713 c_parser_consume_token (parser
);
5714 expr
= default_function_array_conversion (expr
);
5715 if (c_parser_next_token_is (parser
, CPP_NAME
))
5716 ident
= c_parser_peek_token (parser
)->value
;
5719 c_parser_error (parser
, "expected identifier");
5720 expr
.value
= error_mark_node
;
5721 expr
.original_code
= ERROR_MARK
;
5722 expr
.original_type
= NULL
;
5725 c_parser_consume_token (parser
);
5726 expr
.value
= build_component_ref (build_indirect_ref (loc
,
5730 expr
.original_code
= ERROR_MARK
;
5731 if (TREE_CODE (expr
.value
) != COMPONENT_REF
)
5732 expr
.original_type
= NULL
;
5735 /* Remember the original type of a bitfield. */
5736 tree field
= TREE_OPERAND (expr
.value
, 1);
5737 if (TREE_CODE (field
) != FIELD_DECL
)
5738 expr
.original_type
= NULL
;
5740 expr
.original_type
= DECL_BIT_FIELD_TYPE (field
);
5744 /* Postincrement. */
5745 c_parser_consume_token (parser
);
5746 expr
= default_function_array_conversion (expr
);
5747 expr
.value
= build_unary_op (loc
,
5748 POSTINCREMENT_EXPR
, expr
.value
, 0);
5749 expr
.original_code
= ERROR_MARK
;
5750 expr
.original_type
= NULL
;
5752 case CPP_MINUS_MINUS
:
5753 /* Postdecrement. */
5754 c_parser_consume_token (parser
);
5755 expr
= default_function_array_conversion (expr
);
5756 expr
.value
= build_unary_op (loc
,
5757 POSTDECREMENT_EXPR
, expr
.value
, 0);
5758 expr
.original_code
= ERROR_MARK
;
5759 expr
.original_type
= NULL
;
5767 /* Parse an expression (C90 6.3.17, C99 6.5.17).
5770 assignment-expression
5771 expression , assignment-expression
5774 static struct c_expr
5775 c_parser_expression (c_parser
*parser
)
5778 expr
= c_parser_expr_no_commas (parser
, NULL
);
5779 while (c_parser_next_token_is (parser
, CPP_COMMA
))
5782 c_parser_consume_token (parser
);
5783 next
= c_parser_expr_no_commas (parser
, NULL
);
5784 next
= default_function_array_conversion (next
);
5785 expr
.value
= build_compound_expr (expr
.value
, next
.value
);
5786 expr
.original_code
= COMPOUND_EXPR
;
5787 expr
.original_type
= NULL
;
5792 /* Parse an expression and convert functions or arrays to
5795 static struct c_expr
5796 c_parser_expression_conv (c_parser
*parser
)
5799 expr
= c_parser_expression (parser
);
5800 expr
= default_function_array_conversion (expr
);
5804 /* Parse a non-empty list of expressions. If CONVERT_P, convert
5805 functions and arrays to pointers. If FOLD_P, fold the expressions.
5808 assignment-expression
5809 nonempty-expr-list , assignment-expression
5812 /* We cache two vectors, to save most allocation and deallocation. */
5813 static GTY((deletable
)) VEC(tree
,gc
) *cached_expr_list_1
;
5814 static GTY((deletable
)) VEC(tree
,gc
) *cached_expr_list_2
;
5816 static VEC(tree
,gc
) *
5817 c_parser_expr_list (c_parser
*parser
, bool convert_p
, bool fold_p
,
5818 VEC(tree
,gc
) **p_orig_types
)
5821 VEC(tree
,gc
) *orig_types
;
5824 if (cached_expr_list_1
!= NULL
)
5826 ret
= cached_expr_list_1
;
5827 cached_expr_list_1
= NULL
;
5828 VEC_truncate (tree
, ret
, 0);
5830 else if (cached_expr_list_2
!= NULL
)
5832 ret
= cached_expr_list_2
;
5833 cached_expr_list_2
= NULL
;
5834 VEC_truncate (tree
, ret
, 0);
5837 ret
= VEC_alloc (tree
, gc
, 16);
5839 if (p_orig_types
== NULL
)
5843 if (cached_expr_list_2
!= NULL
)
5845 orig_types
= cached_expr_list_2
;
5846 cached_expr_list_2
= NULL
;
5847 VEC_truncate (tree
, orig_types
, 0);
5850 orig_types
= VEC_alloc (tree
, gc
, 16);
5853 expr
= c_parser_expr_no_commas (parser
, NULL
);
5855 expr
= default_function_array_conversion (expr
);
5857 expr
.value
= c_fully_fold (expr
.value
, false, NULL
);
5858 VEC_quick_push (tree
, ret
, expr
.value
);
5859 if (orig_types
!= NULL
)
5860 VEC_quick_push (tree
, orig_types
, expr
.original_type
);
5861 while (c_parser_next_token_is (parser
, CPP_COMMA
))
5863 c_parser_consume_token (parser
);
5864 expr
= c_parser_expr_no_commas (parser
, NULL
);
5866 expr
= default_function_array_conversion (expr
);
5868 expr
.value
= c_fully_fold (expr
.value
, false, NULL
);
5869 VEC_safe_push (tree
, gc
, ret
, expr
.value
);
5870 if (orig_types
!= NULL
)
5871 VEC_safe_push (tree
, gc
, orig_types
, expr
.original_type
);
5873 if (orig_types
!= NULL
)
5874 *p_orig_types
= orig_types
;
5878 /* Release a vector returned by c_parser_expr_list. */
5881 c_parser_release_expr_list (VEC(tree
,gc
) *vec
)
5883 if (cached_expr_list_1
== NULL
)
5884 cached_expr_list_1
= vec
;
5885 else if (cached_expr_list_2
== NULL
)
5886 cached_expr_list_2
= vec
;
5888 VEC_free (tree
, gc
, vec
);
5891 /* Convert a vector, as returned by c_parser_expr_list, to a
5895 c_parser_vec_to_tree_list (VEC(tree
,gc
) *vec
)
5897 tree ret
= NULL_TREE
;
5901 for (i
= 0; VEC_iterate (tree
, vec
, i
, t
); ++i
)
5903 *pp
= build_tree_list (NULL
, t
);
5904 pp
= &TREE_CHAIN (*pp
);
5909 /* Parse Objective-C-specific constructs. */
5911 /* Parse an objc-class-definition.
5913 objc-class-definition:
5914 @interface identifier objc-superclass[opt] objc-protocol-refs[opt]
5915 objc-class-instance-variables[opt] objc-methodprotolist @end
5916 @implementation identifier objc-superclass[opt]
5917 objc-class-instance-variables[opt]
5918 @interface identifier ( identifier ) objc-protocol-refs[opt]
5919 objc-methodprotolist @end
5920 @implementation identifier ( identifier )
5925 "@interface identifier (" must start "@interface identifier (
5926 identifier ) ...": objc-methodprotolist in the first production may
5927 not start with a parenthesized identifier as a declarator of a data
5928 definition with no declaration specifiers if the objc-superclass,
5929 objc-protocol-refs and objc-class-instance-variables are omitted. */
5932 c_parser_objc_class_definition (c_parser
*parser
)
5937 if (c_parser_next_token_is_keyword (parser
, RID_AT_INTERFACE
))
5939 else if (c_parser_next_token_is_keyword (parser
, RID_AT_IMPLEMENTATION
))
5943 c_parser_consume_token (parser
);
5944 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5946 c_parser_error (parser
, "expected identifier");
5949 id1
= c_parser_peek_token (parser
)->value
;
5950 c_parser_consume_token (parser
);
5951 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
5954 tree proto
= NULL_TREE
;
5955 c_parser_consume_token (parser
);
5956 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5958 c_parser_error (parser
, "expected identifier");
5959 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5962 id2
= c_parser_peek_token (parser
)->value
;
5963 c_parser_consume_token (parser
);
5964 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
5967 objc_start_category_implementation (id1
, id2
);
5970 if (c_parser_next_token_is (parser
, CPP_LESS
))
5971 proto
= c_parser_objc_protocol_refs (parser
);
5972 objc_start_category_interface (id1
, id2
, proto
);
5973 c_parser_objc_methodprotolist (parser
);
5974 c_parser_require_keyword (parser
, RID_AT_END
, "expected %<@end%>");
5975 objc_finish_interface ();
5978 if (c_parser_next_token_is (parser
, CPP_COLON
))
5980 c_parser_consume_token (parser
);
5981 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5983 c_parser_error (parser
, "expected identifier");
5986 superclass
= c_parser_peek_token (parser
)->value
;
5987 c_parser_consume_token (parser
);
5990 superclass
= NULL_TREE
;
5993 tree proto
= NULL_TREE
;
5994 if (c_parser_next_token_is (parser
, CPP_LESS
))
5995 proto
= c_parser_objc_protocol_refs (parser
);
5996 objc_start_class_interface (id1
, superclass
, proto
);
5999 objc_start_class_implementation (id1
, superclass
);
6000 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
6001 c_parser_objc_class_instance_variables (parser
);
6004 objc_continue_interface ();
6005 c_parser_objc_methodprotolist (parser
);
6006 c_parser_require_keyword (parser
, RID_AT_END
, "expected %<@end%>");
6007 objc_finish_interface ();
6011 objc_continue_implementation ();
6016 /* Parse objc-class-instance-variables.
6018 objc-class-instance-variables:
6019 { objc-instance-variable-decl-list[opt] }
6021 objc-instance-variable-decl-list:
6022 objc-visibility-spec
6023 objc-instance-variable-decl ;
6025 objc-instance-variable-decl-list objc-visibility-spec
6026 objc-instance-variable-decl-list objc-instance-variable-decl ;
6027 objc-instance-variable-decl-list ;
6029 objc-visibility-spec:
6034 objc-instance-variable-decl:
6039 c_parser_objc_class_instance_variables (c_parser
*parser
)
6041 gcc_assert (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
));
6042 c_parser_consume_token (parser
);
6043 while (c_parser_next_token_is_not (parser
, CPP_EOF
))
6046 /* Parse any stray semicolon. */
6047 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
6049 pedwarn (c_parser_peek_token (parser
)->location
, OPT_pedantic
,
6050 "extra semicolon in struct or union specified");
6051 c_parser_consume_token (parser
);
6054 /* Stop if at the end of the instance variables. */
6055 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
6057 c_parser_consume_token (parser
);
6060 /* Parse any objc-visibility-spec. */
6061 if (c_parser_next_token_is_keyword (parser
, RID_PRIVATE
))
6063 c_parser_consume_token (parser
);
6064 objc_set_visibility (2);
6067 else if (c_parser_next_token_is_keyword (parser
, RID_PROTECTED
))
6069 c_parser_consume_token (parser
);
6070 objc_set_visibility (0);
6073 else if (c_parser_next_token_is_keyword (parser
, RID_PUBLIC
))
6075 c_parser_consume_token (parser
);
6076 objc_set_visibility (1);
6079 else if (c_parser_next_token_is (parser
, CPP_PRAGMA
))
6081 c_parser_pragma (parser
, pragma_external
);
6085 /* Parse some comma-separated declarations. */
6086 decls
= c_parser_struct_declaration (parser
);
6088 /* Comma-separated instance variables are chained together in
6089 reverse order; add them one by one. */
6090 tree ivar
= nreverse (decls
);
6091 for (; ivar
; ivar
= TREE_CHAIN (ivar
))
6092 objc_add_instance_variable (copy_node (ivar
));
6094 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
6098 /* Parse an objc-class-declaration.
6100 objc-class-declaration:
6101 @class identifier-list ;
6105 c_parser_objc_class_declaration (c_parser
*parser
)
6107 tree list
= NULL_TREE
;
6108 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_CLASS
));
6109 c_parser_consume_token (parser
);
6110 /* Any identifiers, including those declared as type names, are OK
6115 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
6117 c_parser_error (parser
, "expected identifier");
6120 id
= c_parser_peek_token (parser
)->value
;
6121 list
= chainon (list
, build_tree_list (NULL_TREE
, id
));
6122 c_parser_consume_token (parser
);
6123 if (c_parser_next_token_is (parser
, CPP_COMMA
))
6124 c_parser_consume_token (parser
);
6128 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
6129 objc_declare_class (list
);
6132 /* Parse an objc-alias-declaration.
6134 objc-alias-declaration:
6135 @compatibility_alias identifier identifier ;
6139 c_parser_objc_alias_declaration (c_parser
*parser
)
6142 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_AT_ALIAS
));
6143 c_parser_consume_token (parser
);
6144 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
6146 c_parser_error (parser
, "expected identifier");
6147 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, NULL
);
6150 id1
= c_parser_peek_token (parser
)->value
;
6151 c_parser_consume_token (parser
);
6152 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
6154 c_parser_error (parser
, "expected identifier");
6155 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, NULL
);
6158 id2
= c_parser_peek_token (parser
)->value
;
6159 c_parser_consume_token (parser
);
6160 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
6161 objc_declare_alias (id1
, id2
);
6164 /* Parse an objc-protocol-definition.
6166 objc-protocol-definition:
6167 @protocol identifier objc-protocol-refs[opt] objc-methodprotolist @end
6168 @protocol identifier-list ;
6170 "@protocol identifier ;" should be resolved as "@protocol
6171 identifier-list ;": objc-methodprotolist may not start with a
6172 semicolon in the first alternative if objc-protocol-refs are
6176 c_parser_objc_protocol_definition (c_parser
*parser
)
6178 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_AT_PROTOCOL
));
6179 c_parser_consume_token (parser
);
6180 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
6182 c_parser_error (parser
, "expected identifier");
6185 if (c_parser_peek_2nd_token (parser
)->type
== CPP_COMMA
6186 || c_parser_peek_2nd_token (parser
)->type
== CPP_SEMICOLON
)
6188 tree list
= NULL_TREE
;
6189 /* Any identifiers, including those declared as type names, are
6194 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
6196 c_parser_error (parser
, "expected identifier");
6199 id
= c_parser_peek_token (parser
)->value
;
6200 list
= chainon (list
, build_tree_list (NULL_TREE
, id
));
6201 c_parser_consume_token (parser
);
6202 if (c_parser_next_token_is (parser
, CPP_COMMA
))
6203 c_parser_consume_token (parser
);
6207 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
6208 objc_declare_protocols (list
);
6212 tree id
= c_parser_peek_token (parser
)->value
;
6213 tree proto
= NULL_TREE
;
6214 c_parser_consume_token (parser
);
6215 if (c_parser_next_token_is (parser
, CPP_LESS
))
6216 proto
= c_parser_objc_protocol_refs (parser
);
6217 parser
->objc_pq_context
= true;
6218 objc_start_protocol (id
, proto
);
6219 c_parser_objc_methodprotolist (parser
);
6220 c_parser_require_keyword (parser
, RID_AT_END
, "expected %<@end%>");
6221 parser
->objc_pq_context
= false;
6222 objc_finish_interface ();
6226 /* Parse an objc-method-type.
6233 static enum tree_code
6234 c_parser_objc_method_type (c_parser
*parser
)
6236 switch (c_parser_peek_token (parser
)->type
)
6239 c_parser_consume_token (parser
);
6242 c_parser_consume_token (parser
);
6249 /* Parse an objc-method-definition.
6251 objc-method-definition:
6252 objc-method-type objc-method-decl ;[opt] compound-statement
6256 c_parser_objc_method_definition (c_parser
*parser
)
6258 enum tree_code type
= c_parser_objc_method_type (parser
);
6260 objc_set_method_type (type
);
6261 parser
->objc_pq_context
= true;
6262 decl
= c_parser_objc_method_decl (parser
);
6263 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
6265 c_parser_consume_token (parser
);
6266 pedwarn (c_parser_peek_token (parser
)->location
, OPT_pedantic
,
6267 "extra semicolon in method definition specified");
6269 if (!c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
6271 c_parser_error (parser
, "expected %<{%>");
6274 parser
->objc_pq_context
= false;
6275 objc_start_method_definition (decl
);
6276 add_stmt (c_parser_compound_statement (parser
));
6277 objc_finish_method_definition (current_function_decl
);
6280 /* Parse an objc-methodprotolist.
6282 objc-methodprotolist:
6284 objc-methodprotolist objc-methodproto
6285 objc-methodprotolist declaration
6286 objc-methodprotolist ;
6288 The declaration is a data definition, which may be missing
6289 declaration specifiers under the same rules and diagnostics as
6290 other data definitions outside functions, and the stray semicolon
6291 is diagnosed the same way as a stray semicolon outside a
6295 c_parser_objc_methodprotolist (c_parser
*parser
)
6299 /* The list is terminated by @end. */
6300 switch (c_parser_peek_token (parser
)->type
)
6303 pedwarn (c_parser_peek_token (parser
)->location
, OPT_pedantic
,
6304 "ISO C does not allow extra %<;%> outside of a function");
6305 c_parser_consume_token (parser
);
6309 c_parser_objc_methodproto (parser
);
6312 c_parser_pragma (parser
, pragma_external
);
6317 if (c_parser_next_token_is_keyword (parser
, RID_AT_END
))
6319 c_parser_declaration_or_fndef (parser
, false, true, false, true);
6325 /* Parse an objc-methodproto.
6328 objc-method-type objc-method-decl ;
6332 c_parser_objc_methodproto (c_parser
*parser
)
6334 enum tree_code type
= c_parser_objc_method_type (parser
);
6336 objc_set_method_type (type
);
6337 /* Remember protocol qualifiers in prototypes. */
6338 parser
->objc_pq_context
= true;
6339 decl
= c_parser_objc_method_decl (parser
);
6340 /* Forget protocol qualifiers here. */
6341 parser
->objc_pq_context
= false;
6342 objc_add_method_declaration (decl
);
6343 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
6346 /* Parse an objc-method-decl.
6349 ( objc-type-name ) objc-selector
6351 ( objc-type-name ) objc-keyword-selector objc-optparmlist
6352 objc-keyword-selector objc-optparmlist
6354 objc-keyword-selector:
6356 objc-keyword-selector objc-keyword-decl
6359 objc-selector : ( objc-type-name ) identifier
6360 objc-selector : identifier
6361 : ( objc-type-name ) identifier
6365 objc-optparms objc-optellipsis
6369 objc-opt-parms , parameter-declaration
6377 c_parser_objc_method_decl (c_parser
*parser
)
6379 tree type
= NULL_TREE
;
6381 tree parms
= NULL_TREE
;
6382 bool ellipsis
= false;
6384 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
6386 c_parser_consume_token (parser
);
6387 type
= c_parser_objc_type_name (parser
);
6388 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
6390 sel
= c_parser_objc_selector (parser
);
6391 /* If there is no selector, or a colon follows, we have an
6392 objc-keyword-selector. If there is a selector, and a colon does
6393 not follow, that selector ends the objc-method-decl. */
6394 if (!sel
|| c_parser_next_token_is (parser
, CPP_COLON
))
6397 tree list
= NULL_TREE
;
6400 tree atype
= NULL_TREE
, id
, keyworddecl
;
6401 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
6403 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
6405 c_parser_consume_token (parser
);
6406 atype
= c_parser_objc_type_name (parser
);
6407 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
6410 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
6412 c_parser_error (parser
, "expected identifier");
6413 return error_mark_node
;
6415 id
= c_parser_peek_token (parser
)->value
;
6416 c_parser_consume_token (parser
);
6417 keyworddecl
= objc_build_keyword_decl (tsel
, atype
, id
);
6418 list
= chainon (list
, keyworddecl
);
6419 tsel
= c_parser_objc_selector (parser
);
6420 if (!tsel
&& c_parser_next_token_is_not (parser
, CPP_COLON
))
6423 /* Parse the optional parameter list. Optional Objective-C
6424 method parameters follow the C syntax, and may include '...'
6425 to denote a variable number of arguments. */
6426 parms
= make_node (TREE_LIST
);
6427 while (c_parser_next_token_is (parser
, CPP_COMMA
))
6429 struct c_parm
*parm
;
6430 c_parser_consume_token (parser
);
6431 if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
))
6434 c_parser_consume_token (parser
);
6437 parm
= c_parser_parameter_declaration (parser
, NULL_TREE
);
6440 parms
= chainon (parms
,
6441 build_tree_list (NULL_TREE
, grokparm (parm
)));
6445 return objc_build_method_signature (type
, sel
, parms
, ellipsis
);
6448 /* Parse an objc-type-name.
6451 objc-type-qualifiers[opt] type-name
6452 objc-type-qualifiers[opt]
6454 objc-type-qualifiers:
6456 objc-type-qualifiers objc-type-qualifier
6458 objc-type-qualifier: one of
6459 in out inout bycopy byref oneway
6463 c_parser_objc_type_name (c_parser
*parser
)
6465 tree quals
= NULL_TREE
;
6466 struct c_type_name
*type_name
= NULL
;
6467 tree type
= NULL_TREE
;
6470 c_token
*token
= c_parser_peek_token (parser
);
6471 if (token
->type
== CPP_KEYWORD
6472 && (token
->keyword
== RID_IN
6473 || token
->keyword
== RID_OUT
6474 || token
->keyword
== RID_INOUT
6475 || token
->keyword
== RID_BYCOPY
6476 || token
->keyword
== RID_BYREF
6477 || token
->keyword
== RID_ONEWAY
))
6479 quals
= chainon (quals
, build_tree_list (NULL_TREE
, token
->value
));
6480 c_parser_consume_token (parser
);
6485 if (c_parser_next_token_starts_typename (parser
))
6486 type_name
= c_parser_type_name (parser
);
6488 type
= groktypename (type_name
, NULL
, NULL
);
6489 return build_tree_list (quals
, type
);
6492 /* Parse objc-protocol-refs.
6499 c_parser_objc_protocol_refs (c_parser
*parser
)
6501 tree list
= NULL_TREE
;
6502 gcc_assert (c_parser_next_token_is (parser
, CPP_LESS
));
6503 c_parser_consume_token (parser
);
6504 /* Any identifiers, including those declared as type names, are OK
6509 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
6511 c_parser_error (parser
, "expected identifier");
6514 id
= c_parser_peek_token (parser
)->value
;
6515 list
= chainon (list
, build_tree_list (NULL_TREE
, id
));
6516 c_parser_consume_token (parser
);
6517 if (c_parser_next_token_is (parser
, CPP_COMMA
))
6518 c_parser_consume_token (parser
);
6522 c_parser_require (parser
, CPP_GREATER
, "expected %<>%>");
6526 /* Parse an objc-try-catch-statement.
6528 objc-try-catch-statement:
6529 @try compound-statement objc-catch-list[opt]
6530 @try compound-statement objc-catch-list[opt] @finally compound-statement
6533 @catch ( parameter-declaration ) compound-statement
6534 objc-catch-list @catch ( parameter-declaration ) compound-statement
6538 c_parser_objc_try_catch_statement (c_parser
*parser
)
6542 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_TRY
));
6543 c_parser_consume_token (parser
);
6544 loc
= c_parser_peek_token (parser
)->location
;
6545 stmt
= c_parser_compound_statement (parser
);
6546 objc_begin_try_stmt (loc
, stmt
);
6547 while (c_parser_next_token_is_keyword (parser
, RID_CATCH
))
6549 struct c_parm
*parm
;
6550 c_parser_consume_token (parser
);
6551 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
6553 parm
= c_parser_parameter_declaration (parser
, NULL_TREE
);
6556 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
6559 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
6560 objc_begin_catch_clause (grokparm (parm
));
6561 if (c_parser_require (parser
, CPP_OPEN_BRACE
, "expected %<{%>"))
6562 c_parser_compound_statement_nostart (parser
);
6563 objc_finish_catch_clause ();
6565 if (c_parser_next_token_is_keyword (parser
, RID_AT_FINALLY
))
6569 c_parser_consume_token (parser
);
6570 finloc
= c_parser_peek_token (parser
)->location
;
6571 finstmt
= c_parser_compound_statement (parser
);
6572 objc_build_finally_clause (finloc
, finstmt
);
6574 objc_finish_try_stmt ();
6577 /* Parse an objc-synchronized-statement.
6579 objc-synchronized-statement:
6580 @synchronized ( expression ) compound-statement
6584 c_parser_objc_synchronized_statement (c_parser
*parser
)
6588 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_AT_SYNCHRONIZED
));
6589 c_parser_consume_token (parser
);
6590 loc
= c_parser_peek_token (parser
)->location
;
6591 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
6593 expr
= c_parser_expression (parser
).value
;
6594 expr
= c_fully_fold (expr
, false, NULL
);
6595 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
6598 expr
= error_mark_node
;
6599 stmt
= c_parser_compound_statement (parser
);
6600 objc_build_synchronized (loc
, expr
, stmt
);
6603 /* Parse an objc-selector; return NULL_TREE without an error if the
6604 next token is not an objc-selector.
6609 enum struct union if else while do for switch case default
6610 break continue return goto asm sizeof typeof __alignof
6611 unsigned long const short volatile signed restrict _Complex
6612 in out inout bycopy byref oneway int char float double void _Bool
6614 ??? Why this selection of keywords but not, for example, storage
6615 class specifiers? */
6618 c_parser_objc_selector (c_parser
*parser
)
6620 c_token
*token
= c_parser_peek_token (parser
);
6621 tree value
= token
->value
;
6622 if (token
->type
== CPP_NAME
)
6624 c_parser_consume_token (parser
);
6627 if (token
->type
!= CPP_KEYWORD
)
6629 switch (token
->keyword
)
6670 c_parser_consume_token (parser
);
6677 /* Parse an objc-selector-arg.
6681 objc-keywordname-list
6683 objc-keywordname-list:
6685 objc-keywordname-list objc-keywordname
6693 c_parser_objc_selector_arg (c_parser
*parser
)
6695 tree sel
= c_parser_objc_selector (parser
);
6696 tree list
= NULL_TREE
;
6697 if (sel
&& c_parser_next_token_is_not (parser
, CPP_COLON
))
6701 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
6703 list
= chainon (list
, build_tree_list (sel
, NULL_TREE
));
6704 sel
= c_parser_objc_selector (parser
);
6705 if (!sel
&& c_parser_next_token_is_not (parser
, CPP_COLON
))
6711 /* Parse an objc-receiver.
6720 c_parser_objc_receiver (c_parser
*parser
)
6722 if (c_parser_peek_token (parser
)->type
== CPP_NAME
6723 && (c_parser_peek_token (parser
)->id_kind
== C_ID_TYPENAME
6724 || c_parser_peek_token (parser
)->id_kind
== C_ID_CLASSNAME
))
6726 tree id
= c_parser_peek_token (parser
)->value
;
6727 c_parser_consume_token (parser
);
6728 return objc_get_class_reference (id
);
6730 return c_fully_fold (c_parser_expression (parser
).value
, false, NULL
);
6733 /* Parse objc-message-args.
6737 objc-keywordarg-list
6739 objc-keywordarg-list:
6741 objc-keywordarg-list objc-keywordarg
6744 objc-selector : objc-keywordexpr
6749 c_parser_objc_message_args (c_parser
*parser
)
6751 tree sel
= c_parser_objc_selector (parser
);
6752 tree list
= NULL_TREE
;
6753 if (sel
&& c_parser_next_token_is_not (parser
, CPP_COLON
))
6758 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
6760 keywordexpr
= c_parser_objc_keywordexpr (parser
);
6761 list
= chainon (list
, build_tree_list (sel
, keywordexpr
));
6762 sel
= c_parser_objc_selector (parser
);
6763 if (!sel
&& c_parser_next_token_is_not (parser
, CPP_COLON
))
6769 /* Parse an objc-keywordexpr.
6776 c_parser_objc_keywordexpr (c_parser
*parser
)
6779 VEC(tree
,gc
) *expr_list
= c_parser_expr_list (parser
, true, true, NULL
);
6780 if (VEC_length (tree
, expr_list
) == 1)
6782 /* Just return the expression, remove a level of
6784 ret
= VEC_index (tree
, expr_list
, 0);
6788 /* We have a comma expression, we will collapse later. */
6789 ret
= c_parser_vec_to_tree_list (expr_list
);
6791 c_parser_release_expr_list (expr_list
);
6796 /* Handle pragmas. Some OpenMP pragmas are associated with, and therefore
6797 should be considered, statements. ALLOW_STMT is true if we're within
6798 the context of a function and such pragmas are to be allowed. Returns
6799 true if we actually parsed such a pragma. */
6802 c_parser_pragma (c_parser
*parser
, enum pragma_context context
)
6806 id
= c_parser_peek_token (parser
)->pragma_kind
;
6807 gcc_assert (id
!= PRAGMA_NONE
);
6811 case PRAGMA_OMP_BARRIER
:
6812 if (context
!= pragma_compound
)
6814 if (context
== pragma_stmt
)
6815 c_parser_error (parser
, "%<#pragma omp barrier%> may only be "
6816 "used in compound statements");
6819 c_parser_omp_barrier (parser
);
6822 case PRAGMA_OMP_FLUSH
:
6823 if (context
!= pragma_compound
)
6825 if (context
== pragma_stmt
)
6826 c_parser_error (parser
, "%<#pragma omp flush%> may only be "
6827 "used in compound statements");
6830 c_parser_omp_flush (parser
);
6833 case PRAGMA_OMP_TASKWAIT
:
6834 if (context
!= pragma_compound
)
6836 if (context
== pragma_stmt
)
6837 c_parser_error (parser
, "%<#pragma omp taskwait%> may only be "
6838 "used in compound statements");
6841 c_parser_omp_taskwait (parser
);
6844 case PRAGMA_OMP_THREADPRIVATE
:
6845 c_parser_omp_threadprivate (parser
);
6848 case PRAGMA_OMP_SECTION
:
6849 error_at (c_parser_peek_token (parser
)->location
,
6850 "%<#pragma omp section%> may only be used in "
6851 "%<#pragma omp sections%> construct");
6852 c_parser_skip_until_found (parser
, CPP_PRAGMA_EOL
, NULL
);
6855 case PRAGMA_GCC_PCH_PREPROCESS
:
6856 c_parser_error (parser
, "%<#pragma GCC pch_preprocess%> must be first");
6857 c_parser_skip_until_found (parser
, CPP_PRAGMA_EOL
, NULL
);
6861 if (id
< PRAGMA_FIRST_EXTERNAL
)
6863 if (context
== pragma_external
)
6866 c_parser_error (parser
, "expected declaration specifiers");
6867 c_parser_skip_until_found (parser
, CPP_PRAGMA_EOL
, NULL
);
6870 c_parser_omp_construct (parser
);
6876 c_parser_consume_pragma (parser
);
6877 c_invoke_pragma_handler (id
);
6879 /* Skip to EOL, but suppress any error message. Those will have been
6880 generated by the handler routine through calling error, as opposed
6881 to calling c_parser_error. */
6882 parser
->error
= true;
6883 c_parser_skip_to_pragma_eol (parser
);
6888 /* The interface the pragma parsers have to the lexer. */
6891 pragma_lex (tree
*value
)
6893 c_token
*tok
= c_parser_peek_token (the_parser
);
6894 enum cpp_ttype ret
= tok
->type
;
6896 *value
= tok
->value
;
6897 if (ret
== CPP_PRAGMA_EOL
|| ret
== CPP_EOF
)
6901 if (ret
== CPP_KEYWORD
)
6903 c_parser_consume_token (the_parser
);
6910 c_parser_pragma_pch_preprocess (c_parser
*parser
)
6914 c_parser_consume_pragma (parser
);
6915 if (c_parser_next_token_is (parser
, CPP_STRING
))
6917 name
= c_parser_peek_token (parser
)->value
;
6918 c_parser_consume_token (parser
);
6921 c_parser_error (parser
, "expected string literal");
6922 c_parser_skip_to_pragma_eol (parser
);
6925 c_common_pch_pragma (parse_in
, TREE_STRING_POINTER (name
));
6928 /* OpenMP 2.5 parsing routines. */
6930 /* Returns name of the next clause.
6931 If the clause is not recognized PRAGMA_OMP_CLAUSE_NONE is returned and
6932 the token is not consumed. Otherwise appropriate pragma_omp_clause is
6933 returned and the token is consumed. */
6935 static pragma_omp_clause
6936 c_parser_omp_clause_name (c_parser
*parser
)
6938 pragma_omp_clause result
= PRAGMA_OMP_CLAUSE_NONE
;
6940 if (c_parser_next_token_is_keyword (parser
, RID_IF
))
6941 result
= PRAGMA_OMP_CLAUSE_IF
;
6942 else if (c_parser_next_token_is_keyword (parser
, RID_DEFAULT
))
6943 result
= PRAGMA_OMP_CLAUSE_DEFAULT
;
6944 else if (c_parser_next_token_is (parser
, CPP_NAME
))
6946 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
6951 if (!strcmp ("collapse", p
))
6952 result
= PRAGMA_OMP_CLAUSE_COLLAPSE
;
6953 else if (!strcmp ("copyin", p
))
6954 result
= PRAGMA_OMP_CLAUSE_COPYIN
;
6955 else if (!strcmp ("copyprivate", p
))
6956 result
= PRAGMA_OMP_CLAUSE_COPYPRIVATE
;
6959 if (!strcmp ("firstprivate", p
))
6960 result
= PRAGMA_OMP_CLAUSE_FIRSTPRIVATE
;
6963 if (!strcmp ("lastprivate", p
))
6964 result
= PRAGMA_OMP_CLAUSE_LASTPRIVATE
;
6967 if (!strcmp ("nowait", p
))
6968 result
= PRAGMA_OMP_CLAUSE_NOWAIT
;
6969 else if (!strcmp ("num_threads", p
))
6970 result
= PRAGMA_OMP_CLAUSE_NUM_THREADS
;
6973 if (!strcmp ("ordered", p
))
6974 result
= PRAGMA_OMP_CLAUSE_ORDERED
;
6977 if (!strcmp ("private", p
))
6978 result
= PRAGMA_OMP_CLAUSE_PRIVATE
;
6981 if (!strcmp ("reduction", p
))
6982 result
= PRAGMA_OMP_CLAUSE_REDUCTION
;
6985 if (!strcmp ("schedule", p
))
6986 result
= PRAGMA_OMP_CLAUSE_SCHEDULE
;
6987 else if (!strcmp ("shared", p
))
6988 result
= PRAGMA_OMP_CLAUSE_SHARED
;
6991 if (!strcmp ("untied", p
))
6992 result
= PRAGMA_OMP_CLAUSE_UNTIED
;
6997 if (result
!= PRAGMA_OMP_CLAUSE_NONE
)
6998 c_parser_consume_token (parser
);
7003 /* Validate that a clause of the given type does not already exist. */
7006 check_no_duplicate_clause (tree clauses
, enum omp_clause_code code
,
7011 for (c
= clauses
; c
; c
= OMP_CLAUSE_CHAIN (c
))
7012 if (OMP_CLAUSE_CODE (c
) == code
)
7014 error ("too many %qs clauses", name
);
7022 variable-list , identifier
7024 If KIND is nonzero, create the appropriate node and install the decl
7025 in OMP_CLAUSE_DECL and add the node to the head of the list.
7027 If KIND is zero, create a TREE_LIST with the decl in TREE_PURPOSE;
7028 return the list created. */
7031 c_parser_omp_variable_list (c_parser
*parser
, enum omp_clause_code kind
,
7034 if (c_parser_next_token_is_not (parser
, CPP_NAME
)
7035 || c_parser_peek_token (parser
)->id_kind
!= C_ID_ID
)
7036 c_parser_error (parser
, "expected identifier");
7038 while (c_parser_next_token_is (parser
, CPP_NAME
)
7039 && c_parser_peek_token (parser
)->id_kind
== C_ID_ID
)
7041 tree t
= lookup_name (c_parser_peek_token (parser
)->value
);
7044 undeclared_variable (c_parser_peek_token (parser
)->value
,
7045 c_parser_peek_token (parser
)->location
);
7046 else if (t
== error_mark_node
)
7050 tree u
= build_omp_clause (kind
);
7051 OMP_CLAUSE_DECL (u
) = t
;
7052 OMP_CLAUSE_CHAIN (u
) = list
;
7056 list
= tree_cons (t
, NULL_TREE
, list
);
7058 c_parser_consume_token (parser
);
7060 if (c_parser_next_token_is_not (parser
, CPP_COMMA
))
7063 c_parser_consume_token (parser
);
7069 /* Similarly, but expect leading and trailing parenthesis. This is a very
7070 common case for omp clauses. */
7073 c_parser_omp_var_list_parens (c_parser
*parser
, enum omp_clause_code kind
,
7076 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
7078 list
= c_parser_omp_variable_list (parser
, kind
, list
);
7079 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
7085 collapse ( constant-expression ) */
7088 c_parser_omp_clause_collapse (c_parser
*parser
, tree list
)
7090 tree c
, num
= error_mark_node
;
7094 check_no_duplicate_clause (list
, OMP_CLAUSE_COLLAPSE
, "collapse");
7096 loc
= c_parser_peek_token (parser
)->location
;
7097 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
7099 num
= c_parser_expr_no_commas (parser
, NULL
).value
;
7100 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
7102 if (num
== error_mark_node
)
7104 if (!INTEGRAL_TYPE_P (TREE_TYPE (num
))
7105 || !host_integerp (num
, 0)
7106 || (n
= tree_low_cst (num
, 0)) <= 0
7110 "collapse argument needs positive constant integer expression");
7113 c
= build_omp_clause (OMP_CLAUSE_COLLAPSE
);
7114 OMP_CLAUSE_COLLAPSE_EXPR (c
) = num
;
7115 OMP_CLAUSE_CHAIN (c
) = list
;
7120 copyin ( variable-list ) */
7123 c_parser_omp_clause_copyin (c_parser
*parser
, tree list
)
7125 return c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_COPYIN
, list
);
7129 copyprivate ( variable-list ) */
7132 c_parser_omp_clause_copyprivate (c_parser
*parser
, tree list
)
7134 return c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_COPYPRIVATE
, list
);
7138 default ( shared | none ) */
7141 c_parser_omp_clause_default (c_parser
*parser
, tree list
)
7143 enum omp_clause_default_kind kind
= OMP_CLAUSE_DEFAULT_UNSPECIFIED
;
7146 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
7148 if (c_parser_next_token_is (parser
, CPP_NAME
))
7150 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
7155 if (strcmp ("none", p
) != 0)
7157 kind
= OMP_CLAUSE_DEFAULT_NONE
;
7161 if (strcmp ("shared", p
) != 0)
7163 kind
= OMP_CLAUSE_DEFAULT_SHARED
;
7170 c_parser_consume_token (parser
);
7175 c_parser_error (parser
, "expected %<none%> or %<shared%>");
7177 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
7179 if (kind
== OMP_CLAUSE_DEFAULT_UNSPECIFIED
)
7182 check_no_duplicate_clause (list
, OMP_CLAUSE_DEFAULT
, "default");
7183 c
= build_omp_clause (OMP_CLAUSE_DEFAULT
);
7184 OMP_CLAUSE_CHAIN (c
) = list
;
7185 OMP_CLAUSE_DEFAULT_KIND (c
) = kind
;
7191 firstprivate ( variable-list ) */
7194 c_parser_omp_clause_firstprivate (c_parser
*parser
, tree list
)
7196 return c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_FIRSTPRIVATE
, list
);
7200 if ( expression ) */
7203 c_parser_omp_clause_if (c_parser
*parser
, tree list
)
7205 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
7207 tree t
= c_parser_paren_condition (parser
);
7210 check_no_duplicate_clause (list
, OMP_CLAUSE_IF
, "if");
7212 c
= build_omp_clause (OMP_CLAUSE_IF
);
7213 OMP_CLAUSE_IF_EXPR (c
) = t
;
7214 OMP_CLAUSE_CHAIN (c
) = list
;
7218 c_parser_error (parser
, "expected %<(%>");
7224 lastprivate ( variable-list ) */
7227 c_parser_omp_clause_lastprivate (c_parser
*parser
, tree list
)
7229 return c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_LASTPRIVATE
, list
);
7236 c_parser_omp_clause_nowait (c_parser
*parser ATTRIBUTE_UNUSED
, tree list
)
7240 check_no_duplicate_clause (list
, OMP_CLAUSE_NOWAIT
, "nowait");
7242 c
= build_omp_clause (OMP_CLAUSE_NOWAIT
);
7243 OMP_CLAUSE_CHAIN (c
) = list
;
7248 num_threads ( expression ) */
7251 c_parser_omp_clause_num_threads (c_parser
*parser
, tree list
)
7253 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
7255 location_t expr_loc
= c_parser_peek_token (parser
)->location
;
7256 tree c
, t
= c_parser_expression (parser
).value
;
7257 t
= c_fully_fold (t
, false, NULL
);
7259 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
7261 if (!INTEGRAL_TYPE_P (TREE_TYPE (t
)))
7263 c_parser_error (parser
, "expected integer expression");
7267 /* Attempt to statically determine when the number isn't positive. */
7268 c
= fold_build2 (LE_EXPR
, boolean_type_node
, t
,
7269 build_int_cst (TREE_TYPE (t
), 0));
7270 if (c
== boolean_true_node
)
7272 warning_at (expr_loc
, 0,
7273 "%<num_threads%> value must be positive");
7274 t
= integer_one_node
;
7277 check_no_duplicate_clause (list
, OMP_CLAUSE_NUM_THREADS
, "num_threads");
7279 c
= build_omp_clause (OMP_CLAUSE_NUM_THREADS
);
7280 OMP_CLAUSE_NUM_THREADS_EXPR (c
) = t
;
7281 OMP_CLAUSE_CHAIN (c
) = list
;
7292 c_parser_omp_clause_ordered (c_parser
*parser ATTRIBUTE_UNUSED
, tree list
)
7296 check_no_duplicate_clause (list
, OMP_CLAUSE_ORDERED
, "ordered");
7298 c
= build_omp_clause (OMP_CLAUSE_ORDERED
);
7299 OMP_CLAUSE_CHAIN (c
) = list
;
7304 private ( variable-list ) */
7307 c_parser_omp_clause_private (c_parser
*parser
, tree list
)
7309 return c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_PRIVATE
, list
);
7313 reduction ( reduction-operator : variable-list )
7316 One of: + * - & ^ | && || */
7319 c_parser_omp_clause_reduction (c_parser
*parser
, tree list
)
7321 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
7323 enum tree_code code
;
7325 switch (c_parser_peek_token (parser
)->type
)
7337 code
= BIT_AND_EXPR
;
7340 code
= BIT_XOR_EXPR
;
7343 code
= BIT_IOR_EXPR
;
7346 code
= TRUTH_ANDIF_EXPR
;
7349 code
= TRUTH_ORIF_EXPR
;
7352 c_parser_error (parser
,
7353 "expected %<+%>, %<*%>, %<-%>, %<&%>, "
7354 "%<^%>, %<|%>, %<&&%>, or %<||%>");
7355 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, 0);
7358 c_parser_consume_token (parser
);
7359 if (c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
7363 nl
= c_parser_omp_variable_list (parser
, OMP_CLAUSE_REDUCTION
, list
);
7364 for (c
= nl
; c
!= list
; c
= OMP_CLAUSE_CHAIN (c
))
7365 OMP_CLAUSE_REDUCTION_CODE (c
) = code
;
7369 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
7375 schedule ( schedule-kind )
7376 schedule ( schedule-kind , expression )
7379 static | dynamic | guided | runtime | auto
7383 c_parser_omp_clause_schedule (c_parser
*parser
, tree list
)
7387 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
7390 c
= build_omp_clause (OMP_CLAUSE_SCHEDULE
);
7392 if (c_parser_next_token_is (parser
, CPP_NAME
))
7394 tree kind
= c_parser_peek_token (parser
)->value
;
7395 const char *p
= IDENTIFIER_POINTER (kind
);
7400 if (strcmp ("dynamic", p
) != 0)
7402 OMP_CLAUSE_SCHEDULE_KIND (c
) = OMP_CLAUSE_SCHEDULE_DYNAMIC
;
7406 if (strcmp ("guided", p
) != 0)
7408 OMP_CLAUSE_SCHEDULE_KIND (c
) = OMP_CLAUSE_SCHEDULE_GUIDED
;
7412 if (strcmp ("runtime", p
) != 0)
7414 OMP_CLAUSE_SCHEDULE_KIND (c
) = OMP_CLAUSE_SCHEDULE_RUNTIME
;
7421 else if (c_parser_next_token_is_keyword (parser
, RID_STATIC
))
7422 OMP_CLAUSE_SCHEDULE_KIND (c
) = OMP_CLAUSE_SCHEDULE_STATIC
;
7423 else if (c_parser_next_token_is_keyword (parser
, RID_AUTO
))
7424 OMP_CLAUSE_SCHEDULE_KIND (c
) = OMP_CLAUSE_SCHEDULE_AUTO
;
7428 c_parser_consume_token (parser
);
7429 if (c_parser_next_token_is (parser
, CPP_COMMA
))
7432 c_parser_consume_token (parser
);
7434 here
= c_parser_peek_token (parser
)->location
;
7435 t
= c_parser_expr_no_commas (parser
, NULL
).value
;
7436 t
= c_fully_fold (t
, false, NULL
);
7438 if (OMP_CLAUSE_SCHEDULE_KIND (c
) == OMP_CLAUSE_SCHEDULE_RUNTIME
)
7439 error_at (here
, "schedule %<runtime%> does not take "
7440 "a %<chunk_size%> parameter");
7441 else if (OMP_CLAUSE_SCHEDULE_KIND (c
) == OMP_CLAUSE_SCHEDULE_AUTO
)
7443 "schedule %<auto%> does not take "
7444 "a %<chunk_size%> parameter");
7445 else if (TREE_CODE (TREE_TYPE (t
)) == INTEGER_TYPE
)
7446 OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c
) = t
;
7448 c_parser_error (parser
, "expected integer expression");
7450 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
7453 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
7454 "expected %<,%> or %<)%>");
7456 check_no_duplicate_clause (list
, OMP_CLAUSE_SCHEDULE
, "schedule");
7457 OMP_CLAUSE_CHAIN (c
) = list
;
7461 c_parser_error (parser
, "invalid schedule kind");
7462 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, 0);
7467 shared ( variable-list ) */
7470 c_parser_omp_clause_shared (c_parser
*parser
, tree list
)
7472 return c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_SHARED
, list
);
7479 c_parser_omp_clause_untied (c_parser
*parser ATTRIBUTE_UNUSED
, tree list
)
7483 /* FIXME: Should we allow duplicates? */
7484 check_no_duplicate_clause (list
, OMP_CLAUSE_UNTIED
, "untied");
7486 c
= build_omp_clause (OMP_CLAUSE_UNTIED
);
7487 OMP_CLAUSE_CHAIN (c
) = list
;
7491 /* Parse all OpenMP clauses. The set clauses allowed by the directive
7492 is a bitmask in MASK. Return the list of clauses found; the result
7493 of clause default goes in *pdefault. */
7496 c_parser_omp_all_clauses (c_parser
*parser
, unsigned int mask
,
7499 tree clauses
= NULL
;
7502 while (c_parser_next_token_is_not (parser
, CPP_PRAGMA_EOL
))
7505 pragma_omp_clause c_kind
;
7507 tree prev
= clauses
;
7509 if (!first
&& c_parser_next_token_is (parser
, CPP_COMMA
))
7510 c_parser_consume_token (parser
);
7513 here
= c_parser_peek_token (parser
)->location
;
7514 c_kind
= c_parser_omp_clause_name (parser
);
7518 case PRAGMA_OMP_CLAUSE_COLLAPSE
:
7519 clauses
= c_parser_omp_clause_collapse (parser
, clauses
);
7520 c_name
= "collapse";
7522 case PRAGMA_OMP_CLAUSE_COPYIN
:
7523 clauses
= c_parser_omp_clause_copyin (parser
, clauses
);
7526 case PRAGMA_OMP_CLAUSE_COPYPRIVATE
:
7527 clauses
= c_parser_omp_clause_copyprivate (parser
, clauses
);
7528 c_name
= "copyprivate";
7530 case PRAGMA_OMP_CLAUSE_DEFAULT
:
7531 clauses
= c_parser_omp_clause_default (parser
, clauses
);
7534 case PRAGMA_OMP_CLAUSE_FIRSTPRIVATE
:
7535 clauses
= c_parser_omp_clause_firstprivate (parser
, clauses
);
7536 c_name
= "firstprivate";
7538 case PRAGMA_OMP_CLAUSE_IF
:
7539 clauses
= c_parser_omp_clause_if (parser
, clauses
);
7542 case PRAGMA_OMP_CLAUSE_LASTPRIVATE
:
7543 clauses
= c_parser_omp_clause_lastprivate (parser
, clauses
);
7544 c_name
= "lastprivate";
7546 case PRAGMA_OMP_CLAUSE_NOWAIT
:
7547 clauses
= c_parser_omp_clause_nowait (parser
, clauses
);
7550 case PRAGMA_OMP_CLAUSE_NUM_THREADS
:
7551 clauses
= c_parser_omp_clause_num_threads (parser
, clauses
);
7552 c_name
= "num_threads";
7554 case PRAGMA_OMP_CLAUSE_ORDERED
:
7555 clauses
= c_parser_omp_clause_ordered (parser
, clauses
);
7558 case PRAGMA_OMP_CLAUSE_PRIVATE
:
7559 clauses
= c_parser_omp_clause_private (parser
, clauses
);
7562 case PRAGMA_OMP_CLAUSE_REDUCTION
:
7563 clauses
= c_parser_omp_clause_reduction (parser
, clauses
);
7564 c_name
= "reduction";
7566 case PRAGMA_OMP_CLAUSE_SCHEDULE
:
7567 clauses
= c_parser_omp_clause_schedule (parser
, clauses
);
7568 c_name
= "schedule";
7570 case PRAGMA_OMP_CLAUSE_SHARED
:
7571 clauses
= c_parser_omp_clause_shared (parser
, clauses
);
7574 case PRAGMA_OMP_CLAUSE_UNTIED
:
7575 clauses
= c_parser_omp_clause_untied (parser
, clauses
);
7579 c_parser_error (parser
, "expected %<#pragma omp%> clause");
7583 if (((mask
>> c_kind
) & 1) == 0 && !parser
->error
)
7585 /* Remove the invalid clause(s) from the list to avoid
7586 confusing the rest of the compiler. */
7588 error_at (here
, "%qs is not valid for %qs", c_name
, where
);
7593 c_parser_skip_to_pragma_eol (parser
);
7595 return c_finish_omp_clauses (clauses
);
7602 In practice, we're also interested in adding the statement to an
7603 outer node. So it is convenient if we work around the fact that
7604 c_parser_statement calls add_stmt. */
7607 c_parser_omp_structured_block (c_parser
*parser
)
7609 tree stmt
= push_stmt_list ();
7610 c_parser_statement (parser
);
7611 return pop_stmt_list (stmt
);
7615 # pragma omp atomic new-line
7619 x binop= expr | x++ | ++x | x-- | --x
7621 +, *, -, /, &, ^, |, <<, >>
7623 where x is an lvalue expression with scalar type. */
7626 c_parser_omp_atomic (c_parser
*parser
)
7630 enum tree_code code
;
7631 struct c_expr rhs_expr
;
7633 c_parser_skip_to_pragma_eol (parser
);
7635 lhs
= c_parser_unary_expression (parser
).value
;
7636 lhs
= c_fully_fold (lhs
, false, NULL
);
7637 switch (TREE_CODE (lhs
))
7641 c_parser_skip_to_end_of_block_or_statement (parser
);
7644 case PREINCREMENT_EXPR
:
7645 case POSTINCREMENT_EXPR
:
7646 lhs
= TREE_OPERAND (lhs
, 0);
7648 rhs
= integer_one_node
;
7651 case PREDECREMENT_EXPR
:
7652 case POSTDECREMENT_EXPR
:
7653 lhs
= TREE_OPERAND (lhs
, 0);
7655 rhs
= integer_one_node
;
7659 switch (c_parser_peek_token (parser
)->type
)
7665 code
= TRUNC_DIV_EXPR
;
7680 code
= BIT_AND_EXPR
;
7683 code
= BIT_IOR_EXPR
;
7686 code
= BIT_XOR_EXPR
;
7689 c_parser_error (parser
,
7690 "invalid operator for %<#pragma omp atomic%>");
7694 c_parser_consume_token (parser
);
7695 rhs_expr
= c_parser_expression (parser
);
7696 rhs_expr
= default_function_array_conversion (rhs_expr
);
7697 rhs
= rhs_expr
.value
;
7698 rhs
= c_fully_fold (rhs
, false, NULL
);
7701 stmt
= c_finish_omp_atomic (code
, lhs
, rhs
);
7702 if (stmt
!= error_mark_node
)
7704 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
7709 # pragma omp barrier new-line
7713 c_parser_omp_barrier (c_parser
*parser
)
7715 c_parser_consume_pragma (parser
);
7716 c_parser_skip_to_pragma_eol (parser
);
7718 c_finish_omp_barrier ();
7722 # pragma omp critical [(name)] new-line
7727 c_parser_omp_critical (c_parser
*parser
)
7729 tree stmt
, name
= NULL
;
7731 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
7733 c_parser_consume_token (parser
);
7734 if (c_parser_next_token_is (parser
, CPP_NAME
))
7736 name
= c_parser_peek_token (parser
)->value
;
7737 c_parser_consume_token (parser
);
7738 c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
7741 c_parser_error (parser
, "expected identifier");
7743 else if (c_parser_next_token_is_not (parser
, CPP_PRAGMA_EOL
))
7744 c_parser_error (parser
, "expected %<(%> or end of line");
7745 c_parser_skip_to_pragma_eol (parser
);
7747 stmt
= c_parser_omp_structured_block (parser
);
7748 return c_finish_omp_critical (stmt
, name
);
7752 # pragma omp flush flush-vars[opt] new-line
7755 ( variable-list ) */
7758 c_parser_omp_flush (c_parser
*parser
)
7760 c_parser_consume_pragma (parser
);
7761 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
7762 c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_ERROR
, NULL
);
7763 else if (c_parser_next_token_is_not (parser
, CPP_PRAGMA_EOL
))
7764 c_parser_error (parser
, "expected %<(%> or end of line");
7765 c_parser_skip_to_pragma_eol (parser
);
7767 c_finish_omp_flush ();
7770 /* Parse the restricted form of the for statement allowed by OpenMP.
7771 The real trick here is to determine the loop control variable early
7772 so that we can push a new decl if necessary to make it private. */
7775 c_parser_omp_for_loop (c_parser
*parser
, tree clauses
, tree
*par_clauses
)
7777 tree decl
, cond
, incr
, save_break
, save_cont
, body
, init
, stmt
, cl
;
7778 tree declv
, condv
, incrv
, initv
, for_block
= NULL
, ret
= NULL
;
7780 bool fail
= false, open_brace_parsed
= false;
7781 int i
, collapse
= 1, nbraces
= 0;
7783 for (cl
= clauses
; cl
; cl
= OMP_CLAUSE_CHAIN (cl
))
7784 if (OMP_CLAUSE_CODE (cl
) == OMP_CLAUSE_COLLAPSE
)
7785 collapse
= tree_low_cst (OMP_CLAUSE_COLLAPSE_EXPR (cl
), 0);
7787 gcc_assert (collapse
>= 1);
7789 declv
= make_tree_vec (collapse
);
7790 initv
= make_tree_vec (collapse
);
7791 condv
= make_tree_vec (collapse
);
7792 incrv
= make_tree_vec (collapse
);
7794 if (!c_parser_next_token_is_keyword (parser
, RID_FOR
))
7796 c_parser_error (parser
, "for statement expected");
7799 loc
= c_parser_peek_token (parser
)->location
;
7800 c_parser_consume_token (parser
);
7802 for (i
= 0; i
< collapse
; i
++)
7806 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
7809 /* Parse the initialization declaration or expression. */
7810 if (c_parser_next_token_starts_declspecs (parser
))
7814 = tree_cons (NULL
, c_begin_compound_stmt (true), for_block
);
7815 c_parser_declaration_or_fndef (parser
, true, true, true, true);
7816 decl
= check_for_loop_decls ();
7819 if (DECL_INITIAL (decl
) == error_mark_node
)
7820 decl
= error_mark_node
;
7823 else if (c_parser_next_token_is (parser
, CPP_NAME
)
7824 && c_parser_peek_2nd_token (parser
)->type
== CPP_EQ
)
7826 struct c_expr init_exp
;
7827 location_t init_loc
;
7829 decl
= c_parser_postfix_expression (parser
).value
;
7831 c_parser_require (parser
, CPP_EQ
, "expected %<=%>");
7832 init_loc
= c_parser_peek_token (parser
)->location
;
7834 init_exp
= c_parser_expr_no_commas (parser
, NULL
);
7835 init_exp
= default_function_array_conversion (init_exp
);
7836 init
= build_modify_expr (init_loc
,
7837 decl
, NOP_EXPR
, init_exp
.value
,
7838 init_exp
.original_type
);
7839 init
= c_process_expr_stmt (init
);
7841 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
7846 c_parser_error (parser
,
7847 "expected iteration declaration or initialization");
7848 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
7854 /* Parse the loop condition. */
7856 if (c_parser_next_token_is_not (parser
, CPP_SEMICOLON
))
7858 location_t cond_loc
= c_parser_peek_token (parser
)->location
;
7859 struct c_expr cond_expr
= c_parser_binary_expression (parser
, NULL
);
7861 cond
= cond_expr
.value
;
7862 cond
= c_objc_common_truthvalue_conversion (cond_loc
, cond
);
7863 cond
= c_fully_fold (cond
, false, NULL
);
7864 switch (cond_expr
.original_code
)
7872 /* Can't be cond = error_mark_node, because we want to preserve
7873 the location until c_finish_omp_for. */
7874 cond
= build1 (NOP_EXPR
, boolean_type_node
, error_mark_node
);
7877 protected_set_expr_location (cond
, cond_loc
);
7879 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
7881 /* Parse the increment expression. */
7883 if (c_parser_next_token_is_not (parser
, CPP_CLOSE_PAREN
))
7885 location_t incr_loc
= c_parser_peek_token (parser
)->location
;
7887 incr
= c_process_expr_stmt (c_parser_expression (parser
).value
);
7888 protected_set_expr_location (incr
, incr_loc
);
7890 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
7892 if (decl
== NULL
|| decl
== error_mark_node
|| init
== error_mark_node
)
7896 TREE_VEC_ELT (declv
, i
) = decl
;
7897 TREE_VEC_ELT (initv
, i
) = init
;
7898 TREE_VEC_ELT (condv
, i
) = cond
;
7899 TREE_VEC_ELT (incrv
, i
) = incr
;
7903 if (i
== collapse
- 1)
7906 /* FIXME: OpenMP 3.0 draft isn't very clear on what exactly is allowed
7907 in between the collapsed for loops to be still considered perfectly
7908 nested. Hopefully the final version clarifies this.
7909 For now handle (multiple) {'s and empty statements. */
7912 if (c_parser_next_token_is_keyword (parser
, RID_FOR
))
7914 c_parser_consume_token (parser
);
7917 else if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
7919 c_parser_consume_token (parser
);
7923 && c_parser_next_token_is (parser
, CPP_SEMICOLON
))
7924 c_parser_consume_token (parser
);
7927 c_parser_error (parser
, "not enough perfectly nested loops");
7930 open_brace_parsed
= true;
7940 nbraces
+= bracecount
;
7943 save_break
= c_break_label
;
7944 c_break_label
= size_one_node
;
7945 save_cont
= c_cont_label
;
7946 c_cont_label
= NULL_TREE
;
7947 body
= push_stmt_list ();
7949 if (open_brace_parsed
)
7951 stmt
= c_begin_compound_stmt (true);
7952 c_parser_compound_statement_nostart (parser
);
7953 add_stmt (c_end_compound_stmt (stmt
, true));
7956 add_stmt (c_parser_c99_block_statement (parser
));
7958 add_stmt (build1 (LABEL_EXPR
, void_type_node
, c_cont_label
));
7960 body
= pop_stmt_list (body
);
7961 c_break_label
= save_break
;
7962 c_cont_label
= save_cont
;
7966 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
7968 c_parser_consume_token (parser
);
7971 else if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
7972 c_parser_consume_token (parser
);
7975 c_parser_error (parser
, "collapsed loops not perfectly nested");
7978 stmt
= c_begin_compound_stmt (true);
7980 c_parser_compound_statement_nostart (parser
);
7981 body
= c_end_compound_stmt (stmt
, true);
7988 /* Only bother calling c_finish_omp_for if we haven't already generated
7989 an error from the initialization parsing. */
7992 stmt
= c_finish_omp_for (loc
, declv
, initv
, condv
, incrv
, body
, NULL
);
7995 if (par_clauses
!= NULL
)
7998 for (c
= par_clauses
; *c
; )
7999 if (OMP_CLAUSE_CODE (*c
) != OMP_CLAUSE_FIRSTPRIVATE
8000 && OMP_CLAUSE_CODE (*c
) != OMP_CLAUSE_LASTPRIVATE
)
8001 c
= &OMP_CLAUSE_CHAIN (*c
);
8004 for (i
= 0; i
< collapse
; i
++)
8005 if (TREE_VEC_ELT (declv
, i
) == OMP_CLAUSE_DECL (*c
))
8008 c
= &OMP_CLAUSE_CHAIN (*c
);
8009 else if (OMP_CLAUSE_CODE (*c
) == OMP_CLAUSE_FIRSTPRIVATE
)
8012 "iteration variable %qD should not be firstprivate",
8013 OMP_CLAUSE_DECL (*c
));
8014 *c
= OMP_CLAUSE_CHAIN (*c
);
8018 /* Copy lastprivate (decl) clause to OMP_FOR_CLAUSES,
8019 change it to shared (decl) in
8020 OMP_PARALLEL_CLAUSES. */
8021 tree l
= build_omp_clause (OMP_CLAUSE_LASTPRIVATE
);
8022 OMP_CLAUSE_DECL (l
) = OMP_CLAUSE_DECL (*c
);
8023 OMP_CLAUSE_CHAIN (l
) = clauses
;
8025 OMP_CLAUSE_SET_CODE (*c
, OMP_CLAUSE_SHARED
);
8029 OMP_FOR_CLAUSES (stmt
) = clauses
;
8036 stmt
= c_end_compound_stmt (TREE_VALUE (for_block
), true);
8038 for_block
= TREE_CHAIN (for_block
);
8044 #pragma omp for for-clause[optseq] new-line
8048 #define OMP_FOR_CLAUSE_MASK \
8049 ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
8050 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
8051 | (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
8052 | (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \
8053 | (1u << PRAGMA_OMP_CLAUSE_ORDERED) \
8054 | (1u << PRAGMA_OMP_CLAUSE_SCHEDULE) \
8055 | (1u << PRAGMA_OMP_CLAUSE_COLLAPSE) \
8056 | (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
8059 c_parser_omp_for (c_parser
*parser
)
8061 tree block
, clauses
, ret
;
8063 clauses
= c_parser_omp_all_clauses (parser
, OMP_FOR_CLAUSE_MASK
,
8066 block
= c_begin_compound_stmt (true);
8067 ret
= c_parser_omp_for_loop (parser
, clauses
, NULL
);
8068 block
= c_end_compound_stmt (block
, true);
8075 # pragma omp master new-line
8080 c_parser_omp_master (c_parser
*parser
)
8082 c_parser_skip_to_pragma_eol (parser
);
8083 return c_finish_omp_master (c_parser_omp_structured_block (parser
));
8087 # pragma omp ordered new-line
8092 c_parser_omp_ordered (c_parser
*parser
)
8094 c_parser_skip_to_pragma_eol (parser
);
8095 return c_finish_omp_ordered (c_parser_omp_structured_block (parser
));
8101 { section-sequence }
8104 section-directive[opt] structured-block
8105 section-sequence section-directive structured-block */
8108 c_parser_omp_sections_scope (c_parser
*parser
)
8111 bool error_suppress
= false;
8114 if (!c_parser_require (parser
, CPP_OPEN_BRACE
, "expected %<{%>"))
8116 /* Avoid skipping until the end of the block. */
8117 parser
->error
= false;
8121 stmt
= push_stmt_list ();
8123 loc
= c_parser_peek_token (parser
)->location
;
8124 if (c_parser_peek_token (parser
)->pragma_kind
!= PRAGMA_OMP_SECTION
)
8126 substmt
= push_stmt_list ();
8130 c_parser_statement (parser
);
8132 if (c_parser_peek_token (parser
)->pragma_kind
== PRAGMA_OMP_SECTION
)
8134 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
8136 if (c_parser_next_token_is (parser
, CPP_EOF
))
8140 substmt
= pop_stmt_list (substmt
);
8141 substmt
= build1 (OMP_SECTION
, void_type_node
, substmt
);
8142 SET_EXPR_LOCATION (substmt
, loc
);
8148 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
8150 if (c_parser_next_token_is (parser
, CPP_EOF
))
8153 loc
= c_parser_peek_token (parser
)->location
;
8154 if (c_parser_peek_token (parser
)->pragma_kind
== PRAGMA_OMP_SECTION
)
8156 c_parser_consume_pragma (parser
);
8157 c_parser_skip_to_pragma_eol (parser
);
8158 error_suppress
= false;
8160 else if (!error_suppress
)
8162 error_at (loc
, "expected %<#pragma omp section%> or %<}%>");
8163 error_suppress
= true;
8166 substmt
= c_parser_omp_structured_block (parser
);
8167 substmt
= build1 (OMP_SECTION
, void_type_node
, substmt
);
8168 SET_EXPR_LOCATION (substmt
, loc
);
8171 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
,
8172 "expected %<#pragma omp section%> or %<}%>");
8174 substmt
= pop_stmt_list (stmt
);
8176 stmt
= make_node (OMP_SECTIONS
);
8177 TREE_TYPE (stmt
) = void_type_node
;
8178 OMP_SECTIONS_BODY (stmt
) = substmt
;
8180 return add_stmt (stmt
);
8184 # pragma omp sections sections-clause[optseq] newline
8188 #define OMP_SECTIONS_CLAUSE_MASK \
8189 ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
8190 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
8191 | (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \
8192 | (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \
8193 | (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
8196 c_parser_omp_sections (c_parser
*parser
)
8198 tree block
, clauses
, ret
;
8200 clauses
= c_parser_omp_all_clauses (parser
, OMP_SECTIONS_CLAUSE_MASK
,
8201 "#pragma omp sections");
8203 block
= c_begin_compound_stmt (true);
8204 ret
= c_parser_omp_sections_scope (parser
);
8206 OMP_SECTIONS_CLAUSES (ret
) = clauses
;
8207 block
= c_end_compound_stmt (block
, true);
8214 # pragma parallel parallel-clause new-line
8215 # pragma parallel for parallel-for-clause new-line
8216 # pragma parallel sections parallel-sections-clause new-line
8219 #define OMP_PARALLEL_CLAUSE_MASK \
8220 ( (1u << PRAGMA_OMP_CLAUSE_IF) \
8221 | (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
8222 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
8223 | (1u << PRAGMA_OMP_CLAUSE_DEFAULT) \
8224 | (1u << PRAGMA_OMP_CLAUSE_SHARED) \
8225 | (1u << PRAGMA_OMP_CLAUSE_COPYIN) \
8226 | (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \
8227 | (1u << PRAGMA_OMP_CLAUSE_NUM_THREADS))
8230 c_parser_omp_parallel (c_parser
*parser
)
8232 enum pragma_kind p_kind
= PRAGMA_OMP_PARALLEL
;
8233 const char *p_name
= "#pragma omp parallel";
8234 tree stmt
, clauses
, par_clause
, ws_clause
, block
;
8235 unsigned int mask
= OMP_PARALLEL_CLAUSE_MASK
;
8237 if (c_parser_next_token_is_keyword (parser
, RID_FOR
))
8239 c_parser_consume_token (parser
);
8240 p_kind
= PRAGMA_OMP_PARALLEL_FOR
;
8241 p_name
= "#pragma omp parallel for";
8242 mask
|= OMP_FOR_CLAUSE_MASK
;
8243 mask
&= ~(1u << PRAGMA_OMP_CLAUSE_NOWAIT
);
8245 else if (c_parser_next_token_is (parser
, CPP_NAME
))
8247 const char *p
= IDENTIFIER_POINTER (c_parser_peek_token (parser
)->value
);
8248 if (strcmp (p
, "sections") == 0)
8250 c_parser_consume_token (parser
);
8251 p_kind
= PRAGMA_OMP_PARALLEL_SECTIONS
;
8252 p_name
= "#pragma omp parallel sections";
8253 mask
|= OMP_SECTIONS_CLAUSE_MASK
;
8254 mask
&= ~(1u << PRAGMA_OMP_CLAUSE_NOWAIT
);
8258 clauses
= c_parser_omp_all_clauses (parser
, mask
, p_name
);
8262 case PRAGMA_OMP_PARALLEL
:
8263 block
= c_begin_omp_parallel ();
8264 c_parser_statement (parser
);
8265 stmt
= c_finish_omp_parallel (clauses
, block
);
8268 case PRAGMA_OMP_PARALLEL_FOR
:
8269 block
= c_begin_omp_parallel ();
8270 c_split_parallel_clauses (clauses
, &par_clause
, &ws_clause
);
8271 c_parser_omp_for_loop (parser
, ws_clause
, &par_clause
);
8272 stmt
= c_finish_omp_parallel (par_clause
, block
);
8273 OMP_PARALLEL_COMBINED (stmt
) = 1;
8276 case PRAGMA_OMP_PARALLEL_SECTIONS
:
8277 block
= c_begin_omp_parallel ();
8278 c_split_parallel_clauses (clauses
, &par_clause
, &ws_clause
);
8279 stmt
= c_parser_omp_sections_scope (parser
);
8281 OMP_SECTIONS_CLAUSES (stmt
) = ws_clause
;
8282 stmt
= c_finish_omp_parallel (par_clause
, block
);
8283 OMP_PARALLEL_COMBINED (stmt
) = 1;
8294 # pragma omp single single-clause[optseq] new-line
8298 #define OMP_SINGLE_CLAUSE_MASK \
8299 ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
8300 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
8301 | (1u << PRAGMA_OMP_CLAUSE_COPYPRIVATE) \
8302 | (1u << PRAGMA_OMP_CLAUSE_NOWAIT))
8305 c_parser_omp_single (c_parser
*parser
)
8307 tree stmt
= make_node (OMP_SINGLE
);
8308 TREE_TYPE (stmt
) = void_type_node
;
8310 OMP_SINGLE_CLAUSES (stmt
)
8311 = c_parser_omp_all_clauses (parser
, OMP_SINGLE_CLAUSE_MASK
,
8312 "#pragma omp single");
8313 OMP_SINGLE_BODY (stmt
) = c_parser_omp_structured_block (parser
);
8315 return add_stmt (stmt
);
8319 # pragma omp task task-clause[optseq] new-line
8322 #define OMP_TASK_CLAUSE_MASK \
8323 ( (1u << PRAGMA_OMP_CLAUSE_IF) \
8324 | (1u << PRAGMA_OMP_CLAUSE_UNTIED) \
8325 | (1u << PRAGMA_OMP_CLAUSE_DEFAULT) \
8326 | (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \
8327 | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \
8328 | (1u << PRAGMA_OMP_CLAUSE_SHARED))
8331 c_parser_omp_task (c_parser
*parser
)
8333 tree clauses
, block
;
8335 clauses
= c_parser_omp_all_clauses (parser
, OMP_TASK_CLAUSE_MASK
,
8336 "#pragma omp task");
8338 block
= c_begin_omp_task ();
8339 c_parser_statement (parser
);
8340 return c_finish_omp_task (clauses
, block
);
8344 # pragma omp taskwait new-line
8348 c_parser_omp_taskwait (c_parser
*parser
)
8350 c_parser_consume_pragma (parser
);
8351 c_parser_skip_to_pragma_eol (parser
);
8353 c_finish_omp_taskwait ();
8356 /* Main entry point to parsing most OpenMP pragmas. */
8359 c_parser_omp_construct (c_parser
*parser
)
8361 enum pragma_kind p_kind
;
8365 loc
= c_parser_peek_token (parser
)->location
;
8366 p_kind
= c_parser_peek_token (parser
)->pragma_kind
;
8367 c_parser_consume_pragma (parser
);
8369 /* For all constructs below except #pragma omp atomic
8370 MUST_NOT_THROW catch handlers are needed when exceptions
8372 if (p_kind
!= PRAGMA_OMP_ATOMIC
)
8373 c_maybe_initialize_eh ();
8377 case PRAGMA_OMP_ATOMIC
:
8378 c_parser_omp_atomic (parser
);
8380 case PRAGMA_OMP_CRITICAL
:
8381 stmt
= c_parser_omp_critical (parser
);
8383 case PRAGMA_OMP_FOR
:
8384 stmt
= c_parser_omp_for (parser
);
8386 case PRAGMA_OMP_MASTER
:
8387 stmt
= c_parser_omp_master (parser
);
8389 case PRAGMA_OMP_ORDERED
:
8390 stmt
= c_parser_omp_ordered (parser
);
8392 case PRAGMA_OMP_PARALLEL
:
8393 stmt
= c_parser_omp_parallel (parser
);
8395 case PRAGMA_OMP_SECTIONS
:
8396 stmt
= c_parser_omp_sections (parser
);
8398 case PRAGMA_OMP_SINGLE
:
8399 stmt
= c_parser_omp_single (parser
);
8401 case PRAGMA_OMP_TASK
:
8402 stmt
= c_parser_omp_task (parser
);
8409 SET_EXPR_LOCATION (stmt
, loc
);
8414 # pragma omp threadprivate (variable-list) */
8417 c_parser_omp_threadprivate (c_parser
*parser
)
8421 c_parser_consume_pragma (parser
);
8422 vars
= c_parser_omp_var_list_parens (parser
, OMP_CLAUSE_ERROR
, NULL
);
8424 /* Mark every variable in VARS to be assigned thread local storage. */
8425 for (t
= vars
; t
; t
= TREE_CHAIN (t
))
8427 tree v
= TREE_PURPOSE (t
);
8429 /* If V had already been marked threadprivate, it doesn't matter
8430 whether it had been used prior to this point. */
8431 if (TREE_CODE (v
) != VAR_DECL
)
8432 error ("%qD is not a variable", v
);
8433 else if (TREE_USED (v
) && !C_DECL_THREADPRIVATE_P (v
))
8434 error ("%qE declared %<threadprivate%> after first use", v
);
8435 else if (! TREE_STATIC (v
) && ! DECL_EXTERNAL (v
))
8436 error ("automatic variable %qE cannot be %<threadprivate%>", v
);
8437 else if (TREE_TYPE (v
) == error_mark_node
)
8439 else if (! COMPLETE_TYPE_P (TREE_TYPE (v
)))
8440 error ("%<threadprivate%> %qE has incomplete type", v
);
8443 if (! DECL_THREAD_LOCAL_P (v
))
8445 DECL_TLS_MODEL (v
) = decl_default_tls_model (v
);
8446 /* If rtl has been already set for this var, call
8447 make_decl_rtl once again, so that encode_section_info
8448 has a chance to look at the new decl flags. */
8449 if (DECL_RTL_SET_P (v
))
8452 C_DECL_THREADPRIVATE_P (v
) = 1;
8456 c_parser_skip_to_pragma_eol (parser
);
8460 /* Parse a single source file. */
8465 /* Use local storage to begin. If the first token is a pragma, parse it.
8466 If it is #pragma GCC pch_preprocess, then this will load a PCH file
8467 which will cause garbage collection. */
8470 memset (&tparser
, 0, sizeof tparser
);
8471 the_parser
= &tparser
;
8473 if (c_parser_peek_token (&tparser
)->pragma_kind
== PRAGMA_GCC_PCH_PREPROCESS
)
8474 c_parser_pragma_pch_preprocess (&tparser
);
8476 the_parser
= GGC_NEW (c_parser
);
8477 *the_parser
= tparser
;
8479 c_parser_translation_unit (the_parser
);
8483 #include "gt-c-parser.h"