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 Free Software Foundation, Inc.
5 Parser actions based on the old Bison parser; structure somewhat
6 influenced by and fragments based on the C++ parser.
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify it under
11 the terms of the GNU General Public License as published by the Free
12 Software Foundation; either version 2, or (at your option) any later
15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING. If not, write to the Free
22 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
27 Make sure all relevant comments, and all relevant code from all
28 actions, brought over from old parser. Verify exact correspondence
31 Add testcases covering every input symbol in every state in old and
34 Include full syntax for GNU C, including erroneous cases accepted
35 with error messages, in syntax productions in comments.
37 Make more diagnostics in the front end generally take an explicit
38 location rather than implicitly using input_location. */
42 #include "coretypes.h"
45 #include "langhooks.h"
58 /* Miscellaneous data and functions needed for the parser. */
62 /* Objective-C specific parser/lexer information. */
64 static int objc_pq_context
= 0;
66 /* The following flag is needed to contextualize Objective-C lexical
67 analysis. In some cases (e.g., 'int NSObject;'), it is undesirable
68 to bind an identifier to an Objective-C class, even if a class with
70 static int objc_need_raw_identifier
= 0;
71 #define OBJC_NEED_RAW_IDENTIFIER(VAL) \
73 if (c_dialect_objc ()) \
74 objc_need_raw_identifier = VAL; \
77 /* The reserved keyword table. */
81 ENUM_BITFIELD(rid
) rid
: 16;
82 unsigned int disable
: 16;
85 /* Disable mask. Keywords are disabled if (reswords[i].disable &
87 #define D_C89 0x01 /* not in C89 */
88 #define D_EXT 0x02 /* GCC extension */
89 #define D_EXT89 0x04 /* GCC extension incorporated in C99 */
90 #define D_OBJC 0x08 /* Objective C only */
92 static const struct resword reswords
[] =
94 { "_Bool", RID_BOOL
, 0 },
95 { "_Complex", RID_COMPLEX
, 0 },
96 { "__FUNCTION__", RID_FUNCTION_NAME
, 0 },
97 { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME
, 0 },
98 { "__alignof", RID_ALIGNOF
, 0 },
99 { "__alignof__", RID_ALIGNOF
, 0 },
100 { "__asm", RID_ASM
, 0 },
101 { "__asm__", RID_ASM
, 0 },
102 { "__attribute", RID_ATTRIBUTE
, 0 },
103 { "__attribute__", RID_ATTRIBUTE
, 0 },
104 { "__builtin_choose_expr", RID_CHOOSE_EXPR
, 0 },
105 { "__builtin_offsetof", RID_OFFSETOF
, 0 },
106 { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P
, 0 },
107 { "__builtin_va_arg", RID_VA_ARG
, 0 },
108 { "__complex", RID_COMPLEX
, 0 },
109 { "__complex__", RID_COMPLEX
, 0 },
110 { "__const", RID_CONST
, 0 },
111 { "__const__", RID_CONST
, 0 },
112 { "__extension__", RID_EXTENSION
, 0 },
113 { "__func__", RID_C99_FUNCTION_NAME
, 0 },
114 { "__imag", RID_IMAGPART
, 0 },
115 { "__imag__", RID_IMAGPART
, 0 },
116 { "__inline", RID_INLINE
, 0 },
117 { "__inline__", RID_INLINE
, 0 },
118 { "__label__", RID_LABEL
, 0 },
119 { "__real", RID_REALPART
, 0 },
120 { "__real__", RID_REALPART
, 0 },
121 { "__restrict", RID_RESTRICT
, 0 },
122 { "__restrict__", RID_RESTRICT
, 0 },
123 { "__signed", RID_SIGNED
, 0 },
124 { "__signed__", RID_SIGNED
, 0 },
125 { "__thread", RID_THREAD
, 0 },
126 { "__typeof", RID_TYPEOF
, 0 },
127 { "__typeof__", RID_TYPEOF
, 0 },
128 { "__volatile", RID_VOLATILE
, 0 },
129 { "__volatile__", RID_VOLATILE
, 0 },
130 { "asm", RID_ASM
, D_EXT
},
131 { "auto", RID_AUTO
, 0 },
132 { "break", RID_BREAK
, 0 },
133 { "case", RID_CASE
, 0 },
134 { "char", RID_CHAR
, 0 },
135 { "const", RID_CONST
, 0 },
136 { "continue", RID_CONTINUE
, 0 },
137 { "default", RID_DEFAULT
, 0 },
139 { "double", RID_DOUBLE
, 0 },
140 { "else", RID_ELSE
, 0 },
141 { "enum", RID_ENUM
, 0 },
142 { "extern", RID_EXTERN
, 0 },
143 { "float", RID_FLOAT
, 0 },
144 { "for", RID_FOR
, 0 },
145 { "goto", RID_GOTO
, 0 },
147 { "inline", RID_INLINE
, D_EXT89
},
148 { "int", RID_INT
, 0 },
149 { "long", RID_LONG
, 0 },
150 { "register", RID_REGISTER
, 0 },
151 { "restrict", RID_RESTRICT
, D_C89
},
152 { "return", RID_RETURN
, 0 },
153 { "short", RID_SHORT
, 0 },
154 { "signed", RID_SIGNED
, 0 },
155 { "sizeof", RID_SIZEOF
, 0 },
156 { "static", RID_STATIC
, 0 },
157 { "struct", RID_STRUCT
, 0 },
158 { "switch", RID_SWITCH
, 0 },
159 { "typedef", RID_TYPEDEF
, 0 },
160 { "typeof", RID_TYPEOF
, D_EXT
},
161 { "union", RID_UNION
, 0 },
162 { "unsigned", RID_UNSIGNED
, 0 },
163 { "void", RID_VOID
, 0 },
164 { "volatile", RID_VOLATILE
, 0 },
165 { "while", RID_WHILE
, 0 },
166 /* These Objective-C keywords are recognized only immediately after
168 { "class", RID_AT_CLASS
, D_OBJC
},
169 { "compatibility_alias", RID_AT_ALIAS
, D_OBJC
},
170 { "defs", RID_AT_DEFS
, D_OBJC
},
171 { "encode", RID_AT_ENCODE
, D_OBJC
},
172 { "end", RID_AT_END
, D_OBJC
},
173 { "implementation", RID_AT_IMPLEMENTATION
, D_OBJC
},
174 { "interface", RID_AT_INTERFACE
, D_OBJC
},
175 { "private", RID_AT_PRIVATE
, D_OBJC
},
176 { "protected", RID_AT_PROTECTED
, D_OBJC
},
177 { "protocol", RID_AT_PROTOCOL
, D_OBJC
},
178 { "public", RID_AT_PUBLIC
, D_OBJC
},
179 { "selector", RID_AT_SELECTOR
, D_OBJC
},
180 { "throw", RID_AT_THROW
, D_OBJC
},
181 { "try", RID_AT_TRY
, D_OBJC
},
182 { "catch", RID_AT_CATCH
, D_OBJC
},
183 { "finally", RID_AT_FINALLY
, D_OBJC
},
184 { "synchronized", RID_AT_SYNCHRONIZED
, D_OBJC
},
185 /* These are recognized only in protocol-qualifier context
187 { "bycopy", RID_BYCOPY
, D_OBJC
},
188 { "byref", RID_BYREF
, D_OBJC
},
189 { "in", RID_IN
, D_OBJC
},
190 { "inout", RID_INOUT
, D_OBJC
},
191 { "oneway", RID_ONEWAY
, D_OBJC
},
192 { "out", RID_OUT
, D_OBJC
},
194 #define N_reswords (sizeof reswords / sizeof (struct resword))
196 /* Initialization routine for this file. */
201 /* The only initialization required is of the reserved word
205 int mask
= (flag_isoc99
? 0 : D_C89
)
206 | (flag_no_asm
? (flag_isoc99
? D_EXT
: D_EXT
|D_EXT89
) : 0);
208 if (!c_dialect_objc ())
211 ridpointers
= GGC_CNEWVEC (tree
, (int) RID_MAX
);
212 for (i
= 0; i
< N_reswords
; i
++)
214 /* If a keyword is disabled, do not enter it into the table
215 and so create a canonical spelling that isn't a keyword. */
216 if (reswords
[i
].disable
& mask
)
219 id
= get_identifier (reswords
[i
].word
);
220 C_RID_CODE (id
) = reswords
[i
].rid
;
221 C_IS_RESERVED_WORD (id
) = 1;
222 ridpointers
[(int) reswords
[i
].rid
] = id
;
226 /* The C lexer intermediates between the lexer in cpplib and c-lex.c
227 and the C parser. Unlike the C++ lexer, the parser structure
228 stores the lexer information instead of using a separate structure.
229 Identifiers are separated into ordinary identifiers, type names,
230 keywords and some other Objective-C types of identifiers, and some
231 look-ahead is maintained.
233 ??? It might be a good idea to lex the whole file up front (as for
234 C++). It would then be possible to share more of the C and C++
235 lexer code, if desired. */
237 /* The following local token type is used. */
240 #define CPP_KEYWORD ((enum cpp_ttype) (N_TTYPES + 1))
242 /* More information about the type of a CPP_NAME token. */
243 typedef enum c_id_kind
{
244 /* An ordinary identifier. */
246 /* An identifier declared as a typedef name. */
248 /* An identifier declared as an Objective-C class name. */
250 /* Not an identifier. */
254 /* A single C token after string literal concatenation and conversion
255 of preprocessing tokens to tokens. */
256 typedef struct c_token
GTY (())
258 /* The kind of token. */
259 ENUM_BITFIELD (cpp_ttype
) type
: 8;
260 /* If this token is a CPP_NAME, this value indicates whether also
261 declared as some kind of type. Otherwise, it is C_ID_NONE. */
262 ENUM_BITFIELD (c_id_kind
) id_kind
: 8;
263 /* If this token is a keyword, this value indicates which keyword.
264 Otherwise, this value is RID_MAX. */
265 ENUM_BITFIELD (rid
) keyword
: 8;
266 /* True if this token is from a system header. */
267 BOOL_BITFIELD in_system_header
: 1;
268 /* The value associated with this token, if any. */
270 /* The location at which this token was found. */
274 /* A parser structure recording information about the state and
275 context of parsing. Includes lexer information with up to two
276 tokens of look-ahead; more are not needed for C. */
277 typedef struct c_parser
GTY(())
279 /* The look-ahead tokens. */
281 /* How many look-ahead tokens are available (0, 1 or 2). */
283 /* True if a syntax error is being recovered from; false otherwise.
284 c_parser_error sets this flag. It should clear this flag when
285 enough tokens have been consumed to recover from the error. */
286 BOOL_BITFIELD error
: 1;
289 /* Read in and lex a single token, storing it in *TOKEN. */
292 c_lex_one_token (c_token
*token
)
294 timevar_push (TV_LEX
);
295 token
->type
= c_lex_with_flags (&token
->value
, &token
->location
, NULL
);
296 token
->in_system_header
= in_system_header
;
300 token
->id_kind
= C_ID_NONE
;
301 token
->keyword
= RID_MAX
;
305 int objc_force_identifier
= objc_need_raw_identifier
;
306 OBJC_NEED_RAW_IDENTIFIER (0);
308 if (C_IS_RESERVED_WORD (token
->value
))
310 enum rid rid_code
= C_RID_CODE (token
->value
);
312 if (c_dialect_objc ())
314 if (!OBJC_IS_AT_KEYWORD (rid_code
)
315 && (!OBJC_IS_PQ_KEYWORD (rid_code
) || objc_pq_context
))
317 /* Return the canonical spelling for this keyword. */
318 token
->value
= ridpointers
[(int) rid_code
];
319 token
->type
= CPP_KEYWORD
;
320 token
->keyword
= rid_code
;
326 /* Return the canonical spelling for this keyword. */
327 token
->value
= ridpointers
[(int) rid_code
];
328 token
->type
= CPP_KEYWORD
;
329 token
->keyword
= rid_code
;
334 decl
= lookup_name (token
->value
);
337 if (TREE_CODE (decl
) == TYPE_DECL
)
339 token
->id_kind
= C_ID_TYPENAME
;
343 else if (c_dialect_objc ())
345 tree objc_interface_decl
= objc_is_class_name (token
->value
);
346 /* Objective-C class names are in the same namespace as
347 variables and typedefs, and hence are shadowed by local
349 if (objc_interface_decl
350 && (global_bindings_p ()
351 || (!objc_force_identifier
&& !decl
)))
353 token
->value
= objc_interface_decl
;
354 token
->id_kind
= C_ID_CLASSNAME
;
359 token
->id_kind
= C_ID_ID
;
362 /* This only happens in Objective-C; it must be a keyword. */
363 token
->type
= CPP_KEYWORD
;
364 token
->id_kind
= C_ID_NONE
;
365 token
->keyword
= C_RID_CODE (token
->value
);
369 case CPP_CLOSE_PAREN
:
371 /* These tokens may affect the interpretation of any identifiers
372 following, if doing Objective-C. */
373 OBJC_NEED_RAW_IDENTIFIER (0);
374 token
->id_kind
= C_ID_NONE
;
375 token
->keyword
= RID_MAX
;
378 token
->id_kind
= C_ID_NONE
;
379 token
->keyword
= RID_MAX
;
382 timevar_pop (TV_LEX
);
385 /* Return a pointer to the next token from PARSER, reading it in if
388 static inline c_token
*
389 c_parser_peek_token (c_parser
*parser
)
391 if (parser
->tokens_avail
== 0)
393 c_lex_one_token (&parser
->tokens
[0]);
394 parser
->tokens_avail
= 1;
396 return &parser
->tokens
[0];
399 /* Return true if the next token from PARSER has the indicated
403 c_parser_next_token_is (c_parser
*parser
, enum cpp_ttype type
)
405 return c_parser_peek_token (parser
)->type
== type
;
408 /* Return true if the next token from PARSER does not have the
412 c_parser_next_token_is_not (c_parser
*parser
, enum cpp_ttype type
)
414 return !c_parser_next_token_is (parser
, type
);
417 /* Return true if the next token from PARSER is the indicated
421 c_parser_next_token_is_keyword (c_parser
*parser
, enum rid keyword
)
425 /* Peek at the next token. */
426 token
= c_parser_peek_token (parser
);
427 /* Check to see if it is the indicated keyword. */
428 return token
->keyword
== keyword
;
431 /* Return true if TOKEN can start a type name,
434 c_token_starts_typename (c_token
*token
)
439 switch (token
->id_kind
)
446 gcc_assert (c_dialect_objc ());
452 switch (token
->keyword
)
478 if (c_dialect_objc ())
486 /* Return true if the next token from PARSER can start a type name,
489 c_parser_next_token_starts_typename (c_parser
*parser
)
491 c_token
*token
= c_parser_peek_token (parser
);
492 return c_token_starts_typename (token
);
495 /* Return true if TOKEN can start declaration specifiers, false
498 c_token_starts_declspecs (c_token
*token
)
503 switch (token
->id_kind
)
510 gcc_assert (c_dialect_objc ());
516 switch (token
->keyword
)
549 if (c_dialect_objc ())
557 /* Return true if the next token from PARSER can start declaration
558 specifiers, false otherwise. */
560 c_parser_next_token_starts_declspecs (c_parser
*parser
)
562 c_token
*token
= c_parser_peek_token (parser
);
563 return c_token_starts_declspecs (token
);
566 /* Return a pointer to the next-but-one token from PARSER, reading it
567 in if necessary. The next token is already read in. */
570 c_parser_peek_2nd_token (c_parser
*parser
)
572 if (parser
->tokens_avail
>= 2)
573 return &parser
->tokens
[1];
574 gcc_assert (parser
->tokens_avail
== 1);
575 gcc_assert (parser
->tokens
[0].type
!= CPP_EOF
);
576 c_lex_one_token (&parser
->tokens
[1]);
577 parser
->tokens_avail
= 2;
578 return &parser
->tokens
[1];
581 /* Consume the next token from PARSER. */
584 c_parser_consume_token (c_parser
*parser
)
586 if (parser
->tokens_avail
== 2)
587 parser
->tokens
[0] = parser
->tokens
[1];
590 gcc_assert (parser
->tokens_avail
== 1);
591 gcc_assert (parser
->tokens
[0].type
!= CPP_EOF
);
593 parser
->tokens_avail
--;
596 /* Update the globals input_location and in_system_header from
599 c_parser_set_source_position_from_token (c_token
*token
)
601 if (token
->type
!= CPP_EOF
)
603 input_location
= token
->location
;
604 in_system_header
= token
->in_system_header
;
608 /* Allocate a new parser. */
613 /* Use local storage to lex the first token because loading a PCH
614 file may cause garbage collection. */
617 memset (&tparser
, 0, sizeof tparser
);
618 c_lex_one_token (&tparser
.tokens
[0]);
619 tparser
.tokens_avail
= 1;
620 ret
= GGC_NEW (c_parser
);
621 memcpy (ret
, &tparser
, sizeof tparser
);
625 /* Issue a diagnostic of the form
626 FILE:LINE: MESSAGE before TOKEN
627 where TOKEN is the next token in the input stream of PARSER.
628 MESSAGE (specified by the caller) is usually of the form "expected
631 Do not issue a diagnostic if still recovering from an error.
633 ??? This is taken from the C++ parser, but building up messages in
634 this way is not i18n-friendly and some other approach should be
638 c_parser_error (c_parser
*parser
, const char *gmsgid
)
640 c_token
*token
= c_parser_peek_token (parser
);
643 parser
->error
= true;
646 /* This diagnostic makes more sense if it is tagged to the line of
647 the token we just peeked at. */
648 c_parser_set_source_position_from_token (token
);
649 c_parse_error (gmsgid
,
650 /* Because c_parse_error does not understand
651 CPP_KEYWORD, keywords are treated like
653 (token
->type
== CPP_KEYWORD
? CPP_NAME
: token
->type
),
657 /* If the next token is of the indicated TYPE, consume it. Otherwise,
658 issue the error MSGID. If MSGID is NULL then a message has already
659 been produced and no message will be produced this time. Returns
660 true if found, false otherwise. */
663 c_parser_require (c_parser
*parser
,
667 if (c_parser_next_token_is (parser
, type
))
669 c_parser_consume_token (parser
);
674 c_parser_error (parser
, msgid
);
679 /* If the next token is the indicated keyword, consume it. Otherwise,
680 issue the error MSGID. Returns true if found, false otherwise. */
683 c_parser_require_keyword (c_parser
*parser
,
687 if (c_parser_next_token_is_keyword (parser
, keyword
))
689 c_parser_consume_token (parser
);
694 c_parser_error (parser
, msgid
);
699 /* Like c_parser_require, except that tokens will be skipped until the
700 desired token is found. An error message is still produced if the
701 next token is not as expected. If MSGID is NULL then a message has
702 already been produced and no message will be produced this
706 c_parser_skip_until_found (c_parser
*parser
,
710 unsigned nesting_depth
= 0;
712 if (c_parser_require (parser
, type
, msgid
))
715 /* Skip tokens until the desired token is found. */
718 /* Peek at the next token. */
719 c_token
*token
= c_parser_peek_token (parser
);
720 /* If we've reached the token we want, consume it and stop. */
721 if (token
->type
== type
&& !nesting_depth
)
723 c_parser_consume_token (parser
);
726 /* If we've run out of tokens, stop. */
727 if (token
->type
== CPP_EOF
)
729 if (token
->type
== CPP_OPEN_BRACE
730 || token
->type
== CPP_OPEN_PAREN
731 || token
->type
== CPP_OPEN_SQUARE
)
733 else if (token
->type
== CPP_CLOSE_BRACE
734 || token
->type
== CPP_CLOSE_PAREN
735 || token
->type
== CPP_CLOSE_SQUARE
)
737 if (nesting_depth
-- == 0)
740 /* Consume this token. */
741 c_parser_consume_token (parser
);
743 parser
->error
= false;
746 /* Skip tokens until the end of a parameter is found, but do not
747 consume the comma, semicolon or closing delimiter. */
750 c_parser_skip_to_end_of_parameter (c_parser
*parser
)
752 unsigned nesting_depth
= 0;
756 c_token
*token
= c_parser_peek_token (parser
);
757 if ((token
->type
== CPP_COMMA
|| token
->type
== CPP_SEMICOLON
)
760 /* If we've run out of tokens, stop. */
761 if (token
->type
== CPP_EOF
)
763 if (token
->type
== CPP_OPEN_BRACE
764 || token
->type
== CPP_OPEN_PAREN
765 || token
->type
== CPP_OPEN_SQUARE
)
767 else if (token
->type
== CPP_CLOSE_BRACE
768 || token
->type
== CPP_CLOSE_PAREN
769 || token
->type
== CPP_CLOSE_SQUARE
)
771 if (nesting_depth
-- == 0)
774 /* Consume this token. */
775 c_parser_consume_token (parser
);
777 parser
->error
= false;
780 /* Skip tokens until we have consumed an entire block, or until we
781 have consumed a non-nested ';'. */
784 c_parser_skip_to_end_of_block_or_statement (c_parser
*parser
)
786 unsigned nesting_depth
= 0;
792 /* Peek at the next token. */
793 token
= c_parser_peek_token (parser
);
794 /* If we've run out of tokens, stop. */
795 if (token
->type
== CPP_EOF
)
797 /* If the next token is a ';', we have reached the end of the
799 if (token
->type
== CPP_SEMICOLON
&& !nesting_depth
)
801 /* Consume the ';'. */
802 c_parser_consume_token (parser
);
805 /* If the next token is a non-nested '}', then we have reached
806 the end of the current block. */
807 if (token
->type
== CPP_CLOSE_BRACE
808 && (nesting_depth
== 0 || --nesting_depth
== 0))
810 c_parser_consume_token (parser
);
813 /* If it the next token is a '{', then we are entering a new
814 block. Consume the entire block. */
815 if (token
->type
== CPP_OPEN_BRACE
)
817 c_parser_consume_token (parser
);
819 parser
->error
= false;
823 /* Save the warning flags which are controlled by __extension__. */
826 disable_extension_diagnostics (void)
829 | (warn_pointer_arith
<< 1)
830 | (warn_traditional
<< 2)
833 warn_pointer_arith
= 0;
834 warn_traditional
= 0;
839 /* Restore the warning flags which are controlled by __extension__.
840 FLAGS is the return value from disable_extension_diagnostics. */
843 restore_extension_diagnostics (int flags
)
845 pedantic
= flags
& 1;
846 warn_pointer_arith
= (flags
>> 1) & 1;
847 warn_traditional
= (flags
>> 2) & 1;
848 flag_iso
= (flags
>> 3) & 1;
851 /* Possibly kinds of declarator to parse. */
852 typedef enum c_dtr_syn
{
853 /* A normal declarator with an identifier. */
855 /* An abstract declarator (maybe empty). */
857 /* A parameter declarator: may be either, but after a type name does
858 not redeclare a typedef name as an identifier if it can
859 alternatively be interpreted as a typedef name; see DR#009,
860 applied in C90 TC1, omitted from C99 and reapplied in C99 TC2
861 following DR#249. For example, given a typedef T, "int T" and
862 "int *T" are valid parameter declarations redeclaring T, while
863 "int (T)" and "int * (T)" and "int (T[])" and "int (T (int))" are
864 abstract declarators rather than involving redundant parentheses;
865 the same applies with attributes inside the parentheses before
870 static void c_parser_external_declaration (c_parser
*);
871 static void c_parser_asm_definition (c_parser
*);
872 static void c_parser_declaration_or_fndef (c_parser
*, bool, bool, bool, bool);
873 static void c_parser_declspecs (c_parser
*, struct c_declspecs
*, bool, bool,
875 static struct c_typespec
c_parser_enum_specifier (c_parser
*);
876 static struct c_typespec
c_parser_struct_or_union_specifier (c_parser
*);
877 static tree
c_parser_struct_declaration (c_parser
*);
878 static struct c_typespec
c_parser_typeof_specifier (c_parser
*);
879 static struct c_declarator
*c_parser_declarator (c_parser
*, bool, c_dtr_syn
,
881 static struct c_declarator
*c_parser_direct_declarator (c_parser
*, bool,
883 static struct c_declarator
*c_parser_direct_declarator_inner (c_parser
*,
885 struct c_declarator
*);
886 static struct c_arg_info
*c_parser_parms_declarator (c_parser
*, bool, tree
);
887 static struct c_arg_info
*c_parser_parms_list_declarator (c_parser
*, tree
);
888 static struct c_parm
*c_parser_parameter_declaration (c_parser
*, tree
);
889 static tree
c_parser_simple_asm_expr (c_parser
*);
890 static tree
c_parser_attributes (c_parser
*);
891 static struct c_type_name
*c_parser_type_name (c_parser
*);
892 static struct c_expr
c_parser_initializer (c_parser
*);
893 static struct c_expr
c_parser_braced_init (c_parser
*, tree
, bool);
894 static void c_parser_initelt (c_parser
*);
895 static void c_parser_initval (c_parser
*, struct c_expr
*);
896 static tree
c_parser_compound_statement (c_parser
*);
897 static void c_parser_compound_statement_nostart (c_parser
*);
898 static void c_parser_label (c_parser
*);
899 static void c_parser_statement (c_parser
*);
900 static void c_parser_statement_after_labels (c_parser
*);
901 static void c_parser_if_statement (c_parser
*);
902 static void c_parser_switch_statement (c_parser
*);
903 static void c_parser_while_statement (c_parser
*);
904 static void c_parser_do_statement (c_parser
*);
905 static void c_parser_for_statement (c_parser
*);
906 static tree
c_parser_asm_statement (c_parser
*);
907 static tree
c_parser_asm_operands (c_parser
*, bool);
908 static tree
c_parser_asm_clobbers (c_parser
*);
909 static struct c_expr
c_parser_expr_no_commas (c_parser
*, struct c_expr
*);
910 static struct c_expr
c_parser_conditional_expression (c_parser
*,
912 static struct c_expr
c_parser_binary_expression (c_parser
*, struct c_expr
*);
913 static struct c_expr
c_parser_cast_expression (c_parser
*, struct c_expr
*);
914 static struct c_expr
c_parser_unary_expression (c_parser
*);
915 static struct c_expr
c_parser_sizeof_expression (c_parser
*);
916 static struct c_expr
c_parser_alignof_expression (c_parser
*);
917 static struct c_expr
c_parser_postfix_expression (c_parser
*);
918 static struct c_expr
c_parser_postfix_expression_after_paren_type (c_parser
*,
919 struct c_type_name
*);
920 static struct c_expr
c_parser_postfix_expression_after_primary (c_parser
*,
922 static struct c_expr
c_parser_expression (c_parser
*);
923 static struct c_expr
c_parser_expression_conv (c_parser
*);
924 static tree
c_parser_expr_list (c_parser
*, bool);
926 /* These Objective-C parser functions are only ever called when
927 compiling Objective-C. */
928 static void c_parser_objc_class_definition (c_parser
*);
929 static void c_parser_objc_class_instance_variables (c_parser
*);
930 static void c_parser_objc_class_declaration (c_parser
*);
931 static void c_parser_objc_alias_declaration (c_parser
*);
932 static void c_parser_objc_protocol_definition (c_parser
*);
933 static enum tree_code
c_parser_objc_method_type (c_parser
*);
934 static void c_parser_objc_method_definition (c_parser
*);
935 static void c_parser_objc_methodprotolist (c_parser
*);
936 static void c_parser_objc_methodproto (c_parser
*);
937 static tree
c_parser_objc_method_decl (c_parser
*);
938 static tree
c_parser_objc_type_name (c_parser
*);
939 static tree
c_parser_objc_protocol_refs (c_parser
*);
940 static void c_parser_objc_try_catch_statement (c_parser
*);
941 static void c_parser_objc_synchronized_statement (c_parser
*);
942 static tree
c_parser_objc_selector (c_parser
*);
943 static tree
c_parser_objc_selector_arg (c_parser
*);
944 static tree
c_parser_objc_receiver (c_parser
*);
945 static tree
c_parser_objc_message_args (c_parser
*);
946 static tree
c_parser_objc_keywordexpr (c_parser
*);
948 /* Parse a translation unit (C90 6.7, C99 6.9).
951 external-declarations
953 external-declarations:
955 external-declarations external-declaration
964 c_parser_translation_unit (c_parser
*parser
)
966 if (c_parser_next_token_is (parser
, CPP_EOF
))
969 pedwarn ("ISO C forbids an empty source file");
973 void *obstack_position
= obstack_alloc (&parser_obstack
, 0);
977 c_parser_external_declaration (parser
);
978 obstack_free (&parser_obstack
, obstack_position
);
980 while (c_parser_next_token_is_not (parser
, CPP_EOF
));
984 /* Parse an external declaration (C90 6.7, C99 6.9).
986 external-declaration:
992 external-declaration:
995 __extension__ external-declaration
999 external-declaration:
1000 objc-class-definition
1001 objc-class-declaration
1002 objc-alias-declaration
1003 objc-protocol-definition
1004 objc-method-definition
1009 c_parser_external_declaration (c_parser
*parser
)
1012 switch (c_parser_peek_token (parser
)->type
)
1015 switch (c_parser_peek_token (parser
)->keyword
)
1018 ext
= disable_extension_diagnostics ();
1019 c_parser_consume_token (parser
);
1020 c_parser_external_declaration (parser
);
1021 restore_extension_diagnostics (ext
);
1024 c_parser_asm_definition (parser
);
1026 case RID_AT_INTERFACE
:
1027 case RID_AT_IMPLEMENTATION
:
1028 gcc_assert (c_dialect_objc ());
1029 c_parser_objc_class_definition (parser
);
1032 gcc_assert (c_dialect_objc ());
1033 c_parser_objc_class_declaration (parser
);
1036 gcc_assert (c_dialect_objc ());
1037 c_parser_objc_alias_declaration (parser
);
1039 case RID_AT_PROTOCOL
:
1040 gcc_assert (c_dialect_objc ());
1041 c_parser_objc_protocol_definition (parser
);
1044 gcc_assert (c_dialect_objc ());
1045 c_parser_consume_token (parser
);
1046 objc_finish_implementation ();
1054 pedwarn ("ISO C does not allow extra %<;%> outside of a function");
1055 c_parser_consume_token (parser
);
1059 if (c_dialect_objc ())
1061 c_parser_objc_method_definition (parser
);
1064 /* Else fall through, and yield a syntax error trying to parse
1065 as a declaration or function definition. */
1068 /* A declaration or a function definition. We can only tell
1069 which after parsing the declaration specifiers, if any, and
1070 the first declarator. */
1071 c_parser_declaration_or_fndef (parser
, true, true, false, true);
1076 /* Parse a declaration or function definition (C90 6.5, 6.7.1, C99
1077 6.7, 6.9.1). If FNDEF_OK is true, a function definition is
1078 accepted; otherwise (old-style parameter declarations) only other
1079 declarations are accepted. If NESTED is true, we are inside a
1080 function or parsing old-style parameter declarations; any functions
1081 encountered are nested functions and declaration specifiers are
1082 required; otherwise we are at top level and functions are normal
1083 functions and declaration specifiers may be optional. If EMPTY_OK
1084 is true, empty declarations are OK (subject to all other
1085 constraints); otherwise (old-style parameter declarations) they are
1086 diagnosed. If START_ATTR_OK is true, the declaration specifiers
1087 may start with attributes; otherwise they may not.
1090 declaration-specifiers init-declarator-list[opt] ;
1092 function-definition:
1093 declaration-specifiers[opt] declarator declaration-list[opt]
1098 declaration-list declaration
1100 init-declarator-list:
1102 init-declarator-list , init-declarator
1105 declarator simple-asm-expr[opt] attributes[opt]
1106 declarator simple-asm-expr[opt] attributes[opt] = initializer
1110 nested-function-definition:
1111 declaration-specifiers declarator declaration-list[opt]
1114 The simple-asm-expr and attributes are GNU extensions.
1116 This function does not handle __extension__; that is handled in its
1117 callers. ??? Following the old parser, __extension__ may start
1118 external declarations, declarations in functions and declarations
1119 at the start of "for" loops, but not old-style parameter
1122 C99 requires declaration specifiers in a function definition; the
1123 absence is diagnosed through the diagnosis of implicit int. In GNU
1124 C we also allow but diagnose declarations without declaration
1125 specifiers, but only at top level (elsewhere they conflict with
1129 c_parser_declaration_or_fndef (c_parser
*parser
, bool fndef_ok
, bool empty_ok
,
1130 bool nested
, bool start_attr_ok
)
1132 struct c_declspecs
*specs
;
1134 tree all_prefix_attrs
;
1135 bool diagnosed_no_specs
= false;
1136 specs
= build_null_declspecs ();
1137 c_parser_declspecs (parser
, specs
, true, true, start_attr_ok
);
1140 c_parser_skip_to_end_of_block_or_statement (parser
);
1143 if (nested
&& !specs
->declspecs_seen_p
)
1145 c_parser_error (parser
, "expected declaration specifiers");
1146 c_parser_skip_to_end_of_block_or_statement (parser
);
1149 finish_declspecs (specs
);
1150 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
1156 shadow_tag_warned (specs
, 1);
1157 pedwarn ("empty declaration");
1159 c_parser_consume_token (parser
);
1162 pending_xref_error ();
1163 prefix_attrs
= specs
->attrs
;
1164 all_prefix_attrs
= prefix_attrs
;
1165 specs
->attrs
= NULL_TREE
;
1168 struct c_declarator
*declarator
;
1171 /* Declaring either one or more declarators (in which case we
1172 should diagnose if there were no declaration specifiers) or a
1173 function definition (in which case the diagnostic for
1174 implicit int suffices). */
1175 declarator
= c_parser_declarator (parser
, specs
->type_seen_p
,
1176 C_DTR_NORMAL
, &dummy
);
1177 if (declarator
== NULL
)
1179 c_parser_skip_to_end_of_block_or_statement (parser
);
1182 if (c_parser_next_token_is (parser
, CPP_EQ
)
1183 || c_parser_next_token_is (parser
, CPP_COMMA
)
1184 || c_parser_next_token_is (parser
, CPP_SEMICOLON
)
1185 || c_parser_next_token_is_keyword (parser
, RID_ASM
)
1186 || c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
1188 tree asm_name
= NULL_TREE
;
1189 tree postfix_attrs
= NULL_TREE
;
1190 if (!diagnosed_no_specs
&& !specs
->declspecs_seen_p
)
1192 diagnosed_no_specs
= true;
1193 pedwarn ("data definition has no type or storage class");
1195 /* Having seen a data definition, there cannot now be a
1196 function definition. */
1198 if (c_parser_next_token_is_keyword (parser
, RID_ASM
))
1199 asm_name
= c_parser_simple_asm_expr (parser
);
1200 if (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
1201 postfix_attrs
= c_parser_attributes (parser
);
1202 if (c_parser_next_token_is (parser
, CPP_EQ
))
1206 c_parser_consume_token (parser
);
1207 /* The declaration of the variable is in effect while
1208 its initializer is parsed. */
1209 d
= start_decl (declarator
, specs
, true,
1210 chainon (postfix_attrs
, all_prefix_attrs
));
1212 d
= error_mark_node
;
1213 start_init (d
, asm_name
, global_bindings_p ());
1214 init
= c_parser_initializer (parser
);
1216 if (d
!= error_mark_node
)
1218 maybe_warn_string_init (TREE_TYPE (d
), init
);
1219 finish_decl (d
, init
.value
, asm_name
);
1224 tree d
= start_decl (declarator
, specs
, false,
1225 chainon (postfix_attrs
,
1228 finish_decl (d
, NULL_TREE
, asm_name
);
1230 if (c_parser_next_token_is (parser
, CPP_COMMA
))
1232 c_parser_consume_token (parser
);
1233 if (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
1234 all_prefix_attrs
= chainon (c_parser_attributes (parser
),
1237 all_prefix_attrs
= prefix_attrs
;
1240 else if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
1242 c_parser_consume_token (parser
);
1247 c_parser_error (parser
, "expected %<,%> or %<;%>");
1248 c_parser_skip_to_end_of_block_or_statement (parser
);
1254 c_parser_error (parser
, "expected %<=%>, %<,%>, %<;%>, "
1255 "%<asm%> or %<__attribute__%>");
1256 c_parser_skip_to_end_of_block_or_statement (parser
);
1259 /* Function definition (nested or otherwise). */
1263 pedwarn ("ISO C forbids nested functions");
1264 push_function_context ();
1266 if (!start_function (specs
, declarator
, all_prefix_attrs
))
1268 /* This can appear in many cases looking nothing like a
1269 function definition, so we don't give a more specific
1270 error suggesting there was one. */
1271 c_parser_error (parser
, "expected %<=%>, %<,%>, %<;%>, %<asm%> "
1272 "or %<__attribute__%>");
1274 pop_function_context ();
1277 /* Parse old-style parameter declarations. ??? Attributes are
1278 not allowed to start declaration specifiers here because of a
1279 syntax conflict between a function declaration with attribute
1280 suffix and a function definition with an attribute prefix on
1281 first old-style parameter declaration. Following the old
1282 parser, they are not accepted on subsequent old-style
1283 parameter declarations either. However, there is no
1284 ambiguity after the first declaration, nor indeed on the
1285 first as long as we don't allow postfix attributes after a
1286 declarator with a nonempty identifier list in a definition;
1287 and postfix attributes have never been accepted here in
1288 function definitions either. */
1289 while (c_parser_next_token_is_not (parser
, CPP_EOF
)
1290 && c_parser_next_token_is_not (parser
, CPP_OPEN_BRACE
))
1291 c_parser_declaration_or_fndef (parser
, false, false, true, false);
1292 DECL_SOURCE_LOCATION (current_function_decl
)
1293 = c_parser_peek_token (parser
)->location
;
1294 store_parm_decls ();
1295 fnbody
= c_parser_compound_statement (parser
);
1298 tree decl
= current_function_decl
;
1301 pop_function_context ();
1302 add_stmt (build_stmt (DECL_EXPR
, decl
));
1313 /* Parse an asm-definition (asm() outside a function body). This is a
1321 c_parser_asm_definition (c_parser
*parser
)
1323 tree asm_str
= c_parser_simple_asm_expr (parser
);
1324 /* ??? This only works sensibly in the presence of
1325 -fno-unit-at-a-time; file-scope asms really need to be passed to
1326 cgraph which needs to preserve the order of functions and
1329 assemble_asm (asm_str
);
1330 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
1333 /* Parse some declaration specifiers (possibly none) (C90 6.5, C99
1334 6.7), adding them to SPECS (which may already include some).
1335 Storage class specifiers are accepted iff SCSPEC_OK; type
1336 specifiers are accepted iff TYPESPEC_OK; attributes are accepted at
1337 the start iff START_ATTR_OK.
1339 declaration-specifiers:
1340 storage-class-specifier declaration-specifiers[opt]
1341 type-specifier declaration-specifiers[opt]
1342 type-qualifier declaration-specifiers[opt]
1343 function-specifier declaration-specifiers[opt]
1345 Function specifiers (inline) are from C99, and are currently
1346 handled as storage class specifiers, as is __thread.
1348 C90 6.5.1, C99 6.7.1:
1349 storage-class-specifier:
1360 C90 6.5.2, C99 6.7.2:
1373 [_Imaginary removed in C99 TC2]
1374 struct-or-union-specifier
1378 (_Bool and _Complex are new in C99.)
1380 C90 6.5.3, C99 6.7.3:
1387 (restrict is new in C99.)
1391 declaration-specifiers:
1392 attributes declaration-specifiers[opt]
1394 storage-class-specifier:
1403 class-name objc-protocol-refs[opt]
1404 typedef-name objc-protocol-refs
1409 c_parser_declspecs (c_parser
*parser
, struct c_declspecs
*specs
,
1410 bool scspec_ok
, bool typespec_ok
, bool start_attr_ok
)
1412 bool attrs_ok
= start_attr_ok
;
1413 bool seen_type
= specs
->type_seen_p
;
1414 while (c_parser_next_token_is (parser
, CPP_NAME
)
1415 || c_parser_next_token_is (parser
, CPP_KEYWORD
)
1416 || (c_dialect_objc () && c_parser_next_token_is (parser
, CPP_LESS
)))
1418 struct c_typespec t
;
1420 if (c_parser_next_token_is (parser
, CPP_NAME
))
1422 tree value
= c_parser_peek_token (parser
)->value
;
1423 c_id_kind kind
= c_parser_peek_token (parser
)->id_kind
;
1424 /* This finishes the specifiers unless a type name is OK, it
1425 is declared as a type name and a type name hasn't yet
1427 if (!typespec_ok
|| seen_type
1428 || (kind
!= C_ID_TYPENAME
&& kind
!= C_ID_CLASSNAME
))
1430 c_parser_consume_token (parser
);
1433 if (kind
== C_ID_TYPENAME
1434 && (!c_dialect_objc ()
1435 || c_parser_next_token_is_not (parser
, CPP_LESS
)))
1437 t
.kind
= ctsk_typedef
;
1438 /* For a typedef name, record the meaning, not the name.
1439 In case of 'foo foo, bar;'. */
1440 t
.spec
= lookup_name (value
);
1444 tree proto
= NULL_TREE
;
1445 gcc_assert (c_dialect_objc ());
1447 if (c_parser_next_token_is (parser
, CPP_LESS
))
1448 proto
= c_parser_objc_protocol_refs (parser
);
1449 t
.spec
= objc_get_protocol_qualified_type (value
, proto
);
1451 declspecs_add_type (specs
, t
);
1454 if (c_parser_next_token_is (parser
, CPP_LESS
))
1456 /* Make "<SomeProtocol>" equivalent to "id <SomeProtocol>" -
1457 nisse@lysator.liu.se. */
1459 gcc_assert (c_dialect_objc ());
1460 if (!typespec_ok
|| seen_type
)
1462 proto
= c_parser_objc_protocol_refs (parser
);
1464 t
.spec
= objc_get_protocol_qualified_type (NULL_TREE
, proto
);
1465 declspecs_add_type (specs
, t
);
1468 gcc_assert (c_parser_next_token_is (parser
, CPP_KEYWORD
));
1469 switch (c_parser_peek_token (parser
)->keyword
)
1481 /* TODO: Distinguish between function specifiers (inline)
1482 and storage class specifiers, either here or in
1483 declspecs_add_scspec. */
1484 declspecs_add_scspec (specs
, c_parser_peek_token (parser
)->value
);
1485 c_parser_consume_token (parser
);
1502 OBJC_NEED_RAW_IDENTIFIER (1);
1503 t
.kind
= ctsk_resword
;
1504 t
.spec
= c_parser_peek_token (parser
)->value
;
1505 declspecs_add_type (specs
, t
);
1506 c_parser_consume_token (parser
);
1513 t
= c_parser_enum_specifier (parser
);
1514 declspecs_add_type (specs
, t
);
1522 t
= c_parser_struct_or_union_specifier (parser
);
1523 declspecs_add_type (specs
, t
);
1526 /* ??? The old parser rejected typeof after other type
1527 specifiers, but is a syntax error the best way of
1529 if (!typespec_ok
|| seen_type
)
1533 t
= c_parser_typeof_specifier (parser
);
1534 declspecs_add_type (specs
, t
);
1540 declspecs_add_qual (specs
, c_parser_peek_token (parser
)->value
);
1541 c_parser_consume_token (parser
);
1546 attrs
= c_parser_attributes (parser
);
1547 declspecs_add_attrs (specs
, attrs
);
1556 /* Parse an enum specifier (C90 6.5.2.2, C99 6.7.2.2).
1559 enum attributes[opt] identifier[opt] { enumerator-list } attributes[opt]
1560 enum attributes[opt] identifier[opt] { enumerator-list , } attributes[opt]
1561 enum attributes[opt] identifier
1563 The form with trailing comma is new in C99. The forms with
1564 attributes are GNU extensions. In GNU C, we accept any expression
1565 without commas in the syntax (assignment expressions, not just
1566 conditional expressions); assignment expressions will be diagnosed
1571 enumerator-list , enumerator
1574 enumeration-constant
1575 enumeration-constant = constant-expression
1578 static struct c_typespec
1579 c_parser_enum_specifier (c_parser
*parser
)
1581 struct c_typespec ret
;
1583 tree ident
= NULL_TREE
;
1584 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_ENUM
));
1585 c_parser_consume_token (parser
);
1586 attrs
= c_parser_attributes (parser
);
1587 if (c_parser_next_token_is (parser
, CPP_NAME
))
1589 ident
= c_parser_peek_token (parser
)->value
;
1590 c_parser_consume_token (parser
);
1592 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
1594 /* Parse an enum definition. */
1595 tree type
= start_enum (ident
);
1597 /* We chain the enumerators in reverse order, then put them in
1598 forward order at the end. */
1599 tree values
= NULL_TREE
;
1600 c_parser_consume_token (parser
);
1607 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
1609 c_parser_error (parser
, "expected identifier");
1610 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
, NULL
);
1611 values
= error_mark_node
;
1614 enum_id
= c_parser_peek_token (parser
)->value
;
1615 c_parser_consume_token (parser
);
1616 if (c_parser_next_token_is (parser
, CPP_EQ
))
1618 c_parser_consume_token (parser
);
1619 enum_value
= c_parser_expr_no_commas (parser
, NULL
).value
;
1622 enum_value
= NULL_TREE
;
1623 enum_decl
= build_enumerator (enum_id
, enum_value
);
1624 TREE_CHAIN (enum_decl
) = values
;
1627 if (c_parser_next_token_is (parser
, CPP_COMMA
))
1630 c_parser_consume_token (parser
);
1632 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
1634 if (seen_comma
&& pedantic
&& !flag_isoc99
)
1635 pedwarn ("comma at end of enumerator list");
1636 c_parser_consume_token (parser
);
1641 c_parser_error (parser
, "expected %<,%> or %<}%>");
1642 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
, NULL
);
1643 values
= error_mark_node
;
1647 postfix_attrs
= c_parser_attributes (parser
);
1648 ret
.spec
= finish_enum (type
, nreverse (values
),
1649 chainon (attrs
, postfix_attrs
));
1650 ret
.kind
= ctsk_tagdef
;
1655 c_parser_error (parser
, "expected %<{%>");
1656 ret
.spec
= error_mark_node
;
1657 ret
.kind
= ctsk_tagref
;
1660 ret
= parser_xref_tag (ENUMERAL_TYPE
, ident
);
1661 /* In ISO C, enumerated types can be referred to only if already
1663 if (pedantic
&& !COMPLETE_TYPE_P (ret
.spec
))
1664 pedwarn ("ISO C forbids forward references to %<enum%> types");
1668 /* Parse a struct or union specifier (C90 6.5.2.1, C99 6.7.2.1).
1670 struct-or-union-specifier:
1671 struct-or-union attributes[opt] identifier[opt]
1672 { struct-contents } attributes[opt]
1673 struct-or-union attributes[opt] identifier
1676 struct-declaration-list
1678 struct-declaration-list:
1679 struct-declaration ;
1680 struct-declaration-list struct-declaration ;
1687 struct-declaration-list struct-declaration
1689 struct-declaration-list:
1690 struct-declaration-list ;
1693 (Note that in the syntax here, unlike that in ISO C, the semicolons
1694 are included here rather than in struct-declaration, in order to
1695 describe the syntax with extra semicolons and missing semicolon at
1700 struct-declaration-list:
1701 @defs ( class-name )
1703 (Note this does not include a trailing semicolon, but can be
1704 followed by further declarations, and gets a pedwarn-if-pedantic
1705 when followed by a semicolon.) */
1707 static struct c_typespec
1708 c_parser_struct_or_union_specifier (c_parser
*parser
)
1710 struct c_typespec ret
;
1712 tree ident
= NULL_TREE
;
1713 enum tree_code code
;
1714 switch (c_parser_peek_token (parser
)->keyword
)
1725 c_parser_consume_token (parser
);
1726 attrs
= c_parser_attributes (parser
);
1727 if (c_parser_next_token_is (parser
, CPP_NAME
))
1729 ident
= c_parser_peek_token (parser
)->value
;
1730 c_parser_consume_token (parser
);
1732 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
1734 /* Parse a struct or union definition. Start the scope of the
1735 tag before parsing components. */
1736 tree type
= start_struct (code
, ident
);
1738 /* We chain the components in reverse order, then put them in
1739 forward order at the end. Each struct-declaration may
1740 declare multiple components (comma-separated), so we must use
1741 chainon to join them, although when parsing each
1742 struct-declaration we can use TREE_CHAIN directly.
1744 The theory behind all this is that there will be more
1745 semicolon separated fields than comma separated fields, and
1746 so we'll be minimizing the number of node traversals required
1748 tree contents
= NULL_TREE
;
1749 c_parser_consume_token (parser
);
1750 /* Handle the Objective-C @defs construct,
1751 e.g. foo(sizeof(struct{ @defs(ClassName) }));. */
1752 if (c_parser_next_token_is_keyword (parser
, RID_AT_DEFS
))
1755 gcc_assert (c_dialect_objc ());
1756 c_parser_consume_token (parser
);
1757 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
1759 if (c_parser_next_token_is (parser
, CPP_NAME
)
1760 && c_parser_peek_token (parser
)->id_kind
== C_ID_CLASSNAME
)
1762 name
= c_parser_peek_token (parser
)->value
;
1763 c_parser_consume_token (parser
);
1767 c_parser_error (parser
, "expected class name");
1768 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
1771 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
1773 contents
= nreverse (objc_get_class_ivars (name
));
1776 /* Parse the struct-declarations and semicolons. Problems with
1777 semicolons are diagnosed here; empty structures are diagnosed
1782 /* Parse any stray semicolon. */
1783 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
1786 pedwarn ("extra semicolon in struct or union specified");
1787 c_parser_consume_token (parser
);
1790 /* Stop if at the end of the struct or union contents. */
1791 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
1793 c_parser_consume_token (parser
);
1796 /* Parse some comma-separated declarations, but not the
1797 trailing semicolon if any. */
1798 decls
= c_parser_struct_declaration (parser
);
1799 contents
= chainon (decls
, contents
);
1800 /* If no semicolon follows, either we have a parse error or
1801 are at the end of the struct or union and should
1803 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
1804 c_parser_consume_token (parser
);
1807 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
1808 pedwarn ("no semicolon at end of struct or union");
1811 c_parser_error (parser
, "expected %<;%>");
1812 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
, NULL
);
1817 postfix_attrs
= c_parser_attributes (parser
);
1818 ret
.spec
= finish_struct (type
, nreverse (contents
),
1819 chainon (attrs
, postfix_attrs
));
1820 ret
.kind
= ctsk_tagdef
;
1825 c_parser_error (parser
, "expected %<{%>");
1826 ret
.spec
= error_mark_node
;
1827 ret
.kind
= ctsk_tagref
;
1830 ret
= parser_xref_tag (code
, ident
);
1834 /* Parse a struct-declaration (C90 6.5.2.1, C99 6.7.2.1), *without*
1835 the trailing semicolon.
1838 specifier-qualifier-list struct-declarator-list
1840 specifier-qualifier-list:
1841 type-specifier specifier-qualifier-list[opt]
1842 type-qualifier specifier-qualifier-list[opt]
1843 attributes specifier-qualifier-list[opt]
1845 struct-declarator-list:
1847 struct-declarator-list , attributes[opt] struct-declarator
1850 declarator attributes[opt]
1851 declarator[opt] : constant-expression attributes[opt]
1856 __extension__ struct-declaration
1857 specifier-qualifier-list
1859 Unlike the ISO C syntax, semicolons are handled elsewhere. The use
1860 of attributes where shown is a GNU extension. In GNU C, we accept
1861 any expression without commas in the syntax (assignment
1862 expressions, not just conditional expressions); assignment
1863 expressions will be diagnosed as non-constant. */
1866 c_parser_struct_declaration (c_parser
*parser
)
1868 struct c_declspecs
*specs
;
1870 tree all_prefix_attrs
;
1872 if (c_parser_next_token_is_keyword (parser
, RID_EXTENSION
))
1876 ext
= disable_extension_diagnostics ();
1877 c_parser_consume_token (parser
);
1878 decl
= c_parser_struct_declaration (parser
);
1879 restore_extension_diagnostics (ext
);
1882 specs
= build_null_declspecs ();
1883 c_parser_declspecs (parser
, specs
, false, true, true);
1886 if (!specs
->declspecs_seen_p
)
1888 c_parser_error (parser
, "expected specifier-qualifier-list");
1891 finish_declspecs (specs
);
1892 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
1895 if (!specs
->type_seen_p
)
1898 pedwarn ("ISO C forbids member declarations with no members");
1899 shadow_tag_warned (specs
, pedantic
);
1904 /* Support for unnamed structs or unions as members of
1905 structs or unions (which is [a] useful and [b] supports
1907 ret
= grokfield (build_id_declarator (NULL_TREE
), specs
, NULL_TREE
);
1911 pending_xref_error ();
1912 prefix_attrs
= specs
->attrs
;
1913 all_prefix_attrs
= prefix_attrs
;
1914 specs
->attrs
= NULL_TREE
;
1918 /* Declaring one or more declarators or un-named bit-fields. */
1919 struct c_declarator
*declarator
;
1921 if (c_parser_next_token_is (parser
, CPP_COLON
))
1922 declarator
= build_id_declarator (NULL_TREE
);
1924 declarator
= c_parser_declarator (parser
, specs
->type_seen_p
,
1925 C_DTR_NORMAL
, &dummy
);
1926 if (declarator
== NULL
)
1928 c_parser_skip_to_end_of_block_or_statement (parser
);
1931 if (c_parser_next_token_is (parser
, CPP_COLON
)
1932 || c_parser_next_token_is (parser
, CPP_COMMA
)
1933 || c_parser_next_token_is (parser
, CPP_SEMICOLON
)
1934 || c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
)
1935 || c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
1937 tree postfix_attrs
= NULL_TREE
;
1938 tree width
= NULL_TREE
;
1940 if (c_parser_next_token_is (parser
, CPP_COLON
))
1942 c_parser_consume_token (parser
);
1943 width
= c_parser_expr_no_commas (parser
, NULL
).value
;
1945 if (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
1946 postfix_attrs
= c_parser_attributes (parser
);
1947 d
= grokfield (declarator
, specs
, width
);
1948 decl_attributes (&d
, chainon (postfix_attrs
,
1949 all_prefix_attrs
), 0);
1950 TREE_CHAIN (d
) = decls
;
1952 if (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
1953 all_prefix_attrs
= chainon (c_parser_attributes (parser
),
1956 all_prefix_attrs
= prefix_attrs
;
1957 if (c_parser_next_token_is (parser
, CPP_COMMA
))
1958 c_parser_consume_token (parser
);
1959 else if (c_parser_next_token_is (parser
, CPP_SEMICOLON
)
1960 || c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
1962 /* Semicolon consumed in caller. */
1967 c_parser_error (parser
, "expected %<,%>, %<;%> or %<}%>");
1973 c_parser_error (parser
,
1974 "expected %<:%>, %<,%>, %<;%>, %<}%> or "
1975 "%<__attribute__%>");
1982 /* Parse a typeof specifier (a GNU extension).
1985 typeof ( expression )
1986 typeof ( type-name )
1989 static struct c_typespec
1990 c_parser_typeof_specifier (c_parser
*parser
)
1992 struct c_typespec ret
;
1993 ret
.kind
= ctsk_typeof
;
1994 ret
.spec
= error_mark_node
;
1995 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_TYPEOF
));
1996 c_parser_consume_token (parser
);
1999 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
2005 if (c_parser_next_token_starts_typename (parser
))
2007 struct c_type_name
*type
= c_parser_type_name (parser
);
2012 ret
.spec
= groktypename (type
);
2013 pop_maybe_used (variably_modified_type_p (ret
.spec
, NULL_TREE
));
2018 struct c_expr expr
= c_parser_expression (parser
);
2021 if (TREE_CODE (expr
.value
) == COMPONENT_REF
2022 && DECL_C_BIT_FIELD (TREE_OPERAND (expr
.value
, 1)))
2023 error ("%<typeof%> applied to a bit-field");
2024 ret
.spec
= TREE_TYPE (expr
.value
);
2025 pop_maybe_used (variably_modified_type_p (ret
.spec
, NULL_TREE
));
2027 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
2031 /* Parse a declarator, possibly an abstract declarator (C90 6.5.4,
2032 6.5.5, C99 6.7.5, 6.7.6). If TYPE_SEEN_P then a typedef name may
2033 be redeclared; otherwise it may not. KIND indicates which kind of
2034 declarator is wanted. Returns a valid declarator except in the
2035 case of a syntax error in which case NULL is returned. *SEEN_ID is
2036 set to true if an identifier being declared is seen; this is used
2037 to diagnose bad forms of abstract array declarators and to
2038 determine whether an identifier list is syntactically permitted.
2041 pointer[opt] direct-declarator
2045 ( attributes[opt] declarator )
2046 direct-declarator array-declarator
2047 direct-declarator ( parameter-type-list )
2048 direct-declarator ( identifier-list[opt] )
2051 * type-qualifier-list[opt]
2052 * type-qualifier-list[opt] pointer
2054 type-qualifier-list:
2057 type-qualifier-list type-qualifier
2058 type-qualifier-list attributes
2060 parameter-type-list:
2062 parameter-list , ...
2065 parameter-declaration
2066 parameter-list , parameter-declaration
2068 parameter-declaration:
2069 declaration-specifiers declarator attributes[opt]
2070 declaration-specifiers abstract-declarator[opt] attributes[opt]
2074 identifier-list , identifier
2076 abstract-declarator:
2078 pointer[opt] direct-abstract-declarator
2080 direct-abstract-declarator:
2081 ( attributes[opt] abstract-declarator )
2082 direct-abstract-declarator[opt] array-declarator
2083 direct-abstract-declarator[opt] ( parameter-type-list[opt] )
2088 direct-declarator ( parameter-forward-declarations
2089 parameter-type-list[opt] )
2091 direct-abstract-declarator:
2092 direct-abstract-declarator[opt] ( parameter-forward-declarations
2093 parameter-type-list[opt] )
2095 parameter-forward-declarations:
2097 parameter-forward-declarations parameter-list ;
2099 The uses of attributes shown above are GNU extensions.
2101 Some forms of array declarator are not included in C99 in the
2102 syntax for abstract declarators; these are disallowed elsewhere.
2103 This may be a defect (DR#289).
2105 This function also accepts an omitted abstract declarator as being
2106 an abstract declarator, although not part of the formal syntax. */
2108 static struct c_declarator
*
2109 c_parser_declarator (c_parser
*parser
, bool type_seen_p
, c_dtr_syn kind
,
2112 /* Parse any initial pointer part. */
2113 if (c_parser_next_token_is (parser
, CPP_MULT
))
2115 struct c_declspecs
*quals_attrs
= build_null_declspecs ();
2116 struct c_declarator
*inner
;
2117 c_parser_consume_token (parser
);
2118 c_parser_declspecs (parser
, quals_attrs
, false, false, true);
2119 inner
= c_parser_declarator (parser
, type_seen_p
, kind
, seen_id
);
2123 return make_pointer_declarator (quals_attrs
, inner
);
2125 /* Now we have a direct declarator, direct abstract declarator or
2126 nothing (which counts as a direct abstract declarator here). */
2127 return c_parser_direct_declarator (parser
, type_seen_p
, kind
, seen_id
);
2130 /* Parse a direct declarator or direct abstract declarator; arguments
2131 as c_parser_declarator. */
2133 static struct c_declarator
*
2134 c_parser_direct_declarator (c_parser
*parser
, bool type_seen_p
, c_dtr_syn kind
,
2137 /* The direct declarator must start with an identifier (possibly
2138 omitted) or a parenthesized declarator (possibly abstract). In
2139 an ordinary declarator, initial parentheses must start a
2140 parenthesized declarator. In an abstract declarator or parameter
2141 declarator, they could start a parenthesized declarator or a
2142 parameter list. To tell which, the open parenthesis and any
2143 following attributes must be read. If a declaration specifier
2144 follows, then it is a parameter list; if the specifier is a
2145 typedef name, there might be an ambiguity about redeclaring it,
2146 which is resolved in the direction of treating it as a typedef
2147 name. If a close parenthesis follows, it is also an empty
2148 parameter list, as the syntax does not permit empty abstract
2149 declarators. Otherwise, it is a parenthesized declarator (in
2150 which case the analysis may be repeated inside it, recursively).
2152 ??? There is an ambiguity in a parameter declaration "int
2153 (__attribute__((foo)) x)", where x is not a typedef name: it
2154 could be an abstract declarator for a function, or declare x with
2155 parentheses. The proper resolution of this ambiguity needs
2156 documenting. At present we follow an accident of the old
2157 parser's implementation, whereby the first parameter must have
2158 some declaration specifiers other than just attributes. Thus as
2159 a parameter declaration it is treated as a parenthesized
2160 parameter named x, and as an abstract declarator it is
2163 ??? Also following the old parser, attributes inside an empty
2164 parameter list are ignored, making it a list not yielding a
2165 prototype, rather than giving an error or making it have one
2166 parameter with implicit type int.
2168 ??? Also following the old parser, typedef names may be
2169 redeclared in declarators, but not Objective-C class names. */
2171 if (kind
!= C_DTR_ABSTRACT
2172 && c_parser_next_token_is (parser
, CPP_NAME
)
2174 && c_parser_peek_token (parser
)->id_kind
== C_ID_TYPENAME
)
2175 || c_parser_peek_token (parser
)->id_kind
== C_ID_ID
))
2177 struct c_declarator
*inner
2178 = build_id_declarator (c_parser_peek_token (parser
)->value
);
2180 inner
->id_loc
= c_parser_peek_token (parser
)->location
;
2181 c_parser_consume_token (parser
);
2182 return c_parser_direct_declarator_inner (parser
, *seen_id
, inner
);
2185 if (kind
!= C_DTR_NORMAL
2186 && c_parser_next_token_is (parser
, CPP_OPEN_SQUARE
))
2188 struct c_declarator
*inner
= build_id_declarator (NULL_TREE
);
2189 return c_parser_direct_declarator_inner (parser
, *seen_id
, inner
);
2192 /* Either we are at the end of an abstract declarator, or we have
2195 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
2198 struct c_declarator
*inner
;
2199 c_parser_consume_token (parser
);
2200 attrs
= c_parser_attributes (parser
);
2201 if (kind
!= C_DTR_NORMAL
2202 && (c_parser_next_token_starts_declspecs (parser
)
2203 || c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
)))
2205 struct c_arg_info
*args
2206 = c_parser_parms_declarator (parser
, kind
== C_DTR_NORMAL
,
2213 = build_function_declarator (args
,
2214 build_id_declarator (NULL_TREE
));
2215 return c_parser_direct_declarator_inner (parser
, *seen_id
,
2219 /* A parenthesized declarator. */
2220 inner
= c_parser_declarator (parser
, type_seen_p
, kind
, seen_id
);
2221 if (inner
!= NULL
&& attrs
!= NULL
)
2222 inner
= build_attrs_declarator (attrs
, inner
);
2223 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2225 c_parser_consume_token (parser
);
2229 return c_parser_direct_declarator_inner (parser
, *seen_id
, inner
);
2233 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
2240 if (kind
== C_DTR_NORMAL
)
2242 c_parser_error (parser
, "expected identifier or %<(%>");
2246 return build_id_declarator (NULL_TREE
);
2250 /* Parse part of a direct declarator or direct abstract declarator,
2251 given that some (in INNER) has already been parsed; ID_PRESENT is
2252 true if an identifier is present, false for an abstract
2255 static struct c_declarator
*
2256 c_parser_direct_declarator_inner (c_parser
*parser
, bool id_present
,
2257 struct c_declarator
*inner
)
2259 /* Parse a sequence of array declarators and parameter lists. */
2260 if (c_parser_next_token_is (parser
, CPP_OPEN_SQUARE
))
2262 struct c_declarator
*declarator
;
2263 struct c_declspecs
*quals_attrs
= build_null_declspecs ();
2267 c_parser_consume_token (parser
);
2268 c_parser_declspecs (parser
, quals_attrs
, false, false, true);
2269 static_seen
= c_parser_next_token_is_keyword (parser
, RID_STATIC
);
2271 c_parser_consume_token (parser
);
2272 if (static_seen
&& !quals_attrs
->declspecs_seen_p
)
2273 c_parser_declspecs (parser
, quals_attrs
, false, false, true);
2274 if (!quals_attrs
->declspecs_seen_p
)
2276 /* If "static" is present, there must be an array dimension.
2277 Otherwise, there may be a dimension, "*", or no
2282 dimen
= c_parser_expr_no_commas (parser
, NULL
).value
;
2286 if (c_parser_next_token_is (parser
, CPP_CLOSE_SQUARE
))
2291 else if (c_parser_next_token_is (parser
, CPP_MULT
))
2293 if (c_parser_peek_2nd_token (parser
)->type
== CPP_CLOSE_SQUARE
)
2297 c_parser_consume_token (parser
);
2302 dimen
= c_parser_expr_no_commas (parser
, NULL
).value
;
2308 dimen
= c_parser_expr_no_commas (parser
, NULL
).value
;
2311 if (c_parser_next_token_is (parser
, CPP_CLOSE_SQUARE
))
2312 c_parser_consume_token (parser
);
2315 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
2319 declarator
= build_array_declarator (dimen
, quals_attrs
, static_seen
,
2321 inner
= set_array_declarator_inner (declarator
, inner
, !id_present
);
2322 return c_parser_direct_declarator_inner (parser
, id_present
, inner
);
2324 else if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
2327 struct c_arg_info
*args
;
2328 c_parser_consume_token (parser
);
2329 attrs
= c_parser_attributes (parser
);
2330 args
= c_parser_parms_declarator (parser
, id_present
, attrs
);
2335 inner
= build_function_declarator (args
, inner
);
2336 return c_parser_direct_declarator_inner (parser
, id_present
, inner
);
2342 /* Parse a parameter list or identifier list, including the closing
2343 parenthesis but not the opening one. ATTRS are the attributes at
2344 the start of the list. ID_LIST_OK is true if an identifier list is
2345 acceptable; such a list must not have attributes at the start. */
2347 static struct c_arg_info
*
2348 c_parser_parms_declarator (c_parser
*parser
, bool id_list_ok
, tree attrs
)
2351 declare_parm_level ();
2352 /* If the list starts with an identifier, it is an identifier list.
2353 Otherwise, it is either a prototype list or an empty list. */
2356 && c_parser_next_token_is (parser
, CPP_NAME
)
2357 && c_parser_peek_token (parser
)->id_kind
== C_ID_ID
)
2359 tree list
= NULL_TREE
, *nextp
= &list
;
2360 while (c_parser_next_token_is (parser
, CPP_NAME
)
2361 && c_parser_peek_token (parser
)->id_kind
== C_ID_ID
)
2363 *nextp
= build_tree_list (NULL_TREE
,
2364 c_parser_peek_token (parser
)->value
);
2365 nextp
= & TREE_CHAIN (*nextp
);
2366 c_parser_consume_token (parser
);
2367 if (c_parser_next_token_is_not (parser
, CPP_COMMA
))
2369 c_parser_consume_token (parser
);
2370 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2372 c_parser_error (parser
, "expected identifier");
2376 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2378 struct c_arg_info
*ret
= XOBNEW (&parser_obstack
, struct c_arg_info
);
2383 c_parser_consume_token (parser
);
2389 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
2397 struct c_arg_info
*ret
= c_parser_parms_list_declarator (parser
, attrs
);
2403 /* Parse a parameter list (possibly empty), including the closing
2404 parenthesis but not the opening one. ATTRS are the attributes at
2405 the start of the list. */
2407 static struct c_arg_info
*
2408 c_parser_parms_list_declarator (c_parser
*parser
, tree attrs
)
2410 bool good_parm
= false;
2411 /* ??? Following the old parser, forward parameter declarations may
2412 use abstract declarators, and if no real parameter declarations
2413 follow the forward declarations then this is not diagnosed. Also
2414 note as above that attributes are ignored as the only contents of
2415 the parentheses, or as the only contents after forward
2417 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2419 struct c_arg_info
*ret
= XOBNEW (&parser_obstack
, struct c_arg_info
);
2424 c_parser_consume_token (parser
);
2427 if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
))
2429 struct c_arg_info
*ret
= XOBNEW (&parser_obstack
, struct c_arg_info
);
2433 /* Suppress -Wold-style-definition for this case. */
2434 ret
->types
= error_mark_node
;
2435 error ("ISO C requires a named argument before %<...%>");
2436 c_parser_consume_token (parser
);
2437 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2439 c_parser_consume_token (parser
);
2444 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
2449 /* Nonempty list of parameters, either terminated with semicolon
2450 (forward declarations; recurse) or with close parenthesis (normal
2451 function) or with ", ... )" (variadic function). */
2454 /* Parse a parameter. */
2455 struct c_parm
*parm
= c_parser_parameter_declaration (parser
, attrs
);
2460 push_parm_decl (parm
);
2462 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
2465 c_parser_consume_token (parser
);
2466 new_attrs
= c_parser_attributes (parser
);
2467 return c_parser_parms_list_declarator (parser
, new_attrs
);
2469 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2471 c_parser_consume_token (parser
);
2473 return get_parm_info (false);
2476 struct c_arg_info
*ret
2477 = XOBNEW (&parser_obstack
, struct c_arg_info
);
2485 if (!c_parser_require (parser
, CPP_COMMA
,
2486 "expected %<;%>, %<,%> or %<)%>"))
2488 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
2491 if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
))
2493 c_parser_consume_token (parser
);
2494 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2496 c_parser_consume_token (parser
);
2498 return get_parm_info (true);
2501 struct c_arg_info
*ret
2502 = XOBNEW (&parser_obstack
, struct c_arg_info
);
2512 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
2520 /* Parse a parameter declaration. ATTRS are the attributes at the
2521 start of the declaration if it is the first parameter. */
2523 static struct c_parm
*
2524 c_parser_parameter_declaration (c_parser
*parser
, tree attrs
)
2526 struct c_declspecs
*specs
;
2527 struct c_declarator
*declarator
;
2529 tree postfix_attrs
= NULL_TREE
;
2531 if (!c_parser_next_token_starts_declspecs (parser
))
2533 /* ??? In some Objective-C cases '...' isn't applicable so there
2534 should be a different message. */
2535 c_parser_error (parser
,
2536 "expected declaration specifiers or %<...%>");
2537 c_parser_skip_to_end_of_parameter (parser
);
2540 specs
= build_null_declspecs ();
2543 declspecs_add_attrs (specs
, attrs
);
2546 c_parser_declspecs (parser
, specs
, true, true, true);
2547 finish_declspecs (specs
);
2548 pending_xref_error ();
2549 prefix_attrs
= specs
->attrs
;
2550 specs
->attrs
= NULL_TREE
;
2551 declarator
= c_parser_declarator (parser
, specs
->type_seen_p
,
2552 C_DTR_PARM
, &dummy
);
2553 if (declarator
== NULL
)
2555 c_parser_skip_until_found (parser
, CPP_COMMA
, NULL
);
2558 if (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
2559 postfix_attrs
= c_parser_attributes (parser
);
2560 return build_c_parm (specs
, chainon (postfix_attrs
, prefix_attrs
),
2564 /* Parse a string literal in an asm expression. It should not be
2565 translated, and wide string literals are an error although
2566 permitted by the syntax. This is a GNU extension.
2571 ??? At present, following the old parser, the caller needs to have
2572 set c_lex_string_translate to 0. It would be better to follow the
2573 C++ parser rather than using the c_lex_string_translate kludge. */
2576 c_parser_asm_string_literal (c_parser
*parser
)
2579 if (c_parser_next_token_is (parser
, CPP_STRING
))
2581 str
= c_parser_peek_token (parser
)->value
;
2582 c_parser_consume_token (parser
);
2584 else if (c_parser_next_token_is (parser
, CPP_WSTRING
))
2586 error ("wide string literal in %<asm%>");
2587 str
= build_string (1, "");
2588 c_parser_consume_token (parser
);
2592 c_parser_error (parser
, "expected string literal");
2598 /* Parse a simple asm expression. This is used in restricted
2599 contexts, where a full expression with inputs and outputs does not
2600 make sense. This is a GNU extension.
2603 asm ( asm-string-literal )
2607 c_parser_simple_asm_expr (c_parser
*parser
)
2610 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_ASM
));
2611 /* ??? Follow the C++ parser rather than using the
2612 c_lex_string_translate kludge. */
2613 c_lex_string_translate
= 0;
2614 c_parser_consume_token (parser
);
2615 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
2617 c_lex_string_translate
= 1;
2620 str
= c_parser_asm_string_literal (parser
);
2621 c_lex_string_translate
= 1;
2622 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
2624 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
2630 /* Parse (possibly empty) attributes. This is a GNU extension.
2634 attributes attribute
2637 __attribute__ ( ( attribute-list ) )
2641 attribute_list , attrib
2646 any-word ( identifier )
2647 any-word ( identifier , nonempty-expr-list )
2648 any-word ( expr-list )
2650 where the "identifier" must not be declared as a type, and
2651 "any-word" may be any identifier (including one declared as a
2652 type), a reserved word storage class specifier, type specifier or
2653 type qualifier. ??? This still leaves out most reserved keywords
2654 (following the old parser), shouldn't we include them, and why not
2655 allow identifiers declared as types to start the arguments? */
2658 c_parser_attributes (c_parser
*parser
)
2660 tree attrs
= NULL_TREE
;
2661 while (c_parser_next_token_is_keyword (parser
, RID_ATTRIBUTE
))
2663 /* ??? Follow the C++ parser rather than using the
2664 c_lex_string_translate kludge. */
2665 c_lex_string_translate
= 0;
2666 c_parser_consume_token (parser
);
2667 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
2669 c_lex_string_translate
= 1;
2672 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
2674 c_lex_string_translate
= 1;
2675 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
2678 /* Parse the attribute list. */
2679 while (c_parser_next_token_is (parser
, CPP_COMMA
)
2680 || c_parser_next_token_is (parser
, CPP_NAME
)
2681 || c_parser_next_token_is (parser
, CPP_KEYWORD
))
2683 tree attr
, attr_name
, attr_args
;
2684 if (c_parser_next_token_is (parser
, CPP_COMMA
))
2686 c_parser_consume_token (parser
);
2689 if (c_parser_next_token_is (parser
, CPP_KEYWORD
))
2691 /* ??? See comment above about what keywords are
2694 switch (c_parser_peek_token (parser
)->keyword
)
2726 attr_name
= c_parser_peek_token (parser
)->value
;
2727 c_parser_consume_token (parser
);
2728 if (c_parser_next_token_is_not (parser
, CPP_OPEN_PAREN
))
2730 attr
= build_tree_list (attr_name
, NULL_TREE
);
2731 attrs
= chainon (attrs
, attr
);
2734 c_parser_consume_token (parser
);
2735 /* Parse the attribute contents. If they start with an
2736 identifier which is followed by a comma or close
2737 parenthesis, then the arguments start with that
2738 identifier; otherwise they are an expression list. */
2739 if (c_parser_next_token_is (parser
, CPP_NAME
)
2740 && c_parser_peek_token (parser
)->id_kind
== C_ID_ID
2741 && ((c_parser_peek_2nd_token (parser
)->type
== CPP_COMMA
)
2742 || (c_parser_peek_2nd_token (parser
)->type
2743 == CPP_CLOSE_PAREN
)))
2745 tree arg1
= c_parser_peek_token (parser
)->value
;
2746 c_parser_consume_token (parser
);
2747 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2748 attr_args
= build_tree_list (NULL_TREE
, arg1
);
2751 c_parser_consume_token (parser
);
2752 attr_args
= tree_cons (NULL_TREE
, arg1
,
2753 c_parser_expr_list (parser
, false));
2758 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2759 attr_args
= NULL_TREE
;
2761 attr_args
= c_parser_expr_list (parser
, false);
2763 attr
= build_tree_list (attr_name
, attr_args
);
2764 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2765 c_parser_consume_token (parser
);
2768 c_lex_string_translate
= 1;
2769 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
2773 attrs
= chainon (attrs
, attr
);
2775 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2776 c_parser_consume_token (parser
);
2779 c_lex_string_translate
= 1;
2780 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
2784 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
2785 c_parser_consume_token (parser
);
2788 c_lex_string_translate
= 1;
2789 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
2793 c_lex_string_translate
= 1;
2798 /* Parse a type name (C90 6.5.5, C99 6.7.6).
2801 specifier-qualifier-list abstract-declarator[opt]
2804 static struct c_type_name
*
2805 c_parser_type_name (c_parser
*parser
)
2807 struct c_declspecs
*specs
= build_null_declspecs ();
2808 struct c_declarator
*declarator
;
2809 struct c_type_name
*ret
;
2811 c_parser_declspecs (parser
, specs
, false, true, true);
2812 if (!specs
->declspecs_seen_p
)
2814 c_parser_error (parser
, "expected specifier-qualifier-list");
2817 pending_xref_error ();
2818 finish_declspecs (specs
);
2819 declarator
= c_parser_declarator (parser
, specs
->type_seen_p
,
2820 C_DTR_ABSTRACT
, &dummy
);
2821 if (declarator
== NULL
)
2823 ret
= XOBNEW (&parser_obstack
, struct c_type_name
);
2825 ret
->declarator
= declarator
;
2829 /* Parse an initializer (C90 6.5.7, C99 6.7.8).
2832 assignment-expression
2833 { initializer-list }
2834 { initializer-list , }
2837 designation[opt] initializer
2838 initializer-list , designation[opt] initializer
2845 designator-list designator
2852 [ constant-expression ]
2864 [ constant-expression ... constant-expression ]
2866 Any expression without commas is accepted in the syntax for the
2867 constant-expressions, with non-constant expressions rejected later.
2869 This function is only used for top-level initializers; for nested
2870 ones, see c_parser_initval. */
2872 static struct c_expr
2873 c_parser_initializer (c_parser
*parser
)
2875 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
2876 return c_parser_braced_init (parser
, NULL_TREE
, false);
2880 ret
= c_parser_expr_no_commas (parser
, NULL
);
2881 if (TREE_CODE (ret
.value
) != STRING_CST
2882 && TREE_CODE (ret
.value
) != COMPOUND_LITERAL_EXPR
)
2883 ret
= default_function_array_conversion (ret
);
2888 /* Parse a braced initializer list. TYPE is the type specified for a
2889 compound literal, and NULL_TREE for other initializers and for
2890 nested braced lists. NESTED_P is true for nested braced lists,
2891 false for the list of a compound literal or the list that is the
2892 top-level initializer in a declaration. */
2894 static struct c_expr
2895 c_parser_braced_init (c_parser
*parser
, tree type
, bool nested_p
)
2897 gcc_assert (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
));
2898 c_parser_consume_token (parser
);
2900 push_init_level (0);
2902 really_start_incremental_init (type
);
2903 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
2906 pedwarn ("ISO C forbids empty initializer braces");
2910 /* Parse a non-empty initializer list, possibly with a trailing
2914 c_parser_initelt (parser
);
2917 if (c_parser_next_token_is (parser
, CPP_COMMA
))
2918 c_parser_consume_token (parser
);
2921 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
2925 if (c_parser_next_token_is_not (parser
, CPP_CLOSE_BRACE
))
2928 ret
.value
= error_mark_node
;
2929 ret
.original_code
= ERROR_MARK
;
2930 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
, "expected %<}%>");
2933 c_parser_consume_token (parser
);
2934 return pop_init_level (0);
2937 /* Parse a nested initializer, including designators. */
2940 c_parser_initelt (c_parser
*parser
)
2942 /* Parse any designator or designator list. A single array
2943 designator may have the subsequent "=" omitted in GNU C, but a
2944 longer list or a structure member designator may not. */
2945 if (c_parser_next_token_is (parser
, CPP_NAME
)
2946 && c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
)
2948 /* Old-style structure member designator. */
2949 set_init_label (c_parser_peek_token (parser
)->value
);
2951 pedwarn ("obsolete use of designated initializer with %<:%>");
2952 c_parser_consume_token (parser
);
2953 c_parser_consume_token (parser
);
2957 /* des_seen is 0 if there have been no designators, 1 if there
2958 has been a single array designator and 2 otherwise. */
2960 while (c_parser_next_token_is (parser
, CPP_OPEN_SQUARE
)
2961 || c_parser_next_token_is (parser
, CPP_DOT
))
2963 int des_prev
= des_seen
;
2966 if (c_parser_next_token_is (parser
, CPP_DOT
))
2969 c_parser_consume_token (parser
);
2970 if (c_parser_next_token_is (parser
, CPP_NAME
))
2972 set_init_label (c_parser_peek_token (parser
)->value
);
2973 c_parser_consume_token (parser
);
2978 init
.value
= error_mark_node
;
2979 init
.original_code
= ERROR_MARK
;
2980 c_parser_error (parser
, "expected identifier");
2981 c_parser_skip_until_found (parser
, CPP_COMMA
, NULL
);
2982 process_init_element (init
);
2989 /* ??? Following the old parser, [ objc-receiver
2990 objc-message-args ] is accepted as an initializer,
2991 being distinguished from a designator by what follows
2992 the first assignment expression inside the square
2993 brackets, but after a first array designator a
2994 subsequent square bracket is for Objective-C taken to
2995 start an expression, using the obsolete form of
2996 designated initializer without '=', rather than
2997 possibly being a second level of designation: in LALR
2998 terms, the '[' is shifted rather than reducing
2999 designator to designator-list. */
3000 if (des_prev
== 1 && c_dialect_objc ())
3002 des_seen
= des_prev
;
3005 if (des_prev
== 0 && c_dialect_objc ())
3007 /* This might be an array designator or an
3008 Objective-C message expression. If the former,
3009 continue parsing here; if the latter, parse the
3010 remainder of the initializer given the starting
3011 primary-expression. ??? It might make sense to
3012 distinguish when des_prev == 1 as well; see
3013 previous comment. */
3015 struct c_expr mexpr
;
3016 c_parser_consume_token (parser
);
3017 if (c_parser_peek_token (parser
)->type
== CPP_NAME
3018 && ((c_parser_peek_token (parser
)->id_kind
3020 || (c_parser_peek_token (parser
)->id_kind
3021 == C_ID_CLASSNAME
)))
3023 /* Type name receiver. */
3024 tree id
= c_parser_peek_token (parser
)->value
;
3025 c_parser_consume_token (parser
);
3026 rec
= objc_get_class_reference (id
);
3027 goto parse_message_args
;
3029 first
= c_parser_expr_no_commas (parser
, NULL
).value
;
3030 if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
)
3031 || c_parser_next_token_is (parser
, CPP_CLOSE_SQUARE
))
3032 goto array_desig_after_first
;
3033 /* Expression receiver. So far only one part
3034 without commas has been parsed; there might be
3035 more of the expression. */
3037 while (c_parser_next_token_is (parser
, CPP_COMMA
))
3040 c_parser_consume_token (parser
);
3041 next
= c_parser_expr_no_commas (parser
, NULL
);
3042 next
= default_function_array_conversion (next
);
3043 rec
= build_compound_expr (rec
, next
.value
);
3046 /* Now parse the objc-message-args. */
3047 args
= c_parser_objc_message_args (parser
);
3048 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
3051 = objc_build_message_expr (build_tree_list (rec
, args
));
3052 mexpr
.original_code
= ERROR_MARK
;
3053 /* Now parse and process the remainder of the
3054 initializer, starting with this message
3055 expression as a primary-expression. */
3056 c_parser_initval (parser
, &mexpr
);
3059 c_parser_consume_token (parser
);
3060 first
= c_parser_expr_no_commas (parser
, NULL
).value
;
3061 array_desig_after_first
:
3062 if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
))
3064 c_parser_consume_token (parser
);
3065 second
= c_parser_expr_no_commas (parser
, NULL
).value
;
3069 if (c_parser_next_token_is (parser
, CPP_CLOSE_SQUARE
))
3071 c_parser_consume_token (parser
);
3072 set_init_index (first
, second
);
3073 if (pedantic
&& second
)
3074 pedwarn ("ISO C forbids specifying range of "
3075 "elements to initialize");
3078 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
3084 if (c_parser_next_token_is (parser
, CPP_EQ
))
3086 if (pedantic
&& !flag_isoc99
)
3087 pedwarn ("ISO C90 forbids specifying subobject to initialize");
3088 c_parser_consume_token (parser
);
3095 pedwarn ("obsolete use of designated initializer "
3101 init
.value
= error_mark_node
;
3102 init
.original_code
= ERROR_MARK
;
3103 c_parser_error (parser
, "expected %<=%>");
3104 c_parser_skip_until_found (parser
, CPP_COMMA
, NULL
);
3105 process_init_element (init
);
3111 c_parser_initval (parser
, NULL
);
3114 /* Parse a nested initializer; as c_parser_initializer but parses
3115 initializers within braced lists, after any designators have been
3116 applied. If AFTER is not NULL then it is an Objective-C message
3117 expression which is the primary-expression starting the
3121 c_parser_initval (c_parser
*parser
, struct c_expr
*after
)
3124 gcc_assert (!after
|| c_dialect_objc ());
3125 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
) && !after
)
3126 init
= c_parser_braced_init (parser
, NULL_TREE
, true);
3129 init
= c_parser_expr_no_commas (parser
, after
);
3130 if (init
.value
!= NULL_TREE
3131 && TREE_CODE (init
.value
) != STRING_CST
3132 && TREE_CODE (init
.value
) != COMPOUND_LITERAL_EXPR
)
3133 init
= default_function_array_conversion (init
);
3135 process_init_element (init
);
3138 /* Parse a compound statement (possibly a function body) (C90 6.6.2,
3142 { block-item-list[opt] }
3143 { label-declarations block-item-list }
3147 block-item-list block-item
3159 { label-declarations block-item-list }
3162 __extension__ nested-declaration
3163 nested-function-definition
3167 label-declarations label-declaration
3170 __label__ identifier-list ;
3172 Allowing the mixing of declarations and code is new in C99. The
3173 GNU syntax also permits (not shown above) labels at the end of
3174 compound statements, which yield an error. We don't allow labels
3175 on declarations; this might seem like a natural extension, but
3176 there would be a conflict between attributes on the label and
3177 prefix attributes on the declaration. ??? The syntax follows the
3178 old parser in requiring something after label declarations.
3179 Although they are erroneous if the labels declared aren't defined,
3180 is it useful for the syntax to be this way? */
3183 c_parser_compound_statement (c_parser
*parser
)
3186 if (!c_parser_require (parser
, CPP_OPEN_BRACE
, "expected %<{%>"))
3187 return error_mark_node
;
3188 stmt
= c_begin_compound_stmt (true);
3189 c_parser_compound_statement_nostart (parser
);
3190 return c_end_compound_stmt (stmt
, true);
3193 /* Parse a compound statement except for the opening brace. This is
3194 used for parsing both compound statements and statement expressions
3195 (which follow different paths to handling the opening). */
3198 c_parser_compound_statement_nostart (c_parser
*parser
)
3200 bool last_stmt
= false;
3201 bool last_label
= false;
3202 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
3204 c_parser_consume_token (parser
);
3207 if (c_parser_next_token_is_keyword (parser
, RID_LABEL
))
3209 /* Read zero or more forward-declarations for labels that nested
3210 functions can jump to. */
3211 while (c_parser_next_token_is_keyword (parser
, RID_LABEL
))
3213 c_parser_consume_token (parser
);
3214 /* Any identifiers, including those declared as type names,
3219 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
3221 c_parser_error (parser
, "expected identifier");
3225 = declare_label (c_parser_peek_token (parser
)->value
);
3226 C_DECLARED_LABEL_FLAG (label
) = 1;
3227 add_stmt (build_stmt (DECL_EXPR
, label
));
3228 c_parser_consume_token (parser
);
3229 if (c_parser_next_token_is (parser
, CPP_COMMA
))
3230 c_parser_consume_token (parser
);
3234 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
3236 /* ??? Locating this diagnostic on the token after the
3237 declarations end follows the old parser, but it might be
3238 better to locate it where the declarations start instead. */
3240 pedwarn ("ISO C forbids label declarations");
3242 /* We must now have at least one statement, label or declaration. */
3243 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
3245 c_parser_error (parser
, "expected declaration or statement");
3246 c_parser_consume_token (parser
);
3249 while (c_parser_next_token_is_not (parser
, CPP_CLOSE_BRACE
))
3251 location_t loc
= c_parser_peek_token (parser
)->location
;
3252 if (c_parser_next_token_is (parser
, CPP_EOF
))
3254 c_parser_error (parser
, "expected declaration or statement");
3257 if (c_parser_next_token_is_keyword (parser
, RID_CASE
)
3258 || c_parser_next_token_is_keyword (parser
, RID_DEFAULT
)
3259 || (c_parser_next_token_is (parser
, CPP_NAME
)
3260 && c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
))
3264 c_parser_label (parser
);
3266 else if (!last_label
3267 && c_parser_next_token_starts_declspecs (parser
))
3270 c_parser_declaration_or_fndef (parser
, true, true, true, true);
3272 && ((pedantic
&& !flag_isoc99
)
3273 || warn_declaration_after_statement
))
3274 pedwarn_c90 ("%HISO C90 forbids mixed declarations and code",
3278 else if (!last_label
3279 && c_parser_next_token_is_keyword (parser
, RID_EXTENSION
))
3281 /* __extension__ can start a declaration, but is also an
3282 unary operator that can start an expression. Consume all
3283 but the last of a possible series of __extension__ to
3285 while (c_parser_peek_2nd_token (parser
)->type
== CPP_KEYWORD
3286 && (c_parser_peek_2nd_token (parser
)->keyword
3288 c_parser_consume_token (parser
);
3289 if (c_token_starts_declspecs (c_parser_peek_2nd_token (parser
)))
3292 ext
= disable_extension_diagnostics ();
3293 c_parser_consume_token (parser
);
3295 c_parser_declaration_or_fndef (parser
, true, true, true, true);
3296 /* Following the old parser, __extension__ does not
3297 disable this diagnostic. */
3298 restore_extension_diagnostics (ext
);
3300 && ((pedantic
&& !flag_isoc99
)
3301 || warn_declaration_after_statement
))
3302 pedwarn_c90 ("%HISO C90 forbids mixed declarations and code",
3314 c_parser_statement_after_labels (parser
);
3318 error ("label at end of compound statement");
3319 c_parser_consume_token (parser
);
3322 /* Parse a label (C90 6.6.1, C99 6.8.1).
3325 identifier : attributes[opt]
3326 case constant-expression :
3332 case constant-expression ... constant-expression :
3334 The use of attributes on labels is a GNU extension. The syntax in
3335 GNU C accepts any expressions without commas, non-constant
3336 expressions being rejected later. */
3339 c_parser_label (c_parser
*parser
)
3341 location_t loc1
= c_parser_peek_token (parser
)->location
;
3342 tree label
= NULL_TREE
;
3343 if (c_parser_next_token_is_keyword (parser
, RID_CASE
))
3346 c_parser_consume_token (parser
);
3347 exp1
= c_parser_expr_no_commas (parser
, NULL
).value
;
3348 if (c_parser_next_token_is (parser
, CPP_COLON
))
3350 c_parser_consume_token (parser
);
3351 label
= do_case (exp1
, NULL_TREE
);
3353 else if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
))
3355 c_parser_consume_token (parser
);
3356 exp2
= c_parser_expr_no_commas (parser
, NULL
).value
;
3357 if (c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
3358 label
= do_case (exp1
, exp2
);
3361 c_parser_error (parser
, "expected %<:%> or %<...%>");
3363 else if (c_parser_next_token_is_keyword (parser
, RID_DEFAULT
))
3365 c_parser_consume_token (parser
);
3366 if (c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
3367 label
= do_case (NULL_TREE
, NULL_TREE
);
3371 tree name
= c_parser_peek_token (parser
)->value
;
3375 gcc_assert (c_parser_next_token_is (parser
, CPP_NAME
));
3376 c_parser_consume_token (parser
);
3377 gcc_assert (c_parser_next_token_is (parser
, CPP_COLON
));
3378 loc2
= c_parser_peek_token (parser
)->location
;
3379 c_parser_consume_token (parser
);
3380 attrs
= c_parser_attributes (parser
);
3381 tlab
= define_label (loc2
, name
);
3384 decl_attributes (&tlab
, attrs
, 0);
3385 label
= add_stmt (build_stmt (LABEL_EXPR
, tlab
));
3389 SET_EXPR_LOCATION (label
, loc1
);
3392 /* Parse a statement (C90 6.6, C99 6.8).
3397 expression-statement
3405 expression-statement:
3408 selection-statement:
3412 iteration-statement:
3421 return expression[opt] ;
3434 objc-throw-statement
3435 objc-try-catch-statement
3436 objc-synchronized-statement
3438 objc-throw-statement:
3444 c_parser_statement (c_parser
*parser
)
3446 while (c_parser_next_token_is_keyword (parser
, RID_CASE
)
3447 || c_parser_next_token_is_keyword (parser
, RID_DEFAULT
)
3448 || (c_parser_next_token_is (parser
, CPP_NAME
)
3449 && c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
))
3450 c_parser_label (parser
);
3451 c_parser_statement_after_labels (parser
);
3454 /* Parse a statement, other than a labeled statement. */
3457 c_parser_statement_after_labels (c_parser
*parser
)
3459 location_t loc
= c_parser_peek_token (parser
)->location
;
3460 tree stmt
= NULL_TREE
;
3461 switch (c_parser_peek_token (parser
)->type
)
3463 case CPP_OPEN_BRACE
:
3464 add_stmt (c_parser_compound_statement (parser
));
3467 switch (c_parser_peek_token (parser
)->keyword
)
3470 c_parser_if_statement (parser
);
3473 c_parser_switch_statement (parser
);
3476 c_parser_while_statement (parser
);
3479 c_parser_do_statement (parser
);
3482 c_parser_for_statement (parser
);
3485 c_parser_consume_token (parser
);
3486 if (c_parser_next_token_is (parser
, CPP_NAME
))
3488 stmt
= c_finish_goto_label (c_parser_peek_token (parser
)->value
);
3489 c_parser_consume_token (parser
);
3491 else if (c_parser_next_token_is (parser
, CPP_MULT
))
3493 c_parser_consume_token (parser
);
3494 stmt
= c_finish_goto_ptr (c_parser_expression (parser
).value
);
3497 c_parser_error (parser
, "expected identifier or %<*%>");
3498 goto expect_semicolon
;
3500 c_parser_consume_token (parser
);
3501 stmt
= c_finish_bc_stmt (&c_cont_label
, false);
3502 goto expect_semicolon
;
3504 c_parser_consume_token (parser
);
3505 stmt
= c_finish_bc_stmt (&c_break_label
, true);
3506 goto expect_semicolon
;
3508 c_parser_consume_token (parser
);
3509 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
3511 stmt
= c_finish_return (NULL_TREE
);
3512 c_parser_consume_token (parser
);
3516 stmt
= c_finish_return (c_parser_expression_conv (parser
).value
);
3517 goto expect_semicolon
;
3521 stmt
= c_parser_asm_statement (parser
);
3524 gcc_assert (c_dialect_objc ());
3525 c_parser_consume_token (parser
);
3526 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
3528 stmt
= objc_build_throw_stmt (NULL_TREE
);
3529 c_parser_consume_token (parser
);
3534 = objc_build_throw_stmt (c_parser_expression (parser
).value
);
3535 goto expect_semicolon
;
3539 gcc_assert (c_dialect_objc ());
3540 c_parser_objc_try_catch_statement (parser
);
3542 case RID_AT_SYNCHRONIZED
:
3543 gcc_assert (c_dialect_objc ());
3544 c_parser_objc_synchronized_statement (parser
);
3551 c_parser_consume_token (parser
);
3553 case CPP_CLOSE_PAREN
:
3554 case CPP_CLOSE_SQUARE
:
3555 /* Avoid infinite loop in error recovery:
3556 c_parser_skip_until_found stops at a closing nesting
3557 delimiter without consuming it, but here we need to consume
3558 it to proceed further. */
3559 c_parser_error (parser
, "expected statement");
3560 c_parser_consume_token (parser
);
3564 stmt
= c_finish_expr_stmt (c_parser_expression_conv (parser
).value
);
3566 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
3569 /* Two cases cannot and do not have line numbers associated: If stmt
3570 is degenerate, such as "2;", then stmt is an INTEGER_CST, which
3571 cannot hold line numbers. But that's OK because the statement
3572 will either be changed to a MODIFY_EXPR during gimplification of
3573 the statement expr, or discarded. If stmt was compound, but
3574 without new variables, we will have skipped the creation of a
3575 BIND and will have a bare STATEMENT_LIST. But that's OK because
3576 (recursively) all of the component statements should already have
3577 line numbers assigned. ??? Can we discard no-op statements
3579 if (stmt
&& EXPR_P (stmt
))
3580 SET_EXPR_LOCATION (stmt
, loc
);
3583 /* Parse a parenthesized condition from an if, do or while statement.
3589 c_parser_paren_condition (c_parser
*parser
)
3593 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
3594 return error_mark_node
;
3595 loc
= c_parser_peek_token (parser
)->location
;
3596 cond
= c_objc_common_truthvalue_conversion
3597 (c_parser_expression_conv (parser
).value
);
3599 SET_EXPR_LOCATION (cond
, loc
);
3600 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
3604 /* Parse a statement which is a block in C99. */
3607 c_parser_c99_block_statement (c_parser
*parser
)
3609 tree block
= c_begin_compound_stmt (flag_isoc99
);
3610 c_parser_statement (parser
);
3611 return c_end_compound_stmt (block
, flag_isoc99
);
3614 /* Parse the body of an if statement or the else half thereof. This
3615 is just parsing a statement but (a) it is a block in C99, (b) we
3616 track whether the body is an if statement for the sake of
3617 -Wparentheses warnings, (c) we handle an empty body specially for
3618 the sake of -Wextra warnings. */
3621 c_parser_if_body (c_parser
*parser
, bool *if_p
)
3623 tree block
= c_begin_compound_stmt (flag_isoc99
);
3624 while (c_parser_next_token_is_keyword (parser
, RID_CASE
)
3625 || c_parser_next_token_is_keyword (parser
, RID_DEFAULT
)
3626 || (c_parser_next_token_is (parser
, CPP_NAME
)
3627 && c_parser_peek_2nd_token (parser
)->type
== CPP_COLON
))
3628 c_parser_label (parser
);
3629 *if_p
= c_parser_next_token_is_keyword (parser
, RID_IF
);
3630 if (extra_warnings
&& c_parser_next_token_is (parser
, CPP_SEMICOLON
))
3631 add_stmt (build (NOP_EXPR
, NULL_TREE
, NULL_TREE
));
3632 c_parser_statement_after_labels (parser
);
3633 return c_end_compound_stmt (block
, flag_isoc99
);
3636 /* Parse an if statement (C90 6.6.4, C99 6.8.4).
3639 if ( expression ) statement
3640 if ( expression ) statement else statement
3644 c_parser_if_statement (c_parser
*parser
)
3649 bool first_if
= false, second_if
= false;
3650 tree first_body
, second_body
;
3651 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_IF
));
3652 c_parser_consume_token (parser
);
3653 block
= c_begin_compound_stmt (flag_isoc99
);
3654 loc
= c_parser_peek_token (parser
)->location
;
3655 cond
= c_parser_paren_condition (parser
);
3656 first_body
= c_parser_if_body (parser
, &first_if
);
3657 if (c_parser_next_token_is_keyword (parser
, RID_ELSE
))
3659 c_parser_consume_token (parser
);
3660 second_body
= c_parser_if_body (parser
, &second_if
);
3663 second_body
= NULL_TREE
;
3664 c_finish_if_stmt (loc
, cond
, first_body
, second_body
, first_if
);
3665 add_stmt (c_end_compound_stmt (block
, flag_isoc99
));
3668 /* Parse a switch statement (C90 6.6.4, C99 6.8.4).
3671 switch (expression) statement
3675 c_parser_switch_statement (c_parser
*parser
)
3677 tree block
, expr
, body
, save_break
;
3678 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_SWITCH
));
3679 c_parser_consume_token (parser
);
3680 block
= c_begin_compound_stmt (flag_isoc99
);
3681 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
3683 expr
= c_parser_expression (parser
).value
;
3684 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
3687 expr
= error_mark_node
;
3688 c_start_case (expr
);
3689 save_break
= c_break_label
;
3690 c_break_label
= NULL_TREE
;
3691 body
= c_parser_c99_block_statement (parser
);
3692 c_finish_case (body
);
3694 add_stmt (build (LABEL_EXPR
, void_type_node
, c_break_label
));
3695 c_break_label
= save_break
;
3696 add_stmt (c_end_compound_stmt (block
, flag_isoc99
));
3699 /* Parse a while statement (C90 6.6.5, C99 6.8.5).
3702 while (expression) statement
3706 c_parser_while_statement (c_parser
*parser
)
3708 tree block
, cond
, body
, save_break
, save_cont
;
3710 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_WHILE
));
3711 c_parser_consume_token (parser
);
3712 block
= c_begin_compound_stmt (flag_isoc99
);
3713 loc
= c_parser_peek_token (parser
)->location
;
3714 cond
= c_parser_paren_condition (parser
);
3715 save_break
= c_break_label
;
3716 c_break_label
= NULL_TREE
;
3717 save_cont
= c_cont_label
;
3718 c_cont_label
= NULL_TREE
;
3719 body
= c_parser_c99_block_statement (parser
);
3720 c_finish_loop (loc
, cond
, NULL
, body
, c_break_label
, c_cont_label
, true);
3721 add_stmt (c_end_compound_stmt (block
, flag_isoc99
));
3722 c_break_label
= save_break
;
3723 c_cont_label
= save_cont
;
3726 /* Parse a do statement (C90 6.6.5, C99 6.8.5).
3729 do statement while ( expression ) ;
3733 c_parser_do_statement (c_parser
*parser
)
3735 tree block
, cond
, body
, save_break
, save_cont
, new_break
, new_cont
;
3737 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_DO
));
3738 c_parser_consume_token (parser
);
3739 block
= c_begin_compound_stmt (flag_isoc99
);
3740 loc
= c_parser_peek_token (parser
)->location
;
3741 save_break
= c_break_label
;
3742 c_break_label
= NULL_TREE
;
3743 save_cont
= c_cont_label
;
3744 c_cont_label
= NULL_TREE
;
3745 body
= c_parser_c99_block_statement (parser
);
3746 c_parser_require_keyword (parser
, RID_WHILE
, "expected %<while%>");
3747 new_break
= c_break_label
;
3748 c_break_label
= save_break
;
3749 new_cont
= c_cont_label
;
3750 c_cont_label
= save_cont
;
3751 cond
= c_parser_paren_condition (parser
);
3752 if (!c_parser_require (parser
, CPP_SEMICOLON
, "expected %<;%>"))
3753 c_parser_skip_to_end_of_block_or_statement (parser
);
3754 c_finish_loop (loc
, cond
, NULL
, body
, new_break
, new_cont
, false);
3755 add_stmt (c_end_compound_stmt (block
, flag_isoc99
));
3758 /* Parse a for statement (C90 6.6.5, C99 6.8.5).
3761 for ( expression[opt] ; expression[opt] ; expression[opt] ) statement
3762 for ( nested-declaration expression[opt] ; expression[opt] ) statement
3764 The form with a declaration is new in C99.
3766 ??? In accordance with the old parser, the declaration may be a
3767 nested function, which is then rejected in check_for_loop_decls,
3768 but does it make any sense for this to be included in the grammar?
3769 Note in particular that the nested function does not include a
3770 trailing ';', whereas the "declaration" production includes one.
3771 Also, can we reject bad declarations earlier and cheaper than
3772 check_for_loop_decls? */
3775 c_parser_for_statement (c_parser
*parser
)
3777 tree block
, cond
, incr
, save_break
, save_cont
, body
;
3778 location_t loc
= UNKNOWN_LOCATION
;
3779 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_FOR
));
3780 c_parser_consume_token (parser
);
3781 block
= c_begin_compound_stmt (flag_isoc99
);
3782 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
3784 /* Parse the initialization declaration or expression. */
3785 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
3787 c_parser_consume_token (parser
);
3788 c_finish_expr_stmt (NULL_TREE
);
3790 else if (c_parser_next_token_starts_declspecs (parser
))
3792 c_parser_declaration_or_fndef (parser
, true, true, true, true);
3793 check_for_loop_decls ();
3795 else if (c_parser_next_token_is_keyword (parser
, RID_EXTENSION
))
3797 /* __extension__ can start a declaration, but is also an
3798 unary operator that can start an expression. Consume all
3799 but the last of a possible series of __extension__ to
3801 while (c_parser_peek_2nd_token (parser
)->type
== CPP_KEYWORD
3802 && (c_parser_peek_2nd_token (parser
)->keyword
3804 c_parser_consume_token (parser
);
3805 if (c_token_starts_declspecs (c_parser_peek_2nd_token (parser
)))
3808 ext
= disable_extension_diagnostics ();
3809 c_parser_consume_token (parser
);
3810 c_parser_declaration_or_fndef (parser
, true, true, true, true);
3811 restore_extension_diagnostics (ext
);
3812 check_for_loop_decls ();
3820 c_finish_expr_stmt (c_parser_expression (parser
).value
);
3821 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
3823 /* Parse the loop condition. */
3824 loc
= c_parser_peek_token (parser
)->location
;
3825 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
3827 c_parser_consume_token (parser
);
3832 tree ocond
= c_parser_expression_conv (parser
).value
;
3833 cond
= c_objc_common_truthvalue_conversion (ocond
);
3835 SET_EXPR_LOCATION (cond
, loc
);
3836 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
3838 /* Parse the increment expression. */
3839 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
3840 incr
= c_process_expr_stmt (NULL_TREE
);
3842 incr
= c_process_expr_stmt (c_parser_expression (parser
).value
);
3843 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
3847 cond
= error_mark_node
;
3848 incr
= error_mark_node
;
3850 save_break
= c_break_label
;
3851 c_break_label
= NULL_TREE
;
3852 save_cont
= c_cont_label
;
3853 c_cont_label
= NULL_TREE
;
3854 body
= c_parser_c99_block_statement (parser
);
3855 c_finish_loop (loc
, cond
, incr
, body
, c_break_label
, c_cont_label
, true);
3856 add_stmt (c_end_compound_stmt (block
, flag_isoc99
));
3857 c_break_label
= save_break
;
3858 c_cont_label
= save_cont
;
3861 /* Parse an asm statement, a GNU extension. This is a full-blown asm
3862 statement with inputs, outputs, clobbers, and volatile tag
3866 asm type-qualifier[opt] ( asm-argument ) ;
3870 asm-string-literal : asm-operands[opt]
3871 asm-string-literal : asm-operands[opt] : asm-operands[opt]
3872 asm-string-literal : asm-operands[opt] : asm-operands[opt] : asm-clobbers
3874 Qualifiers other than volatile are accepted in the syntax but
3878 c_parser_asm_statement (c_parser
*parser
)
3880 tree quals
, str
, outputs
, inputs
, clobbers
, ret
;
3882 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_ASM
));
3883 c_parser_consume_token (parser
);
3884 if (c_parser_next_token_is_keyword (parser
, RID_VOLATILE
))
3886 quals
= c_parser_peek_token (parser
)->value
;
3887 c_parser_consume_token (parser
);
3889 else if (c_parser_next_token_is_keyword (parser
, RID_CONST
)
3890 || c_parser_next_token_is_keyword (parser
, RID_RESTRICT
))
3892 warning (0, "%E qualifier ignored on asm",
3893 c_parser_peek_token (parser
)->value
);
3895 c_parser_consume_token (parser
);
3899 /* ??? Follow the C++ parser rather than using the
3900 c_lex_string_translate kludge. */
3901 c_lex_string_translate
= 0;
3902 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
3904 c_lex_string_translate
= 1;
3907 str
= c_parser_asm_string_literal (parser
);
3908 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
3911 outputs
= NULL_TREE
;
3913 clobbers
= NULL_TREE
;
3916 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%> or %<)%>"))
3918 c_lex_string_translate
= 1;
3919 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
3923 /* Parse outputs. */
3924 if (c_parser_next_token_is (parser
, CPP_COLON
)
3925 || c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
3926 outputs
= NULL_TREE
;
3928 outputs
= c_parser_asm_operands (parser
, false);
3929 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
3932 clobbers
= NULL_TREE
;
3935 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%> or %<)%>"))
3937 c_lex_string_translate
= 1;
3938 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
3942 if (c_parser_next_token_is (parser
, CPP_COLON
)
3943 || c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
3946 inputs
= c_parser_asm_operands (parser
, true);
3947 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
3949 clobbers
= NULL_TREE
;
3952 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%> or %<)%>"))
3954 c_lex_string_translate
= 1;
3955 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
3958 /* Parse clobbers. */
3959 clobbers
= c_parser_asm_clobbers (parser
);
3961 c_lex_string_translate
= 1;
3962 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
3964 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
3967 if (!c_parser_require (parser
, CPP_SEMICOLON
, "expected %<;%>"))
3968 c_parser_skip_to_end_of_block_or_statement (parser
);
3969 ret
= build_asm_stmt (quals
, build_asm_expr (str
, outputs
, inputs
,
3974 /* Parse asm operands, a GNU extension. If CONVERT_P (for inputs but
3975 not outputs), apply the default conversion of functions and arrays
3980 asm-operands , asm-operand
3983 asm-string-literal ( expression )
3984 [ identifier ] asm-string-literal ( expression )
3988 c_parser_asm_operands (c_parser
*parser
, bool convert_p
)
3990 tree list
= NULL_TREE
;
3995 if (c_parser_next_token_is (parser
, CPP_OPEN_SQUARE
))
3997 c_parser_consume_token (parser
);
3998 if (c_parser_next_token_is (parser
, CPP_NAME
))
4000 tree id
= c_parser_peek_token (parser
)->value
;
4001 c_parser_consume_token (parser
);
4002 name
= build_string (IDENTIFIER_LENGTH (id
),
4003 IDENTIFIER_POINTER (id
));
4007 c_parser_error (parser
, "expected identifier");
4008 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
, NULL
);
4011 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
4016 str
= c_parser_asm_string_literal (parser
);
4017 if (str
== NULL_TREE
)
4019 c_lex_string_translate
= 1;
4020 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
4022 c_lex_string_translate
= 0;
4025 expr
= c_parser_expression (parser
);
4027 expr
= default_function_array_conversion (expr
);
4028 c_lex_string_translate
= 0;
4029 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
4031 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
4034 list
= chainon (list
, build_tree_list (build_tree_list (name
, str
),
4036 if (c_parser_next_token_is (parser
, CPP_COMMA
))
4037 c_parser_consume_token (parser
);
4044 /* Parse asm clobbers, a GNU extension.
4048 asm-clobbers , asm-string-literal
4052 c_parser_asm_clobbers (c_parser
*parser
)
4054 tree list
= NULL_TREE
;
4057 tree str
= c_parser_asm_string_literal (parser
);
4059 list
= tree_cons (NULL_TREE
, str
, list
);
4062 if (c_parser_next_token_is (parser
, CPP_COMMA
))
4063 c_parser_consume_token (parser
);
4070 /* Parse an expression other than a compound expression; that is, an
4071 assignment expression (C90 6.3.16, C99 6.5.16). If AFTER is not
4072 NULL then it is an Objective-C message expression which is the
4073 primary-expression starting the expression as an initializer.
4075 assignment-expression:
4076 conditional-expression
4077 unary-expression assignment-operator assignment-expression
4079 assignment-operator: one of
4080 = *= /= %= += -= <<= >>= &= ^= |=
4082 In GNU C we accept any conditional expression on the LHS and
4083 diagnose the invalid lvalue rather than producing a syntax
4086 static struct c_expr
4087 c_parser_expr_no_commas (c_parser
*parser
, struct c_expr
*after
)
4089 struct c_expr lhs
, rhs
, ret
;
4090 enum tree_code code
;
4091 gcc_assert (!after
|| c_dialect_objc ());
4092 lhs
= c_parser_conditional_expression (parser
, after
);
4093 switch (c_parser_peek_token (parser
)->type
)
4102 code
= TRUNC_DIV_EXPR
;
4105 code
= TRUNC_MOD_EXPR
;
4120 code
= BIT_AND_EXPR
;
4123 code
= BIT_XOR_EXPR
;
4126 code
= BIT_IOR_EXPR
;
4131 c_parser_consume_token (parser
);
4132 rhs
= c_parser_expr_no_commas (parser
, NULL
);
4133 rhs
= default_function_array_conversion (rhs
);
4134 ret
.value
= build_modify_expr (lhs
.value
, code
, rhs
.value
);
4135 if (code
== NOP_EXPR
)
4136 ret
.original_code
= MODIFY_EXPR
;
4139 TREE_NO_WARNING (ret
.value
) = 1;
4140 ret
.original_code
= ERROR_MARK
;
4145 /* Parse a conditional expression (C90 6.3.15, C99 6.5.15). If AFTER
4146 is not NULL then it is an Objective-C message expression which is
4147 the primary-expression starting the expression as an initializer.
4149 conditional-expression:
4150 logical-OR-expression
4151 logical-OR-expression ? expression : conditional-expression
4155 conditional-expression:
4156 logical-OR-expression ? : conditional-expression
4159 static struct c_expr
4160 c_parser_conditional_expression (c_parser
*parser
, struct c_expr
*after
)
4162 struct c_expr cond
, exp1
, exp2
, ret
;
4163 gcc_assert (!after
|| c_dialect_objc ());
4164 cond
= c_parser_binary_expression (parser
, after
);
4165 if (c_parser_next_token_is_not (parser
, CPP_QUERY
))
4167 cond
= default_function_array_conversion (cond
);
4168 c_parser_consume_token (parser
);
4169 if (c_parser_next_token_is (parser
, CPP_COLON
))
4172 pedwarn ("ISO C forbids omitting the middle term of a ?: expression");
4173 /* Make sure first operand is calculated only once. */
4174 exp1
.value
= save_expr (default_conversion (cond
.value
));
4175 cond
.value
= c_objc_common_truthvalue_conversion (exp1
.value
);
4176 skip_evaluation
+= cond
.value
== truthvalue_true_node
;
4181 = c_objc_common_truthvalue_conversion
4182 (default_conversion (cond
.value
));
4183 skip_evaluation
+= cond
.value
== truthvalue_false_node
;
4184 exp1
= c_parser_expression_conv (parser
);
4185 skip_evaluation
+= ((cond
.value
== truthvalue_true_node
)
4186 - (cond
.value
== truthvalue_false_node
));
4188 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
4190 skip_evaluation
-= cond
.value
== truthvalue_true_node
;
4191 ret
.value
= error_mark_node
;
4192 ret
.original_code
= ERROR_MARK
;
4195 exp2
= c_parser_conditional_expression (parser
, NULL
);
4196 exp2
= default_function_array_conversion (exp2
);
4197 skip_evaluation
-= cond
.value
== truthvalue_true_node
;
4198 ret
.value
= build_conditional_expr (cond
.value
, exp1
.value
, exp2
.value
);
4199 ret
.original_code
= ERROR_MARK
;
4203 /* Parse a binary expression; that is, a logical-OR-expression (C90
4204 6.3.5-6.3.14, C99 6.5.5-6.5.14). If AFTER is not NULL then it is
4205 an Objective-C message expression which is the primary-expression
4206 starting the expression as an initializer.
4208 multiplicative-expression:
4210 multiplicative-expression * cast-expression
4211 multiplicative-expression / cast-expression
4212 multiplicative-expression % cast-expression
4214 additive-expression:
4215 multiplicative-expression
4216 additive-expression + multiplicative-expression
4217 additive-expression - multiplicative-expression
4221 shift-expression << additive-expression
4222 shift-expression >> additive-expression
4224 relational-expression:
4226 relational-expression < shift-expression
4227 relational-expression > shift-expression
4228 relational-expression <= shift-expression
4229 relational-expression >= shift-expression
4231 equality-expression:
4232 relational-expression
4233 equality-expression == relational-expression
4234 equality-expression != relational-expression
4238 AND-expression & equality-expression
4240 exclusive-OR-expression:
4242 exclusive-OR-expression ^ AND-expression
4244 inclusive-OR-expression:
4245 exclusive-OR-expression
4246 inclusive-OR-expression | exclusive-OR-expression
4248 logical-AND-expression:
4249 inclusive-OR-expression
4250 logical-AND-expression && inclusive-OR-expression
4252 logical-OR-expression:
4253 logical-AND-expression
4254 logical-OR-expression || logical-AND-expression
4257 static struct c_expr
4258 c_parser_binary_expression (c_parser
*parser
, struct c_expr
*after
)
4260 /* A binary expression is parsed using operator-precedence parsing,
4261 with the operands being cast expressions. All the binary
4262 operators are left-associative. Thus a binary expression is of
4265 E0 op1 E1 op2 E2 ...
4267 which we represent on a stack. On the stack, the precedence
4268 levels are strictly increasing. When a new operator is
4269 encountered of higher precedence than that at the top of the
4270 stack, it is pushed; its LHS is the top expression, and its RHS
4271 is everything parsed until it is popped. When a new operator is
4272 encountered with precedence less than or equal to that at the top
4273 of the stack, triples E[i-1] op[i] E[i] are popped and replaced
4274 by the result of the operation until the operator at the top of
4275 the stack has lower precedence than the new operator or there is
4276 only one element on the stack; then the top expression is the LHS
4277 of the new operator. In the case of logical AND and OR
4278 expressions, we also need to adjust skip_evaluation as
4279 appropriate when the operators are pushed and popped. */
4281 /* The precedence levels, where 0 is a dummy lowest level used for
4282 the bottom of the stack. */
4298 /* The expression at this stack level. */
4300 /* The precedence of the operator on its left, PREC_NONE at the
4301 bottom of the stack. */
4303 /* The operation on its left. */
4309 switch (stack[sp].op) \
4311 case TRUTH_ANDIF_EXPR: \
4312 skip_evaluation -= stack[sp - 1].expr.value == truthvalue_false_node; \
4314 case TRUTH_ORIF_EXPR: \
4315 skip_evaluation -= stack[sp - 1].expr.value == truthvalue_true_node; \
4320 stack[sp - 1].expr \
4321 = default_function_array_conversion (stack[sp - 1].expr); \
4323 = default_function_array_conversion (stack[sp].expr); \
4324 stack[sp - 1].expr = parser_build_binary_op (stack[sp].op, \
4325 stack[sp - 1].expr, \
4329 gcc_assert (!after
|| c_dialect_objc ());
4330 stack
[0].expr
= c_parser_cast_expression (parser
, after
);
4331 stack
[0].prec
= PREC_NONE
;
4336 enum tree_code ocode
;
4339 switch (c_parser_peek_token (parser
)->type
)
4347 ocode
= TRUNC_DIV_EXPR
;
4351 ocode
= TRUNC_MOD_EXPR
;
4363 ocode
= LSHIFT_EXPR
;
4367 ocode
= RSHIFT_EXPR
;
4381 case CPP_GREATER_EQ
:
4394 oprec
= PREC_BITAND
;
4395 ocode
= BIT_AND_EXPR
;
4398 oprec
= PREC_BITXOR
;
4399 ocode
= BIT_XOR_EXPR
;
4403 ocode
= BIT_IOR_EXPR
;
4406 oprec
= PREC_LOGAND
;
4407 ocode
= TRUTH_ANDIF_EXPR
;
4411 ocode
= TRUTH_ORIF_EXPR
;
4414 /* Not a binary operator, so end of the binary
4418 c_parser_consume_token (parser
);
4419 while (oprec
<= stack
[sp
].prec
)
4423 case TRUTH_ANDIF_EXPR
:
4425 = default_function_array_conversion (stack
[sp
].expr
);
4426 stack
[sp
].expr
.value
= c_objc_common_truthvalue_conversion
4427 (default_conversion (stack
[sp
].expr
.value
));
4428 skip_evaluation
+= stack
[sp
].expr
.value
== truthvalue_false_node
;
4430 case TRUTH_ORIF_EXPR
:
4432 = default_function_array_conversion (stack
[sp
].expr
);
4433 stack
[sp
].expr
.value
= c_objc_common_truthvalue_conversion
4434 (default_conversion (stack
[sp
].expr
.value
));
4435 skip_evaluation
+= stack
[sp
].expr
.value
== truthvalue_true_node
;
4441 stack
[sp
].expr
= c_parser_cast_expression (parser
, NULL
);
4442 stack
[sp
].prec
= oprec
;
4443 stack
[sp
].op
= ocode
;
4448 return stack
[0].expr
;
4452 /* Parse a cast expression (C90 6.3.4, C99 6.5.4). If AFTER is not
4453 NULL then it is an Objective-C message expression which is the
4454 primary-expression starting the expression as an initializer.
4458 ( type-name ) unary-expression
4461 static struct c_expr
4462 c_parser_cast_expression (c_parser
*parser
, struct c_expr
*after
)
4464 gcc_assert (!after
|| c_dialect_objc ());
4466 return c_parser_postfix_expression_after_primary (parser
, *after
);
4467 /* If the expression begins with a parenthesized type name, it may
4468 be either a cast or a compound literal; we need to see whether
4469 the next character is '{' to tell the difference. If not, it is
4470 an unary expression. */
4471 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
)
4472 && c_token_starts_typename (c_parser_peek_2nd_token (parser
)))
4474 struct c_type_name
*type_name
;
4477 c_parser_consume_token (parser
);
4478 type_name
= c_parser_type_name (parser
);
4479 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
4480 if (type_name
== NULL
)
4482 ret
.value
= error_mark_node
;
4483 ret
.original_code
= ERROR_MARK
;
4486 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
4487 return c_parser_postfix_expression_after_paren_type (parser
,
4489 expr
= c_parser_cast_expression (parser
, NULL
);
4490 expr
= default_function_array_conversion (expr
);
4491 ret
.value
= c_cast_expr (type_name
, expr
.value
);
4492 ret
.original_code
= ERROR_MARK
;
4496 return c_parser_unary_expression (parser
);
4499 /* Parse an unary expression (C90 6.3.3, C99 6.5.3).
4505 unary-operator cast-expression
4506 sizeof unary-expression
4507 sizeof ( type-name )
4509 unary-operator: one of
4515 __alignof__ unary-expression
4516 __alignof__ ( type-name )
4519 unary-operator: one of
4520 __extension__ __real__ __imag__
4522 In addition, the GNU syntax treats ++ and -- as unary operators, so
4523 they may be applied to cast expressions with errors for non-lvalues
4526 static struct c_expr
4527 c_parser_unary_expression (c_parser
*parser
)
4530 struct c_expr ret
, op
;
4531 switch (c_parser_peek_token (parser
)->type
)
4534 c_parser_consume_token (parser
);
4535 op
= c_parser_cast_expression (parser
, NULL
);
4536 op
= default_function_array_conversion (op
);
4537 return parser_build_unary_op (PREINCREMENT_EXPR
, op
);
4538 case CPP_MINUS_MINUS
:
4539 c_parser_consume_token (parser
);
4540 op
= c_parser_cast_expression (parser
, NULL
);
4541 op
= default_function_array_conversion (op
);
4542 return parser_build_unary_op (PREDECREMENT_EXPR
, op
);
4544 c_parser_consume_token (parser
);
4545 return parser_build_unary_op (ADDR_EXPR
,
4546 c_parser_cast_expression (parser
, NULL
));
4548 c_parser_consume_token (parser
);
4549 op
= c_parser_cast_expression (parser
, NULL
);
4550 op
= default_function_array_conversion (op
);
4551 ret
.value
= build_indirect_ref (op
.value
, "unary *");
4552 ret
.original_code
= ERROR_MARK
;
4555 c_parser_consume_token (parser
);
4556 if (!c_dialect_objc () && !in_system_header
)
4557 warning (OPT_Wtraditional
,
4558 "traditional C rejects the unary plus operator");
4559 op
= c_parser_cast_expression (parser
, NULL
);
4560 op
= default_function_array_conversion (op
);
4561 return parser_build_unary_op (CONVERT_EXPR
, op
);
4563 c_parser_consume_token (parser
);
4564 op
= c_parser_cast_expression (parser
, NULL
);
4565 op
= default_function_array_conversion (op
);
4566 return parser_build_unary_op (NEGATE_EXPR
, op
);
4568 c_parser_consume_token (parser
);
4569 op
= c_parser_cast_expression (parser
, NULL
);
4570 op
= default_function_array_conversion (op
);
4571 return parser_build_unary_op (BIT_NOT_EXPR
, op
);
4573 c_parser_consume_token (parser
);
4574 op
= c_parser_cast_expression (parser
, NULL
);
4575 op
= default_function_array_conversion (op
);
4576 return parser_build_unary_op (TRUTH_NOT_EXPR
, op
);
4578 /* Refer to the address of a label as a pointer. */
4579 c_parser_consume_token (parser
);
4580 if (c_parser_next_token_is (parser
, CPP_NAME
))
4582 ret
.value
= finish_label_address_expr
4583 (c_parser_peek_token (parser
)->value
);
4584 c_parser_consume_token (parser
);
4588 c_parser_error (parser
, "expected identifier");
4589 ret
.value
= error_mark_node
;
4591 ret
.original_code
= ERROR_MARK
;
4594 switch (c_parser_peek_token (parser
)->keyword
)
4597 return c_parser_sizeof_expression (parser
);
4599 return c_parser_alignof_expression (parser
);
4601 c_parser_consume_token (parser
);
4602 ext
= disable_extension_diagnostics ();
4603 ret
= c_parser_cast_expression (parser
, NULL
);
4604 restore_extension_diagnostics (ext
);
4607 c_parser_consume_token (parser
);
4608 op
= c_parser_cast_expression (parser
, NULL
);
4609 op
= default_function_array_conversion (op
);
4610 return parser_build_unary_op (REALPART_EXPR
, op
);
4612 c_parser_consume_token (parser
);
4613 op
= c_parser_cast_expression (parser
, NULL
);
4614 op
= default_function_array_conversion (op
);
4615 return parser_build_unary_op (IMAGPART_EXPR
, op
);
4617 return c_parser_postfix_expression (parser
);
4620 return c_parser_postfix_expression (parser
);
4624 /* Parse a sizeof expression. */
4626 static struct c_expr
4627 c_parser_sizeof_expression (c_parser
*parser
)
4630 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_SIZEOF
));
4631 c_parser_consume_token (parser
);
4634 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
)
4635 && c_token_starts_typename (c_parser_peek_2nd_token (parser
)))
4637 /* Either sizeof ( type-name ) or sizeof unary-expression
4638 starting with a compound literal. */
4639 struct c_type_name
*type_name
;
4640 c_parser_consume_token (parser
);
4641 type_name
= c_parser_type_name (parser
);
4642 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
4643 if (type_name
== NULL
)
4648 ret
.value
= error_mark_node
;
4649 ret
.original_code
= ERROR_MARK
;
4652 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
4654 expr
= c_parser_postfix_expression_after_paren_type (parser
,
4658 /* sizeof ( type-name ). */
4661 return c_expr_sizeof_type (type_name
);
4665 expr
= c_parser_unary_expression (parser
);
4669 if (TREE_CODE (expr
.value
) == COMPONENT_REF
4670 && DECL_C_BIT_FIELD (TREE_OPERAND (expr
.value
, 1)))
4671 error ("%<sizeof%> applied to a bit-field");
4672 return c_expr_sizeof_expr (expr
);
4676 /* Parse an alignof expression. */
4678 static struct c_expr
4679 c_parser_alignof_expression (c_parser
*parser
)
4682 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_ALIGNOF
));
4683 c_parser_consume_token (parser
);
4686 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
)
4687 && c_token_starts_typename (c_parser_peek_2nd_token (parser
)))
4689 /* Either __alignof__ ( type-name ) or __alignof__
4690 unary-expression starting with a compound literal. */
4691 struct c_type_name
*type_name
;
4693 c_parser_consume_token (parser
);
4694 type_name
= c_parser_type_name (parser
);
4695 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
4696 if (type_name
== NULL
)
4701 ret
.value
= error_mark_node
;
4702 ret
.original_code
= ERROR_MARK
;
4705 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
4707 expr
= c_parser_postfix_expression_after_paren_type (parser
,
4711 /* alignof ( type-name ). */
4714 ret
.value
= c_alignof (groktypename (type_name
));
4715 ret
.original_code
= ERROR_MARK
;
4721 expr
= c_parser_unary_expression (parser
);
4725 ret
.value
= c_alignof_expr (expr
.value
);
4726 ret
.original_code
= ERROR_MARK
;
4731 /* Parse a postfix expression (C90 6.3.1-6.3.2, C99 6.5.1-6.5.2).
4735 postfix-expression [ expression ]
4736 postfix-expression ( argument-expression-list[opt] )
4737 postfix-expression . identifier
4738 postfix-expression -> identifier
4739 postfix-expression ++
4740 postfix-expression --
4741 ( type-name ) { initializer-list }
4742 ( type-name ) { initializer-list , }
4744 argument-expression-list:
4746 argument-expression-list , argument-expression
4758 (treated as a keyword in GNU C)
4761 ( compound-statement )
4762 __builtin_va_arg ( assignment-expression , type-name )
4763 __builtin_offsetof ( type-name , offsetof-member-designator )
4764 __builtin_choose_expr ( assignment-expression ,
4765 assignment-expression ,
4766 assignment-expression )
4767 __builtin_types_compatible_p ( type-name , type-name )
4769 offsetof-member-designator:
4771 offsetof-member-designator . identifier
4772 offsetof-member-designator [ expression ]
4777 [ objc-receiver objc-message-args ]
4778 @selector ( objc-selector-arg )
4779 @protocol ( identifier )
4780 @encode ( type-name )
4784 static struct c_expr
4785 c_parser_postfix_expression (c_parser
*parser
)
4787 struct c_expr expr
, e1
, e2
, e3
;
4788 struct c_type_name
*t1
, *t2
;
4789 switch (c_parser_peek_token (parser
)->type
)
4794 expr
.value
= c_parser_peek_token (parser
)->value
;
4795 expr
.original_code
= ERROR_MARK
;
4796 c_parser_consume_token (parser
);
4800 expr
.value
= c_parser_peek_token (parser
)->value
;
4801 expr
.original_code
= STRING_CST
;
4802 c_parser_consume_token (parser
);
4804 case CPP_OBJC_STRING
:
4805 gcc_assert (c_dialect_objc ());
4807 = objc_build_string_object (c_parser_peek_token (parser
)->value
);
4808 expr
.original_code
= ERROR_MARK
;
4809 c_parser_consume_token (parser
);
4812 if (c_parser_peek_token (parser
)->id_kind
!= C_ID_ID
)
4814 c_parser_error (parser
, "expected expression");
4815 expr
.value
= error_mark_node
;
4816 expr
.original_code
= ERROR_MARK
;
4820 tree id
= c_parser_peek_token (parser
)->value
;
4821 location_t loc
= c_parser_peek_token (parser
)->location
;
4822 c_parser_consume_token (parser
);
4823 expr
.value
= build_external_ref (id
,
4824 (c_parser_peek_token (parser
)->type
4825 == CPP_OPEN_PAREN
), loc
);
4826 expr
.original_code
= ERROR_MARK
;
4829 case CPP_OPEN_PAREN
:
4830 /* A parenthesized expression, statement expression or compound
4832 if (c_parser_peek_2nd_token (parser
)->type
== CPP_OPEN_BRACE
)
4834 /* A statement expression. */
4836 c_parser_consume_token (parser
);
4837 c_parser_consume_token (parser
);
4838 if (cur_stmt_list
== NULL
)
4840 error ("braced-group within expression allowed "
4841 "only inside a function");
4842 parser
->error
= true;
4843 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
, NULL
);
4844 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
4845 expr
.value
= error_mark_node
;
4846 expr
.original_code
= ERROR_MARK
;
4849 stmt
= c_begin_stmt_expr ();
4850 c_parser_compound_statement_nostart (parser
);
4851 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
4854 pedwarn ("ISO C forbids braced-groups within expressions");
4855 expr
.value
= c_finish_stmt_expr (stmt
);
4856 expr
.original_code
= ERROR_MARK
;
4858 else if (c_token_starts_typename (c_parser_peek_2nd_token (parser
)))
4860 /* A compound literal. ??? Can we actually get here rather
4861 than going directly to
4862 c_parser_postfix_expression_after_paren_type from
4864 struct c_type_name
*type_name
;
4865 c_parser_consume_token (parser
);
4866 type_name
= c_parser_type_name (parser
);
4867 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
4869 if (type_name
== NULL
)
4871 expr
.value
= error_mark_node
;
4872 expr
.original_code
= ERROR_MARK
;
4875 expr
= c_parser_postfix_expression_after_paren_type (parser
,
4880 /* A parenthesized expression. */
4881 c_parser_consume_token (parser
);
4882 expr
= c_parser_expression (parser
);
4883 if (TREE_CODE (expr
.value
) == MODIFY_EXPR
)
4884 TREE_NO_WARNING (expr
.value
) = 1;
4885 expr
.original_code
= ERROR_MARK
;
4886 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
4891 switch (c_parser_peek_token (parser
)->keyword
)
4893 case RID_FUNCTION_NAME
:
4894 case RID_PRETTY_FUNCTION_NAME
:
4895 case RID_C99_FUNCTION_NAME
:
4896 expr
.value
= fname_decl (c_parser_peek_token (parser
)->keyword
,
4897 c_parser_peek_token (parser
)->value
);
4898 expr
.original_code
= ERROR_MARK
;
4899 c_parser_consume_token (parser
);
4902 c_parser_consume_token (parser
);
4903 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
4905 expr
.value
= error_mark_node
;
4906 expr
.original_code
= ERROR_MARK
;
4909 e1
= c_parser_expr_no_commas (parser
, NULL
);
4910 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
4912 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
4913 expr
.value
= error_mark_node
;
4914 expr
.original_code
= ERROR_MARK
;
4917 t1
= c_parser_type_name (parser
);
4918 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
4922 expr
.value
= error_mark_node
;
4923 expr
.original_code
= ERROR_MARK
;
4927 expr
.value
= build_va_arg (e1
.value
, groktypename (t1
));
4928 expr
.original_code
= ERROR_MARK
;
4932 c_parser_consume_token (parser
);
4933 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
4935 expr
.value
= error_mark_node
;
4936 expr
.original_code
= ERROR_MARK
;
4939 t1
= c_parser_type_name (parser
);
4942 expr
.value
= error_mark_node
;
4943 expr
.original_code
= ERROR_MARK
;
4946 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
4948 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
4949 expr
.value
= error_mark_node
;
4950 expr
.original_code
= ERROR_MARK
;
4954 tree type
= groktypename (t1
);
4956 if (type
== error_mark_node
)
4957 offsetof_ref
= error_mark_node
;
4959 offsetof_ref
= build1 (INDIRECT_REF
, type
, NULL
);
4960 /* Parse the second argument to __builtin_offsetof. We
4961 must have one identifier, and beyond that we want to
4962 accept sub structure and sub array references. */
4963 if (c_parser_next_token_is (parser
, CPP_NAME
))
4965 offsetof_ref
= build_component_ref
4966 (offsetof_ref
, c_parser_peek_token (parser
)->value
);
4967 c_parser_consume_token (parser
);
4968 while (c_parser_next_token_is (parser
, CPP_DOT
)
4969 || c_parser_next_token_is (parser
,
4972 if (c_parser_next_token_is (parser
, CPP_DOT
))
4974 c_parser_consume_token (parser
);
4975 if (c_parser_next_token_is_not (parser
,
4978 c_parser_error (parser
, "expected identifier");
4981 offsetof_ref
= build_component_ref
4983 c_parser_peek_token (parser
)->value
);
4984 c_parser_consume_token (parser
);
4989 c_parser_consume_token (parser
);
4990 idx
= c_parser_expression (parser
).value
;
4991 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
4993 offsetof_ref
= build_array_ref (offsetof_ref
, idx
);
4998 c_parser_error (parser
, "expected identifier");
4999 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5001 expr
.value
= fold_offsetof (offsetof_ref
);
5002 expr
.original_code
= ERROR_MARK
;
5005 case RID_CHOOSE_EXPR
:
5006 c_parser_consume_token (parser
);
5007 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
5009 expr
.value
= error_mark_node
;
5010 expr
.original_code
= ERROR_MARK
;
5013 e1
= c_parser_expr_no_commas (parser
, NULL
);
5014 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
5016 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5017 expr
.value
= error_mark_node
;
5018 expr
.original_code
= ERROR_MARK
;
5021 e2
= c_parser_expr_no_commas (parser
, NULL
);
5022 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
5024 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5025 expr
.value
= error_mark_node
;
5026 expr
.original_code
= ERROR_MARK
;
5029 e3
= c_parser_expr_no_commas (parser
, NULL
);
5030 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5035 c
= fold (e1
.value
);
5036 if (TREE_CODE (c
) != INTEGER_CST
)
5037 error ("first argument to %<__builtin_choose_expr%> not"
5039 expr
= integer_zerop (c
) ? e3
: e2
;
5042 case RID_TYPES_COMPATIBLE_P
:
5043 c_parser_consume_token (parser
);
5044 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
5046 expr
.value
= error_mark_node
;
5047 expr
.original_code
= ERROR_MARK
;
5050 t1
= c_parser_type_name (parser
);
5053 expr
.value
= error_mark_node
;
5054 expr
.original_code
= ERROR_MARK
;
5057 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
5059 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5060 expr
.value
= error_mark_node
;
5061 expr
.original_code
= ERROR_MARK
;
5064 t2
= c_parser_type_name (parser
);
5067 expr
.value
= error_mark_node
;
5068 expr
.original_code
= ERROR_MARK
;
5071 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5076 e1
= TYPE_MAIN_VARIANT (groktypename (t1
));
5077 e2
= TYPE_MAIN_VARIANT (groktypename (t2
));
5079 expr
.value
= comptypes (e1
, e2
)
5080 ? build_int_cst (NULL_TREE
, 1)
5081 : build_int_cst (NULL_TREE
, 0);
5082 expr
.original_code
= ERROR_MARK
;
5085 case RID_AT_SELECTOR
:
5086 gcc_assert (c_dialect_objc ());
5087 c_parser_consume_token (parser
);
5088 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
5090 expr
.value
= error_mark_node
;
5091 expr
.original_code
= ERROR_MARK
;
5095 tree sel
= c_parser_objc_selector_arg (parser
);
5096 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5098 expr
.value
= objc_build_selector_expr (sel
);
5099 expr
.original_code
= ERROR_MARK
;
5102 case RID_AT_PROTOCOL
:
5103 gcc_assert (c_dialect_objc ());
5104 c_parser_consume_token (parser
);
5105 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
5107 expr
.value
= error_mark_node
;
5108 expr
.original_code
= ERROR_MARK
;
5111 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5113 c_parser_error (parser
, "expected identifier");
5114 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5115 expr
.value
= error_mark_node
;
5116 expr
.original_code
= ERROR_MARK
;
5120 tree id
= c_parser_peek_token (parser
)->value
;
5121 c_parser_consume_token (parser
);
5122 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5124 expr
.value
= objc_build_protocol_expr (id
);
5125 expr
.original_code
= ERROR_MARK
;
5129 /* Extension to support C-structures in the archiver. */
5130 gcc_assert (c_dialect_objc ());
5131 c_parser_consume_token (parser
);
5132 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
5134 expr
.value
= error_mark_node
;
5135 expr
.original_code
= ERROR_MARK
;
5138 t1
= c_parser_type_name (parser
);
5141 expr
.value
= error_mark_node
;
5142 expr
.original_code
= ERROR_MARK
;
5143 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5146 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5149 tree type
= groktypename (t1
);
5150 expr
.value
= objc_build_encode_expr (type
);
5151 expr
.original_code
= ERROR_MARK
;
5155 c_parser_error (parser
, "expected expression");
5156 expr
.value
= error_mark_node
;
5157 expr
.original_code
= ERROR_MARK
;
5161 case CPP_OPEN_SQUARE
:
5162 if (c_dialect_objc ())
5164 tree receiver
, args
;
5165 c_parser_consume_token (parser
);
5166 receiver
= c_parser_objc_receiver (parser
);
5167 args
= c_parser_objc_message_args (parser
);
5168 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
5170 expr
.value
= objc_build_message_expr (build_tree_list (receiver
,
5172 expr
.original_code
= ERROR_MARK
;
5175 /* Else fall through to report error. */
5177 c_parser_error (parser
, "expected expression");
5178 expr
.value
= error_mark_node
;
5179 expr
.original_code
= ERROR_MARK
;
5182 return c_parser_postfix_expression_after_primary (parser
, expr
);
5185 /* Parse a postfix expression after a parenthesized type name: the
5186 brace-enclosed initializer of a compound literal, possibly followed
5187 by some postfix operators. This is separate because it is not
5188 possible to tell until after the type name whether a cast
5189 expression has a cast or a compound literal, or whether the operand
5190 of sizeof is a parenthesized type name or starts with a compound
5193 static struct c_expr
5194 c_parser_postfix_expression_after_paren_type (c_parser
*parser
,
5195 struct c_type_name
*type_name
)
5200 start_init (NULL_TREE
, NULL
, 0);
5201 type
= groktypename (type_name
);
5202 if (C_TYPE_VARIABLE_SIZE (type
))
5204 error ("compound literal has variable size");
5205 type
= error_mark_node
;
5207 init
= c_parser_braced_init (parser
, type
, false);
5209 maybe_warn_string_init (type
, init
);
5211 if (pedantic
&& !flag_isoc99
)
5212 pedwarn ("ISO C90 forbids compound literals");
5213 expr
.value
= build_compound_literal (type
, init
.value
);
5214 expr
.original_code
= ERROR_MARK
;
5215 return c_parser_postfix_expression_after_primary (parser
, expr
);
5218 /* Parse a postfix expression after the initial primary or compound
5219 literal; that is, parse a series of postfix operators. */
5221 static struct c_expr
5222 c_parser_postfix_expression_after_primary (c_parser
*parser
,
5225 tree ident
, idx
, exprlist
;
5228 switch (c_parser_peek_token (parser
)->type
)
5230 case CPP_OPEN_SQUARE
:
5231 /* Array reference. */
5232 c_parser_consume_token (parser
);
5233 idx
= c_parser_expression (parser
).value
;
5234 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
5236 expr
.value
= build_array_ref (expr
.value
, idx
);
5237 expr
.original_code
= ERROR_MARK
;
5239 case CPP_OPEN_PAREN
:
5240 /* Function call. */
5241 c_parser_consume_token (parser
);
5242 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
5243 exprlist
= NULL_TREE
;
5245 exprlist
= c_parser_expr_list (parser
, true);
5246 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5248 expr
.value
= build_function_call (expr
.value
, exprlist
);
5249 expr
.original_code
= ERROR_MARK
;
5252 /* Structure element reference. */
5253 c_parser_consume_token (parser
);
5254 expr
= default_function_array_conversion (expr
);
5255 if (c_parser_next_token_is (parser
, CPP_NAME
))
5256 ident
= c_parser_peek_token (parser
)->value
;
5259 c_parser_error (parser
, "expected identifier");
5260 expr
.value
= error_mark_node
;
5261 expr
.original_code
= ERROR_MARK
;
5264 c_parser_consume_token (parser
);
5265 expr
.value
= build_component_ref (expr
.value
, ident
);
5266 expr
.original_code
= ERROR_MARK
;
5269 /* Structure element reference. */
5270 c_parser_consume_token (parser
);
5271 expr
= default_function_array_conversion (expr
);
5272 if (c_parser_next_token_is (parser
, CPP_NAME
))
5273 ident
= c_parser_peek_token (parser
)->value
;
5276 c_parser_error (parser
, "expected identifier");
5277 expr
.value
= error_mark_node
;
5278 expr
.original_code
= ERROR_MARK
;
5281 c_parser_consume_token (parser
);
5282 expr
.value
= build_component_ref (build_indirect_ref (expr
.value
,
5284 expr
.original_code
= ERROR_MARK
;
5287 /* Postincrement. */
5288 c_parser_consume_token (parser
);
5289 expr
= default_function_array_conversion (expr
);
5290 expr
.value
= build_unary_op (POSTINCREMENT_EXPR
, expr
.value
, 0);
5291 expr
.original_code
= ERROR_MARK
;
5293 case CPP_MINUS_MINUS
:
5294 /* Postdecrement. */
5295 c_parser_consume_token (parser
);
5296 expr
= default_function_array_conversion (expr
);
5297 expr
.value
= build_unary_op (POSTDECREMENT_EXPR
, expr
.value
, 0);
5298 expr
.original_code
= ERROR_MARK
;
5306 /* Parse an expression (C90 6.3.17, C99 6.5.17).
5309 assignment-expression
5310 expression , assignment-expression
5313 static struct c_expr
5314 c_parser_expression (c_parser
*parser
)
5317 expr
= c_parser_expr_no_commas (parser
, NULL
);
5318 while (c_parser_next_token_is (parser
, CPP_COMMA
))
5321 c_parser_consume_token (parser
);
5322 next
= c_parser_expr_no_commas (parser
, NULL
);
5323 next
= default_function_array_conversion (next
);
5324 expr
.value
= build_compound_expr (expr
.value
, next
.value
);
5325 expr
.original_code
= COMPOUND_EXPR
;
5330 /* Parse an expression and convert functions or arrays to
5333 static struct c_expr
5334 c_parser_expression_conv (c_parser
*parser
)
5337 expr
= c_parser_expression (parser
);
5338 expr
= default_function_array_conversion (expr
);
5342 /* Parse a non-empty list of expressions. If CONVERT_P, convert
5343 functions and arrays to pointers.
5346 assignment-expression
5347 nonempty-expr-list , assignment-expression
5351 c_parser_expr_list (c_parser
*parser
, bool convert_p
)
5355 expr
= c_parser_expr_no_commas (parser
, NULL
);
5357 expr
= default_function_array_conversion (expr
);
5358 ret
= cur
= build_tree_list (NULL_TREE
, expr
.value
);
5359 while (c_parser_next_token_is (parser
, CPP_COMMA
))
5361 c_parser_consume_token (parser
);
5362 expr
= c_parser_expr_no_commas (parser
, NULL
);
5364 expr
= default_function_array_conversion (expr
);
5365 cur
= TREE_CHAIN (cur
) = build_tree_list (NULL_TREE
, expr
.value
);
5371 /* Parse Objective-C-specific constructs. */
5373 /* Parse an objc-class-definition.
5375 objc-class-definition:
5376 @interface identifier objc-superclass[opt] objc-protocol-refs[opt]
5377 objc-class-instance-variables[opt] objc-methodprotolist @end
5378 @implementation identifier objc-superclass[opt]
5379 objc-class-instance-variables[opt]
5380 @interface identifier ( identifier ) objc-protocol-refs[opt]
5381 objc-methodprotolist @end
5382 @implementation identifier ( identifier )
5387 "@interface identifier (" must start "@interface identifier (
5388 identifier ) ...": objc-methodprotolist in the first production may
5389 not start with a parenthesized identifier as a declarator of a data
5390 definition with no declaration specifiers if the objc-superclass,
5391 objc-protocol-refs and objc-class-instance-variables are omitted. */
5394 c_parser_objc_class_definition (c_parser
*parser
)
5399 if (c_parser_next_token_is_keyword (parser
, RID_AT_INTERFACE
))
5401 else if (c_parser_next_token_is_keyword (parser
, RID_AT_IMPLEMENTATION
))
5405 c_parser_consume_token (parser
);
5406 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5408 c_parser_error (parser
, "expected identifier");
5411 id1
= c_parser_peek_token (parser
)->value
;
5412 c_parser_consume_token (parser
);
5413 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
5416 tree proto
= NULL_TREE
;
5417 c_parser_consume_token (parser
);
5418 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5420 c_parser_error (parser
, "expected identifier");
5421 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5424 id2
= c_parser_peek_token (parser
)->value
;
5425 c_parser_consume_token (parser
);
5426 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
5429 objc_start_category_implementation (id1
, id2
);
5432 if (c_parser_next_token_is (parser
, CPP_LESS
))
5433 proto
= c_parser_objc_protocol_refs (parser
);
5434 objc_start_category_interface (id1
, id2
, proto
);
5435 c_parser_objc_methodprotolist (parser
);
5436 c_parser_require_keyword (parser
, RID_AT_END
, "expected %<@end%>");
5437 objc_finish_interface ();
5440 if (c_parser_next_token_is (parser
, CPP_COLON
))
5442 c_parser_consume_token (parser
);
5443 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5445 c_parser_error (parser
, "expected identifier");
5448 superclass
= c_parser_peek_token (parser
)->value
;
5449 c_parser_consume_token (parser
);
5452 superclass
= NULL_TREE
;
5455 tree proto
= NULL_TREE
;
5456 if (c_parser_next_token_is (parser
, CPP_LESS
))
5457 proto
= c_parser_objc_protocol_refs (parser
);
5458 objc_start_class_interface (id1
, superclass
, proto
);
5461 objc_start_class_implementation (id1
, superclass
);
5462 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
5463 c_parser_objc_class_instance_variables (parser
);
5466 objc_continue_interface ();
5467 c_parser_objc_methodprotolist (parser
);
5468 c_parser_require_keyword (parser
, RID_AT_END
, "expected %<@end%>");
5469 objc_finish_interface ();
5473 objc_continue_implementation ();
5478 /* Parse objc-class-instance-variables.
5480 objc-class-instance-variables:
5481 { objc-instance-variable-decl-list[opt] }
5483 objc-instance-variable-decl-list:
5484 objc-visibility-spec
5485 objc-instance-variable-decl ;
5487 objc-instance-variable-decl-list objc-visibility-spec
5488 objc-instance-variable-decl-list objc-instance-variable-decl ;
5489 objc-instance-variable-decl-list ;
5491 objc-visibility-spec:
5496 objc-instance-variable-decl:
5501 c_parser_objc_class_instance_variables (c_parser
*parser
)
5503 gcc_assert (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
));
5504 c_parser_consume_token (parser
);
5505 while (c_parser_next_token_is_not (parser
, CPP_EOF
))
5508 /* Parse any stray semicolon. */
5509 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
5512 pedwarn ("extra semicolon in struct or union specified");
5513 c_parser_consume_token (parser
);
5516 /* Stop if at the end of the instance variables. */
5517 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
5519 c_parser_consume_token (parser
);
5522 /* Parse any objc-visibility-spec. */
5523 if (c_parser_next_token_is_keyword (parser
, RID_AT_PRIVATE
))
5525 c_parser_consume_token (parser
);
5526 objc_set_visibility (2);
5529 else if (c_parser_next_token_is_keyword (parser
, RID_AT_PROTECTED
))
5531 c_parser_consume_token (parser
);
5532 objc_set_visibility (0);
5535 else if (c_parser_next_token_is_keyword (parser
, RID_AT_PUBLIC
))
5537 c_parser_consume_token (parser
);
5538 objc_set_visibility (1);
5541 /* Parse some comma-separated declarations. */
5542 decls
= c_parser_struct_declaration (parser
);
5544 /* Comma-separated instance variables are chained together in
5545 reverse order; add them one by one. */
5546 tree ivar
= nreverse (decls
);
5547 for (; ivar
; ivar
= TREE_CHAIN (ivar
))
5548 objc_add_instance_variable (copy_node (ivar
));
5550 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
5554 /* Parse an objc-class-declaration.
5556 objc-class-declaration:
5557 @class identifier-list ;
5561 c_parser_objc_class_declaration (c_parser
*parser
)
5563 tree list
= NULL_TREE
;
5564 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_AT_CLASS
));
5565 c_parser_consume_token (parser
);
5566 /* Any identifiers, including those declared as type names, are OK
5571 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5573 c_parser_error (parser
, "expected identifier");
5576 id
= c_parser_peek_token (parser
)->value
;
5577 list
= chainon (list
, build_tree_list (NULL_TREE
, id
));
5578 c_parser_consume_token (parser
);
5579 if (c_parser_next_token_is (parser
, CPP_COMMA
))
5580 c_parser_consume_token (parser
);
5584 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
5585 objc_declare_class (list
);
5588 /* Parse an objc-alias-declaration.
5590 objc-alias-declaration:
5591 @compatibility_alias identifier identifier ;
5595 c_parser_objc_alias_declaration (c_parser
*parser
)
5598 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_AT_ALIAS
));
5599 c_parser_consume_token (parser
);
5600 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5602 c_parser_error (parser
, "expected identifier");
5603 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, NULL
);
5606 id1
= c_parser_peek_token (parser
)->value
;
5607 c_parser_consume_token (parser
);
5608 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5610 c_parser_error (parser
, "expected identifier");
5611 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, NULL
);
5614 id2
= c_parser_peek_token (parser
)->value
;
5615 c_parser_consume_token (parser
);
5616 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
5617 objc_declare_alias (id1
, id2
);
5620 /* Parse an objc-protocol-definition.
5622 objc-protocol-definition:
5623 @protocol identifier objc-protocol-refs[opt] objc-methodprotolist @end
5624 @protocol identifier-list ;
5626 "@protocol identifier ;" should be resolved as "@protocol
5627 identifier-list ;": objc-methodprotolist may not start with a
5628 semicolon in the first alternative if objc-protocol-refs are
5632 c_parser_objc_protocol_definition (c_parser
*parser
)
5634 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_AT_PROTOCOL
));
5635 c_parser_consume_token (parser
);
5636 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5638 c_parser_error (parser
, "expected identifier");
5641 if (c_parser_peek_2nd_token (parser
)->type
== CPP_COMMA
5642 || c_parser_peek_2nd_token (parser
)->type
== CPP_SEMICOLON
)
5644 tree list
= NULL_TREE
;
5645 /* Any identifiers, including those declared as type names, are
5650 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5652 c_parser_error (parser
, "expected identifier");
5655 id
= c_parser_peek_token (parser
)->value
;
5656 list
= chainon (list
, build_tree_list (NULL_TREE
, id
));
5657 c_parser_consume_token (parser
);
5658 if (c_parser_next_token_is (parser
, CPP_COMMA
))
5659 c_parser_consume_token (parser
);
5663 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
5664 objc_declare_protocols (list
);
5668 tree id
= c_parser_peek_token (parser
)->value
;
5669 tree proto
= NULL_TREE
;
5670 c_parser_consume_token (parser
);
5671 if (c_parser_next_token_is (parser
, CPP_LESS
))
5672 proto
= c_parser_objc_protocol_refs (parser
);
5673 objc_pq_context
= 1;
5674 objc_start_protocol (id
, proto
);
5675 c_parser_objc_methodprotolist (parser
);
5676 c_parser_require_keyword (parser
, RID_AT_END
, "expected %<@end%>");
5677 objc_pq_context
= 0;
5678 objc_finish_interface ();
5682 /* Parse an objc-method-type.
5689 static enum tree_code
5690 c_parser_objc_method_type (c_parser
*parser
)
5692 switch (c_parser_peek_token (parser
)->type
)
5695 c_parser_consume_token (parser
);
5698 c_parser_consume_token (parser
);
5705 /* Parse an objc-method-definition.
5707 objc-method-definition:
5708 objc-method-type objc-method-decl ;[opt] compound-statement
5712 c_parser_objc_method_definition (c_parser
*parser
)
5714 enum tree_code type
= c_parser_objc_method_type (parser
);
5716 objc_set_method_type (type
);
5717 objc_pq_context
= 1;
5718 decl
= c_parser_objc_method_decl (parser
);
5719 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
5721 c_parser_consume_token (parser
);
5723 pedwarn ("extra semicolon in method definition specified");
5725 objc_pq_context
= 0;
5726 objc_start_method_definition (decl
);
5727 add_stmt (c_parser_compound_statement (parser
));
5728 objc_finish_method_definition (current_function_decl
);
5731 /* Parse an objc-methodprotolist.
5733 objc-methodprotolist:
5735 objc-methodprotolist objc-methodproto
5736 objc-methodprotolist declaration
5737 objc-methodprotolist ;
5739 The declaration is a data definition, which may be missing
5740 declaration specifiers under the same rules and diagnostics as
5741 other data definitions outside functions, and the stray semicolon
5742 is diagnosed the same way as a stray semicolon outside a
5746 c_parser_objc_methodprotolist (c_parser
*parser
)
5750 /* The list is terminated by @end. */
5751 switch (c_parser_peek_token (parser
)->type
)
5755 pedwarn ("ISO C does not allow extra %<;%> outside of a function");
5756 c_parser_consume_token (parser
);
5760 c_parser_objc_methodproto (parser
);
5765 if (c_parser_next_token_is_keyword (parser
, RID_AT_END
))
5767 c_parser_declaration_or_fndef (parser
, false, true, false, true);
5773 /* Parse an objc-methodproto.
5776 objc-method-type objc-method-decl ;
5780 c_parser_objc_methodproto (c_parser
*parser
)
5782 enum tree_code type
= c_parser_objc_method_type (parser
);
5784 objc_set_method_type (type
);
5785 /* Remember protocol qualifiers in prototypes. */
5786 objc_pq_context
= 1;
5787 decl
= c_parser_objc_method_decl (parser
);
5788 /* Forget protocol qualifiers here. */
5789 objc_pq_context
= 0;
5790 objc_add_method_declaration (decl
);
5791 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
5794 /* Parse an objc-method-decl.
5797 ( objc-type-name ) objc-selector
5799 ( objc-type-name ) objc-keyword-selector objc-optparmlist
5800 objc-keyword-selector objc-optparmlist
5802 objc-keyword-selector:
5804 objc-keyword-selector objc-keyword-decl
5807 objc-selector : ( objc-type-name ) identifier
5808 objc-selector : identifier
5809 : ( objc-type-name ) identifier
5813 objc-optparms objc-optellipsis
5817 objc-opt-parms , parameter-declaration
5825 c_parser_objc_method_decl (c_parser
*parser
)
5827 tree type
= NULL_TREE
;
5829 tree parms
= NULL_TREE
;
5830 bool ellipsis
= false;
5832 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
5834 c_parser_consume_token (parser
);
5835 type
= c_parser_objc_type_name (parser
);
5836 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
5838 sel
= c_parser_objc_selector (parser
);
5839 /* If there is no selector, or a colon follows, we have an
5840 objc-keyword-selector. If there is a selector, and a colon does
5841 not follow, that selector ends the objc-method-decl. */
5842 if (!sel
|| c_parser_next_token_is (parser
, CPP_COLON
))
5845 tree list
= NULL_TREE
;
5848 tree atype
= NULL_TREE
, id
, keyworddecl
;
5849 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
5851 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
5853 c_parser_consume_token (parser
);
5854 atype
= c_parser_objc_type_name (parser
);
5855 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5858 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5860 c_parser_error (parser
, "expected identifier");
5861 return error_mark_node
;
5863 id
= c_parser_peek_token (parser
)->value
;
5864 c_parser_consume_token (parser
);
5865 keyworddecl
= objc_build_keyword_decl (tsel
, atype
, id
);
5866 list
= chainon (list
, keyworddecl
);
5867 tsel
= c_parser_objc_selector (parser
);
5868 if (!tsel
&& c_parser_next_token_is_not (parser
, CPP_COLON
))
5871 /* Parse the optional parameter list. Optional Objective-C
5872 method parameters follow the C syntax, and may include '...'
5873 to denote a variable number of arguments. */
5874 parms
= make_node (TREE_LIST
);
5875 while (c_parser_next_token_is (parser
, CPP_COMMA
))
5877 struct c_parm
*parm
;
5878 c_parser_consume_token (parser
);
5879 if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
))
5882 c_parser_consume_token (parser
);
5885 parm
= c_parser_parameter_declaration (parser
, NULL_TREE
);
5888 parms
= chainon (parms
,
5889 build_tree_list (NULL_TREE
, grokparm (parm
)));
5893 return objc_build_method_signature (type
, sel
, parms
, ellipsis
);
5896 /* Parse an objc-type-name.
5899 objc-type-qualifiers[opt] type-name
5900 objc-type-qualifiers[opt]
5902 objc-type-qualifiers:
5904 objc-type-qualifiers objc-type-qualifier
5906 objc-type-qualifier: one of
5907 in out inout bycopy byref oneway
5911 c_parser_objc_type_name (c_parser
*parser
)
5913 tree quals
= NULL_TREE
;
5914 struct c_type_name
*typename
= NULL
;
5915 tree type
= NULL_TREE
;
5918 c_token
*token
= c_parser_peek_token (parser
);
5919 if (token
->type
== CPP_KEYWORD
5920 && (token
->keyword
== RID_IN
5921 || token
->keyword
== RID_OUT
5922 || token
->keyword
== RID_INOUT
5923 || token
->keyword
== RID_BYCOPY
5924 || token
->keyword
== RID_BYREF
5925 || token
->keyword
== RID_ONEWAY
))
5927 quals
= chainon (quals
, build_tree_list (NULL_TREE
, token
->value
));
5928 c_parser_consume_token (parser
);
5933 if (c_parser_next_token_starts_typename (parser
))
5934 typename
= c_parser_type_name (parser
);
5936 type
= groktypename (typename
);
5937 return build_tree_list (quals
, type
);
5940 /* Parse objc-protocol-refs.
5947 c_parser_objc_protocol_refs (c_parser
*parser
)
5949 tree list
= NULL_TREE
;
5950 gcc_assert (c_parser_next_token_is (parser
, CPP_LESS
));
5951 c_parser_consume_token (parser
);
5952 /* Any identifiers, including those declared as type names, are OK
5957 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5959 c_parser_error (parser
, "expected identifier");
5962 id
= c_parser_peek_token (parser
)->value
;
5963 list
= chainon (list
, build_tree_list (NULL_TREE
, id
));
5964 c_parser_consume_token (parser
);
5965 if (c_parser_next_token_is (parser
, CPP_COMMA
))
5966 c_parser_consume_token (parser
);
5970 c_parser_require (parser
, CPP_GREATER
, "expected %<>%>");
5974 /* Parse an objc-try-catch-statement.
5976 objc-try-catch-statement:
5977 @try compound-statement objc-catch-list[opt]
5978 @try compound-statement objc-catch-list[opt] @finally compound-statement
5981 @catch ( parameter-declaration ) compound-statement
5982 objc-catch-list @catch ( parameter-declaration ) compound-statement
5986 c_parser_objc_try_catch_statement (c_parser
*parser
)
5990 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_AT_TRY
));
5991 c_parser_consume_token (parser
);
5992 loc
= c_parser_peek_token (parser
)->location
;
5993 stmt
= c_parser_compound_statement (parser
);
5994 objc_begin_try_stmt (loc
, stmt
);
5995 while (c_parser_next_token_is_keyword (parser
, RID_AT_CATCH
))
5997 struct c_parm
*parm
;
5998 c_parser_consume_token (parser
);
5999 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
6001 parm
= c_parser_parameter_declaration (parser
, NULL_TREE
);
6004 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
6007 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
6008 objc_begin_catch_clause (grokparm (parm
));
6009 if (c_parser_require (parser
, CPP_OPEN_BRACE
, "expected %<{%>"))
6010 c_parser_compound_statement_nostart (parser
);
6011 objc_finish_catch_clause ();
6013 if (c_parser_next_token_is_keyword (parser
, RID_AT_FINALLY
))
6017 c_parser_consume_token (parser
);
6018 finloc
= c_parser_peek_token (parser
)->location
;
6019 finstmt
= c_parser_compound_statement (parser
);
6020 objc_build_finally_clause (finloc
, finstmt
);
6022 objc_finish_try_stmt ();
6025 /* Parse an objc-synchronized-statement.
6027 objc-synchronized-statement:
6028 @synchronized ( expression ) compound-statement
6032 c_parser_objc_synchronized_statement (c_parser
*parser
)
6036 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_AT_SYNCHRONIZED
));
6037 c_parser_consume_token (parser
);
6038 loc
= c_parser_peek_token (parser
)->location
;
6039 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
6041 expr
= c_parser_expression (parser
).value
;
6042 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
6045 expr
= error_mark_node
;
6046 stmt
= c_parser_compound_statement (parser
);
6047 objc_build_synchronized (loc
, expr
, stmt
);
6050 /* Parse an objc-selector; return NULL_TREE without an error if the
6051 next token is not an objc-selector.
6056 enum struct union if else while do for switch case default
6057 break continue return goto asm sizeof typeof __alignof
6058 unsigned long const short volatile signed restrict _Complex
6059 in out inout bycopy byref oneway int char float double void _Bool
6061 ??? Why this selection of keywords but not, for example, storage
6062 class specifiers? */
6065 c_parser_objc_selector (c_parser
*parser
)
6067 c_token
*token
= c_parser_peek_token (parser
);
6068 tree value
= token
->value
;
6069 if (token
->type
== CPP_NAME
)
6071 c_parser_consume_token (parser
);
6074 if (token
->type
!= CPP_KEYWORD
)
6076 switch (token
->keyword
)
6117 c_parser_consume_token (parser
);
6124 /* Parse an objc-selector-arg.
6128 objc-keywordname-list
6130 objc-keywordname-list:
6132 objc-keywordname-list objc-keywordname
6140 c_parser_objc_selector_arg (c_parser
*parser
)
6142 tree sel
= c_parser_objc_selector (parser
);
6143 tree list
= NULL_TREE
;
6144 if (sel
&& c_parser_next_token_is_not (parser
, CPP_COLON
))
6148 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
6150 list
= chainon (list
, build_tree_list (sel
, NULL_TREE
));
6151 sel
= c_parser_objc_selector (parser
);
6152 if (!sel
&& c_parser_next_token_is_not (parser
, CPP_COLON
))
6158 /* Parse an objc-receiver.
6167 c_parser_objc_receiver (c_parser
*parser
)
6169 if (c_parser_peek_token (parser
)->type
== CPP_NAME
6170 && (c_parser_peek_token (parser
)->id_kind
== C_ID_TYPENAME
6171 || c_parser_peek_token (parser
)->id_kind
== C_ID_CLASSNAME
))
6173 tree id
= c_parser_peek_token (parser
)->value
;
6174 c_parser_consume_token (parser
);
6175 return objc_get_class_reference (id
);
6177 return c_parser_expression (parser
).value
;
6180 /* Parse objc-message-args.
6184 objc-keywordarg-list
6186 objc-keywordarg-list:
6188 objc-keywordarg-list objc-keywordarg
6191 objc-selector : objc-keywordexpr
6196 c_parser_objc_message_args (c_parser
*parser
)
6198 tree sel
= c_parser_objc_selector (parser
);
6199 tree list
= NULL_TREE
;
6200 if (sel
&& c_parser_next_token_is_not (parser
, CPP_COLON
))
6205 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
6207 keywordexpr
= c_parser_objc_keywordexpr (parser
);
6208 list
= chainon (list
, build_tree_list (sel
, keywordexpr
));
6209 sel
= c_parser_objc_selector (parser
);
6210 if (!sel
&& c_parser_next_token_is_not (parser
, CPP_COLON
))
6216 /* Parse an objc-keywordexpr.
6223 c_parser_objc_keywordexpr (c_parser
*parser
)
6225 tree list
= c_parser_expr_list (parser
, true);
6226 if (TREE_CHAIN (list
) == NULL_TREE
)
6228 /* Just return the expression, remove a level of
6230 return TREE_VALUE (list
);
6234 /* We have a comma expression, we will collapse later. */
6240 /* The actual parser and external interface. ??? Does this need to be
6241 garbage-collected? */
6243 static GTY (()) c_parser
*the_parser
;
6245 /* Parse a single source file. */
6250 the_parser
= c_parser_new ();
6251 c_parser_translation_unit (the_parser
);
6255 #include "gt-c-parser.h"