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, 59 Temple Place - Suite 330, 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
.value
= default_function_array_conversion (ret
.value
);
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
).value
;
3042 next
= default_function_array_conversion (next
);
3043 rec
= build_compound_expr (rec
, next
);
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
.value
= default_function_array_conversion (init
.value
);
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
;
3993 tree name
, str
, expr
;
3994 if (c_parser_next_token_is (parser
, CPP_OPEN_SQUARE
))
3996 c_parser_consume_token (parser
);
3997 if (c_parser_next_token_is (parser
, CPP_NAME
))
3999 tree id
= c_parser_peek_token (parser
)->value
;
4000 c_parser_consume_token (parser
);
4001 name
= build_string (IDENTIFIER_LENGTH (id
),
4002 IDENTIFIER_POINTER (id
));
4006 c_parser_error (parser
, "expected identifier");
4007 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
, NULL
);
4010 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
4015 str
= c_parser_asm_string_literal (parser
);
4016 if (str
== NULL_TREE
)
4018 c_lex_string_translate
= 1;
4019 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
4021 c_lex_string_translate
= 0;
4024 expr
= c_parser_expression (parser
).value
;
4026 expr
= default_function_array_conversion (expr
);
4027 c_lex_string_translate
= 0;
4028 if (!c_parser_require (parser
, CPP_CLOSE_PAREN
, "expected %<)%>"))
4030 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
4033 list
= chainon (list
, build_tree_list (build_tree_list (name
, str
),
4035 if (c_parser_next_token_is (parser
, CPP_COMMA
))
4036 c_parser_consume_token (parser
);
4043 /* Parse asm clobbers, a GNU extension.
4047 asm-clobbers , asm-string-literal
4051 c_parser_asm_clobbers (c_parser
*parser
)
4053 tree list
= NULL_TREE
;
4056 tree str
= c_parser_asm_string_literal (parser
);
4058 list
= tree_cons (NULL_TREE
, str
, list
);
4061 if (c_parser_next_token_is (parser
, CPP_COMMA
))
4062 c_parser_consume_token (parser
);
4069 /* Parse an expression other than a compound expression; that is, an
4070 assignment expression (C90 6.3.16, C99 6.5.16). If AFTER is not
4071 NULL then it is an Objective-C message expression which is the
4072 primary-expression starting the expression as an initializer.
4074 assignment-expression:
4075 conditional-expression
4076 unary-expression assignment-operator assignment-expression
4078 assignment-operator: one of
4079 = *= /= %= += -= <<= >>= &= ^= |=
4081 In GNU C we accept any conditional expression on the LHS and
4082 diagnose the invalid lvalue rather than producing a syntax
4085 static struct c_expr
4086 c_parser_expr_no_commas (c_parser
*parser
, struct c_expr
*after
)
4088 struct c_expr lhs
, rhs
, ret
;
4089 enum tree_code code
;
4090 gcc_assert (!after
|| c_dialect_objc ());
4091 lhs
= c_parser_conditional_expression (parser
, after
);
4092 switch (c_parser_peek_token (parser
)->type
)
4101 code
= TRUNC_DIV_EXPR
;
4104 code
= TRUNC_MOD_EXPR
;
4119 code
= BIT_AND_EXPR
;
4122 code
= BIT_XOR_EXPR
;
4125 code
= BIT_IOR_EXPR
;
4130 c_parser_consume_token (parser
);
4131 rhs
= c_parser_expr_no_commas (parser
, NULL
);
4132 rhs
.value
= default_function_array_conversion (rhs
.value
);
4133 ret
.value
= build_modify_expr (lhs
.value
, code
, rhs
.value
);
4134 if (code
== NOP_EXPR
)
4135 ret
.original_code
= MODIFY_EXPR
;
4138 TREE_NO_WARNING (ret
.value
) = 1;
4139 ret
.original_code
= ERROR_MARK
;
4144 /* Parse a conditional expression (C90 6.3.15, C99 6.5.15). If AFTER
4145 is not NULL then it is an Objective-C message expression which is
4146 the primary-expression starting the expression as an initializer.
4148 conditional-expression:
4149 logical-OR-expression
4150 logical-OR-expression ? expression : conditional-expression
4154 conditional-expression:
4155 logical-OR-expression ? : conditional-expression
4158 static struct c_expr
4159 c_parser_conditional_expression (c_parser
*parser
, struct c_expr
*after
)
4161 struct c_expr cond
, exp1
, exp2
, ret
;
4162 gcc_assert (!after
|| c_dialect_objc ());
4163 cond
= c_parser_binary_expression (parser
, after
);
4164 if (c_parser_next_token_is_not (parser
, CPP_QUERY
))
4166 cond
.value
= default_function_array_conversion (cond
.value
);
4167 c_parser_consume_token (parser
);
4168 if (c_parser_next_token_is (parser
, CPP_COLON
))
4171 pedwarn ("ISO C forbids omitting the middle term of a ?: expression");
4172 /* Make sure first operand is calculated only once. */
4173 exp1
.value
= save_expr (default_conversion (cond
.value
));
4174 cond
.value
= c_objc_common_truthvalue_conversion (exp1
.value
);
4175 skip_evaluation
+= cond
.value
== truthvalue_true_node
;
4180 = c_objc_common_truthvalue_conversion
4181 (default_conversion (cond
.value
));
4182 skip_evaluation
+= cond
.value
== truthvalue_false_node
;
4183 exp1
= c_parser_expression_conv (parser
);
4184 skip_evaluation
+= ((cond
.value
== truthvalue_true_node
)
4185 - (cond
.value
== truthvalue_false_node
));
4187 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
4189 skip_evaluation
-= cond
.value
== truthvalue_true_node
;
4190 ret
.value
= error_mark_node
;
4191 ret
.original_code
= ERROR_MARK
;
4194 exp2
= c_parser_conditional_expression (parser
, NULL
);
4195 exp2
.value
= default_function_array_conversion (exp2
.value
);
4196 skip_evaluation
-= cond
.value
== truthvalue_true_node
;
4197 ret
.value
= build_conditional_expr (cond
.value
, exp1
.value
, exp2
.value
);
4198 ret
.original_code
= ERROR_MARK
;
4202 /* Parse a binary expression; that is, a logical-OR-expression (C90
4203 6.3.5-6.3.14, C99 6.5.5-6.5.14). If AFTER is not NULL then it is
4204 an Objective-C message expression which is the primary-expression
4205 starting the expression as an initializer.
4207 multiplicative-expression:
4209 multiplicative-expression * cast-expression
4210 multiplicative-expression / cast-expression
4211 multiplicative-expression % cast-expression
4213 additive-expression:
4214 multiplicative-expression
4215 additive-expression + multiplicative-expression
4216 additive-expression - multiplicative-expression
4220 shift-expression << additive-expression
4221 shift-expression >> additive-expression
4223 relational-expression:
4225 relational-expression < shift-expression
4226 relational-expression > shift-expression
4227 relational-expression <= shift-expression
4228 relational-expression >= shift-expression
4230 equality-expression:
4231 relational-expression
4232 equality-expression == relational-expression
4233 equality-expression != relational-expression
4237 AND-expression & equality-expression
4239 exclusive-OR-expression:
4241 exclusive-OR-expression ^ AND-expression
4243 inclusive-OR-expression:
4244 exclusive-OR-expression
4245 inclusive-OR-expression | exclusive-OR-expression
4247 logical-AND-expression:
4248 inclusive-OR-expression
4249 logical-AND-expression && inclusive-OR-expression
4251 logical-OR-expression:
4252 logical-AND-expression
4253 logical-OR-expression || logical-AND-expression
4256 static struct c_expr
4257 c_parser_binary_expression (c_parser
*parser
, struct c_expr
*after
)
4259 /* A binary expression is parsed using operator-precedence parsing,
4260 with the operands being cast expressions. All the binary
4261 operators are left-associative. Thus a binary expression is of
4264 E0 op1 E1 op2 E2 ...
4266 which we represent on a stack. On the stack, the precedence
4267 levels are strictly increasing. When a new operator is
4268 encountered of higher precedence than that at the top of the
4269 stack, it is pushed; its LHS is the top expression, and its RHS
4270 is everything parsed until it is popped. When a new operator is
4271 encountered with precedence less than or equal to that at the top
4272 of the stack, triples E[i-1] op[i] E[i] are popped and replaced
4273 by the result of the operation until the operator at the top of
4274 the stack has lower precedence than the new operator or there is
4275 only one element on the stack; then the top expression is the LHS
4276 of the new operator. In the case of logical AND and OR
4277 expressions, we also need to adjust skip_evaluation as
4278 appropriate when the operators are pushed and popped. */
4280 /* The precedence levels, where 0 is a dummy lowest level used for
4281 the bottom of the stack. */
4297 /* The expression at this stack level. */
4299 /* The precedence of the operator on its left, PREC_NONE at the
4300 bottom of the stack. */
4302 /* The operation on its left. */
4308 switch (stack[sp].op) \
4310 case TRUTH_ANDIF_EXPR: \
4311 skip_evaluation -= stack[sp - 1].expr.value == truthvalue_false_node; \
4313 case TRUTH_ORIF_EXPR: \
4314 skip_evaluation -= stack[sp - 1].expr.value == truthvalue_true_node; \
4319 stack[sp - 1].expr.value \
4320 = default_function_array_conversion (stack[sp - 1].expr.value); \
4321 stack[sp].expr.value \
4322 = default_function_array_conversion (stack[sp].expr.value); \
4323 stack[sp - 1].expr = parser_build_binary_op (stack[sp].op, \
4324 stack[sp - 1].expr, \
4328 gcc_assert (!after
|| c_dialect_objc ());
4329 stack
[0].expr
= c_parser_cast_expression (parser
, after
);
4330 stack
[0].prec
= PREC_NONE
;
4335 enum tree_code ocode
;
4338 switch (c_parser_peek_token (parser
)->type
)
4346 ocode
= TRUNC_DIV_EXPR
;
4350 ocode
= TRUNC_MOD_EXPR
;
4362 ocode
= LSHIFT_EXPR
;
4366 ocode
= RSHIFT_EXPR
;
4380 case CPP_GREATER_EQ
:
4393 oprec
= PREC_BITAND
;
4394 ocode
= BIT_AND_EXPR
;
4397 oprec
= PREC_BITXOR
;
4398 ocode
= BIT_XOR_EXPR
;
4402 ocode
= BIT_IOR_EXPR
;
4405 oprec
= PREC_LOGAND
;
4406 ocode
= TRUTH_ANDIF_EXPR
;
4410 ocode
= TRUTH_ORIF_EXPR
;
4413 /* Not a binary operator, so end of the binary
4417 c_parser_consume_token (parser
);
4418 while (oprec
<= stack
[sp
].prec
)
4422 case TRUTH_ANDIF_EXPR
:
4423 stack
[sp
].expr
.value
4424 = default_function_array_conversion (stack
[sp
].expr
.value
);
4425 stack
[sp
].expr
.value
= c_objc_common_truthvalue_conversion
4426 (default_conversion (stack
[sp
].expr
.value
));
4427 skip_evaluation
+= stack
[sp
].expr
.value
== truthvalue_false_node
;
4429 case TRUTH_ORIF_EXPR
:
4430 stack
[sp
].expr
.value
4431 = default_function_array_conversion (stack
[sp
].expr
.value
);
4432 stack
[sp
].expr
.value
= c_objc_common_truthvalue_conversion
4433 (default_conversion (stack
[sp
].expr
.value
));
4434 skip_evaluation
+= stack
[sp
].expr
.value
== truthvalue_true_node
;
4440 stack
[sp
].expr
= c_parser_cast_expression (parser
, NULL
);
4441 stack
[sp
].prec
= oprec
;
4442 stack
[sp
].op
= ocode
;
4447 return stack
[0].expr
;
4451 /* Parse a cast expression (C90 6.3.4, C99 6.5.4). If AFTER is not
4452 NULL then it is an Objective-C message expression which is the
4453 primary-expression starting the expression as an initializer.
4457 ( type-name ) unary-expression
4460 static struct c_expr
4461 c_parser_cast_expression (c_parser
*parser
, struct c_expr
*after
)
4463 gcc_assert (!after
|| c_dialect_objc ());
4465 return c_parser_postfix_expression_after_primary (parser
, *after
);
4466 /* If the expression begins with a parenthesized type name, it may
4467 be either a cast or a compound literal; we need to see whether
4468 the next character is '{' to tell the difference. If not, it is
4469 an unary expression. */
4470 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
)
4471 && c_token_starts_typename (c_parser_peek_2nd_token (parser
)))
4473 struct c_type_name
*type_name
;
4476 c_parser_consume_token (parser
);
4477 type_name
= c_parser_type_name (parser
);
4478 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
4479 if (type_name
== NULL
)
4481 ret
.value
= error_mark_node
;
4482 ret
.original_code
= ERROR_MARK
;
4485 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
4486 return c_parser_postfix_expression_after_paren_type (parser
,
4488 expr
= c_parser_cast_expression (parser
, NULL
).value
;
4489 expr
= default_function_array_conversion (expr
);
4490 ret
.value
= c_cast_expr (type_name
, expr
);
4491 ret
.original_code
= ERROR_MARK
;
4495 return c_parser_unary_expression (parser
);
4498 /* Parse an unary expression (C90 6.3.3, C99 6.5.3).
4504 unary-operator cast-expression
4505 sizeof unary-expression
4506 sizeof ( type-name )
4508 unary-operator: one of
4514 __alignof__ unary-expression
4515 __alignof__ ( type-name )
4518 unary-operator: one of
4519 __extension__ __real__ __imag__
4521 In addition, the GNU syntax treats ++ and -- as unary operators, so
4522 they may be applied to cast expressions with errors for non-lvalues
4525 static struct c_expr
4526 c_parser_unary_expression (c_parser
*parser
)
4529 struct c_expr ret
, op
;
4530 switch (c_parser_peek_token (parser
)->type
)
4533 c_parser_consume_token (parser
);
4534 op
= c_parser_cast_expression (parser
, NULL
);
4535 op
.value
= default_function_array_conversion (op
.value
);
4536 return parser_build_unary_op (PREINCREMENT_EXPR
, op
);
4537 case CPP_MINUS_MINUS
:
4538 c_parser_consume_token (parser
);
4539 op
= c_parser_cast_expression (parser
, NULL
);
4540 op
.value
= default_function_array_conversion (op
.value
);
4541 return parser_build_unary_op (PREDECREMENT_EXPR
, op
);
4543 c_parser_consume_token (parser
);
4544 return parser_build_unary_op (ADDR_EXPR
,
4545 c_parser_cast_expression (parser
, NULL
));
4547 c_parser_consume_token (parser
);
4548 op
= c_parser_cast_expression (parser
, NULL
);
4549 op
.value
= default_function_array_conversion (op
.value
);
4550 ret
.value
= build_indirect_ref (op
.value
, "unary *");
4551 ret
.original_code
= ERROR_MARK
;
4554 c_parser_consume_token (parser
);
4555 if (!c_dialect_objc () && !in_system_header
)
4556 warning (OPT_Wtraditional
,
4557 "traditional C rejects the unary plus operator");
4558 op
= c_parser_cast_expression (parser
, NULL
);
4559 op
.value
= default_function_array_conversion (op
.value
);
4560 return parser_build_unary_op (CONVERT_EXPR
, op
);
4562 c_parser_consume_token (parser
);
4563 op
= c_parser_cast_expression (parser
, NULL
);
4564 op
.value
= default_function_array_conversion (op
.value
);
4565 return parser_build_unary_op (NEGATE_EXPR
, op
);
4567 c_parser_consume_token (parser
);
4568 op
= c_parser_cast_expression (parser
, NULL
);
4569 op
.value
= default_function_array_conversion (op
.value
);
4570 return parser_build_unary_op (BIT_NOT_EXPR
, op
);
4572 c_parser_consume_token (parser
);
4573 op
= c_parser_cast_expression (parser
, NULL
);
4574 op
.value
= default_function_array_conversion (op
.value
);
4575 return parser_build_unary_op (TRUTH_NOT_EXPR
, op
);
4577 /* Refer to the address of a label as a pointer. */
4578 c_parser_consume_token (parser
);
4579 if (c_parser_next_token_is (parser
, CPP_NAME
))
4581 ret
.value
= finish_label_address_expr
4582 (c_parser_peek_token (parser
)->value
);
4583 c_parser_consume_token (parser
);
4587 c_parser_error (parser
, "expected identifier");
4588 ret
.value
= error_mark_node
;
4590 ret
.original_code
= ERROR_MARK
;
4593 switch (c_parser_peek_token (parser
)->keyword
)
4596 return c_parser_sizeof_expression (parser
);
4598 return c_parser_alignof_expression (parser
);
4600 c_parser_consume_token (parser
);
4601 ext
= disable_extension_diagnostics ();
4602 ret
= c_parser_cast_expression (parser
, NULL
);
4603 restore_extension_diagnostics (ext
);
4606 c_parser_consume_token (parser
);
4607 op
= c_parser_cast_expression (parser
, NULL
);
4608 op
.value
= default_function_array_conversion (op
.value
);
4609 return parser_build_unary_op (REALPART_EXPR
, op
);
4611 c_parser_consume_token (parser
);
4612 op
= c_parser_cast_expression (parser
, NULL
);
4613 op
.value
= default_function_array_conversion (op
.value
);
4614 return parser_build_unary_op (IMAGPART_EXPR
, op
);
4616 return c_parser_postfix_expression (parser
);
4619 return c_parser_postfix_expression (parser
);
4623 /* Parse a sizeof expression. */
4625 static struct c_expr
4626 c_parser_sizeof_expression (c_parser
*parser
)
4629 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_SIZEOF
));
4630 c_parser_consume_token (parser
);
4633 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
)
4634 && c_token_starts_typename (c_parser_peek_2nd_token (parser
)))
4636 /* Either sizeof ( type-name ) or sizeof unary-expression
4637 starting with a compound literal. */
4638 struct c_type_name
*type_name
;
4639 c_parser_consume_token (parser
);
4640 type_name
= c_parser_type_name (parser
);
4641 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
4642 if (type_name
== NULL
)
4647 ret
.value
= error_mark_node
;
4648 ret
.original_code
= ERROR_MARK
;
4651 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
4653 expr
= c_parser_postfix_expression_after_paren_type (parser
,
4657 /* sizeof ( type-name ). */
4660 return c_expr_sizeof_type (type_name
);
4664 expr
= c_parser_unary_expression (parser
);
4668 if (TREE_CODE (expr
.value
) == COMPONENT_REF
4669 && DECL_C_BIT_FIELD (TREE_OPERAND (expr
.value
, 1)))
4670 error ("%<sizeof%> applied to a bit-field");
4671 return c_expr_sizeof_expr (expr
);
4675 /* Parse an alignof expression. */
4677 static struct c_expr
4678 c_parser_alignof_expression (c_parser
*parser
)
4681 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_ALIGNOF
));
4682 c_parser_consume_token (parser
);
4685 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
)
4686 && c_token_starts_typename (c_parser_peek_2nd_token (parser
)))
4688 /* Either __alignof__ ( type-name ) or __alignof__
4689 unary-expression starting with a compound literal. */
4690 struct c_type_name
*type_name
;
4692 c_parser_consume_token (parser
);
4693 type_name
= c_parser_type_name (parser
);
4694 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
4695 if (type_name
== NULL
)
4700 ret
.value
= error_mark_node
;
4701 ret
.original_code
= ERROR_MARK
;
4704 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
4706 expr
= c_parser_postfix_expression_after_paren_type (parser
,
4710 /* alignof ( type-name ). */
4713 ret
.value
= c_alignof (groktypename (type_name
));
4714 ret
.original_code
= ERROR_MARK
;
4720 expr
= c_parser_unary_expression (parser
);
4724 ret
.value
= c_alignof_expr (expr
.value
);
4725 ret
.original_code
= ERROR_MARK
;
4730 /* Parse a postfix expression (C90 6.3.1-6.3.2, C99 6.5.1-6.5.2).
4734 postfix-expression [ expression ]
4735 postfix-expression ( argument-expression-list[opt] )
4736 postfix-expression . identifier
4737 postfix-expression -> identifier
4738 postfix-expression ++
4739 postfix-expression --
4740 ( type-name ) { initializer-list }
4741 ( type-name ) { initializer-list , }
4743 argument-expression-list:
4745 argument-expression-list , argument-expression
4757 (treated as a keyword in GNU C)
4760 ( compound-statement )
4761 __builtin_va_arg ( assignment-expression , type-name )
4762 __builtin_offsetof ( type-name , offsetof-member-designator )
4763 __builtin_choose_expr ( assignment-expression ,
4764 assignment-expression ,
4765 assignment-expression )
4766 __builtin_types_compatible_p ( type-name , type-name )
4768 offsetof-member-designator:
4770 offsetof-member-designator . identifier
4771 offsetof-member-designator [ expression ]
4776 [ objc-receiver objc-message-args ]
4777 @selector ( objc-selector-arg )
4778 @protocol ( identifier )
4779 @encode ( type-name )
4783 static struct c_expr
4784 c_parser_postfix_expression (c_parser
*parser
)
4786 struct c_expr expr
, e1
, e2
, e3
;
4787 struct c_type_name
*t1
, *t2
;
4788 switch (c_parser_peek_token (parser
)->type
)
4793 expr
.value
= c_parser_peek_token (parser
)->value
;
4794 expr
.original_code
= ERROR_MARK
;
4795 c_parser_consume_token (parser
);
4799 expr
.value
= c_parser_peek_token (parser
)->value
;
4800 expr
.original_code
= STRING_CST
;
4801 c_parser_consume_token (parser
);
4803 case CPP_OBJC_STRING
:
4804 gcc_assert (c_dialect_objc ());
4806 = objc_build_string_object (c_parser_peek_token (parser
)->value
);
4807 expr
.original_code
= ERROR_MARK
;
4808 c_parser_consume_token (parser
);
4811 if (c_parser_peek_token (parser
)->id_kind
!= C_ID_ID
)
4813 c_parser_error (parser
, "expected expression");
4814 expr
.value
= error_mark_node
;
4815 expr
.original_code
= ERROR_MARK
;
4819 tree id
= c_parser_peek_token (parser
)->value
;
4820 location_t loc
= c_parser_peek_token (parser
)->location
;
4821 c_parser_consume_token (parser
);
4822 expr
.value
= build_external_ref (id
,
4823 (c_parser_peek_token (parser
)->type
4824 == CPP_OPEN_PAREN
), loc
);
4825 expr
.original_code
= ERROR_MARK
;
4828 case CPP_OPEN_PAREN
:
4829 /* A parenthesized expression, statement expression or compound
4831 if (c_parser_peek_2nd_token (parser
)->type
== CPP_OPEN_BRACE
)
4833 /* A statement expression. */
4835 c_parser_consume_token (parser
);
4836 c_parser_consume_token (parser
);
4837 if (cur_stmt_list
== NULL
)
4839 error ("braced-group within expression allowed "
4840 "only inside a function");
4841 parser
->error
= true;
4842 c_parser_skip_until_found (parser
, CPP_CLOSE_BRACE
, NULL
);
4843 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
4844 expr
.value
= error_mark_node
;
4845 expr
.original_code
= ERROR_MARK
;
4848 stmt
= c_begin_stmt_expr ();
4849 c_parser_compound_statement_nostart (parser
);
4850 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
4853 pedwarn ("ISO C forbids braced-groups within expressions");
4854 expr
.value
= c_finish_stmt_expr (stmt
);
4855 expr
.original_code
= ERROR_MARK
;
4857 else if (c_token_starts_typename (c_parser_peek_2nd_token (parser
)))
4859 /* A compound literal. ??? Can we actually get here rather
4860 than going directly to
4861 c_parser_postfix_expression_after_paren_type from
4863 struct c_type_name
*type_name
;
4864 c_parser_consume_token (parser
);
4865 type_name
= c_parser_type_name (parser
);
4866 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
4868 if (type_name
== NULL
)
4870 expr
.value
= error_mark_node
;
4871 expr
.original_code
= ERROR_MARK
;
4874 expr
= c_parser_postfix_expression_after_paren_type (parser
,
4879 /* A parenthesized expression. */
4880 c_parser_consume_token (parser
);
4881 expr
= c_parser_expression (parser
);
4882 if (TREE_CODE (expr
.value
) == MODIFY_EXPR
)
4883 TREE_NO_WARNING (expr
.value
) = 1;
4884 expr
.original_code
= ERROR_MARK
;
4885 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
4890 switch (c_parser_peek_token (parser
)->keyword
)
4892 case RID_FUNCTION_NAME
:
4893 case RID_PRETTY_FUNCTION_NAME
:
4894 case RID_C99_FUNCTION_NAME
:
4895 expr
.value
= fname_decl (c_parser_peek_token (parser
)->keyword
,
4896 c_parser_peek_token (parser
)->value
);
4897 expr
.original_code
= ERROR_MARK
;
4898 c_parser_consume_token (parser
);
4901 c_parser_consume_token (parser
);
4902 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
4904 expr
.value
= error_mark_node
;
4905 expr
.original_code
= ERROR_MARK
;
4908 e1
= c_parser_expr_no_commas (parser
, NULL
);
4909 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
4911 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
4912 expr
.value
= error_mark_node
;
4913 expr
.original_code
= ERROR_MARK
;
4916 t1
= c_parser_type_name (parser
);
4917 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
4921 expr
.value
= error_mark_node
;
4922 expr
.original_code
= ERROR_MARK
;
4926 expr
.value
= build_va_arg (e1
.value
, groktypename (t1
));
4927 expr
.original_code
= ERROR_MARK
;
4931 c_parser_consume_token (parser
);
4932 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
4934 expr
.value
= error_mark_node
;
4935 expr
.original_code
= ERROR_MARK
;
4938 t1
= c_parser_type_name (parser
);
4941 expr
.value
= error_mark_node
;
4942 expr
.original_code
= ERROR_MARK
;
4945 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
4947 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
4948 expr
.value
= error_mark_node
;
4949 expr
.original_code
= ERROR_MARK
;
4953 tree type
= groktypename (t1
);
4955 if (type
== error_mark_node
)
4956 offsetof_ref
= error_mark_node
;
4958 offsetof_ref
= build1 (INDIRECT_REF
, type
, NULL
);
4959 /* Parse the second argument to __builtin_offsetof. We
4960 must have one identifier, and beyond that we want to
4961 accept sub structure and sub array references. */
4962 if (c_parser_next_token_is (parser
, CPP_NAME
))
4964 offsetof_ref
= build_component_ref
4965 (offsetof_ref
, c_parser_peek_token (parser
)->value
);
4966 c_parser_consume_token (parser
);
4967 while (c_parser_next_token_is (parser
, CPP_DOT
)
4968 || c_parser_next_token_is (parser
,
4971 if (c_parser_next_token_is (parser
, CPP_DOT
))
4973 c_parser_consume_token (parser
);
4974 if (c_parser_next_token_is_not (parser
,
4977 c_parser_error (parser
, "expected identifier");
4980 offsetof_ref
= build_component_ref
4982 c_parser_peek_token (parser
)->value
);
4983 c_parser_consume_token (parser
);
4988 c_parser_consume_token (parser
);
4989 idx
= c_parser_expression (parser
).value
;
4990 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
4992 offsetof_ref
= build_array_ref (offsetof_ref
, idx
);
4997 c_parser_error (parser
, "expected identifier");
4998 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5000 expr
.value
= fold_offsetof (offsetof_ref
);
5001 expr
.original_code
= ERROR_MARK
;
5004 case RID_CHOOSE_EXPR
:
5005 c_parser_consume_token (parser
);
5006 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
5008 expr
.value
= error_mark_node
;
5009 expr
.original_code
= ERROR_MARK
;
5012 e1
= c_parser_expr_no_commas (parser
, NULL
);
5013 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
5015 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5016 expr
.value
= error_mark_node
;
5017 expr
.original_code
= ERROR_MARK
;
5020 e2
= c_parser_expr_no_commas (parser
, NULL
);
5021 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
5023 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5024 expr
.value
= error_mark_node
;
5025 expr
.original_code
= ERROR_MARK
;
5028 e3
= c_parser_expr_no_commas (parser
, NULL
);
5029 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5034 c
= fold (e1
.value
);
5035 if (TREE_CODE (c
) != INTEGER_CST
)
5036 error ("first argument to %<__builtin_choose_expr%> not"
5038 expr
= integer_zerop (c
) ? e3
: e2
;
5041 case RID_TYPES_COMPATIBLE_P
:
5042 c_parser_consume_token (parser
);
5043 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
5045 expr
.value
= error_mark_node
;
5046 expr
.original_code
= ERROR_MARK
;
5049 t1
= c_parser_type_name (parser
);
5052 expr
.value
= error_mark_node
;
5053 expr
.original_code
= ERROR_MARK
;
5056 if (!c_parser_require (parser
, CPP_COMMA
, "expected %<,%>"))
5058 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5059 expr
.value
= error_mark_node
;
5060 expr
.original_code
= ERROR_MARK
;
5063 t2
= c_parser_type_name (parser
);
5066 expr
.value
= error_mark_node
;
5067 expr
.original_code
= ERROR_MARK
;
5070 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5075 e1
= TYPE_MAIN_VARIANT (groktypename (t1
));
5076 e2
= TYPE_MAIN_VARIANT (groktypename (t2
));
5078 expr
.value
= comptypes (e1
, e2
)
5079 ? build_int_cst (NULL_TREE
, 1)
5080 : build_int_cst (NULL_TREE
, 0);
5081 expr
.original_code
= ERROR_MARK
;
5084 case RID_AT_SELECTOR
:
5085 gcc_assert (c_dialect_objc ());
5086 c_parser_consume_token (parser
);
5087 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
5089 expr
.value
= error_mark_node
;
5090 expr
.original_code
= ERROR_MARK
;
5094 tree sel
= c_parser_objc_selector_arg (parser
);
5095 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5097 expr
.value
= objc_build_selector_expr (sel
);
5098 expr
.original_code
= ERROR_MARK
;
5101 case RID_AT_PROTOCOL
:
5102 gcc_assert (c_dialect_objc ());
5103 c_parser_consume_token (parser
);
5104 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
5106 expr
.value
= error_mark_node
;
5107 expr
.original_code
= ERROR_MARK
;
5110 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5112 c_parser_error (parser
, "expected identifier");
5113 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5114 expr
.value
= error_mark_node
;
5115 expr
.original_code
= ERROR_MARK
;
5119 tree id
= c_parser_peek_token (parser
)->value
;
5120 c_parser_consume_token (parser
);
5121 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5123 expr
.value
= objc_build_protocol_expr (id
);
5124 expr
.original_code
= ERROR_MARK
;
5128 /* Extension to support C-structures in the archiver. */
5129 gcc_assert (c_dialect_objc ());
5130 c_parser_consume_token (parser
);
5131 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
5133 expr
.value
= error_mark_node
;
5134 expr
.original_code
= ERROR_MARK
;
5137 t1
= c_parser_type_name (parser
);
5140 expr
.value
= error_mark_node
;
5141 expr
.original_code
= ERROR_MARK
;
5142 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5145 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5148 tree type
= groktypename (t1
);
5149 expr
.value
= objc_build_encode_expr (type
);
5150 expr
.original_code
= ERROR_MARK
;
5154 c_parser_error (parser
, "expected expression");
5155 expr
.value
= error_mark_node
;
5156 expr
.original_code
= ERROR_MARK
;
5160 case CPP_OPEN_SQUARE
:
5161 if (c_dialect_objc ())
5163 tree receiver
, args
;
5164 c_parser_consume_token (parser
);
5165 receiver
= c_parser_objc_receiver (parser
);
5166 args
= c_parser_objc_message_args (parser
);
5167 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
5169 expr
.value
= objc_build_message_expr (build_tree_list (receiver
,
5171 expr
.original_code
= ERROR_MARK
;
5174 /* Else fall through to report error. */
5176 c_parser_error (parser
, "expected expression");
5177 expr
.value
= error_mark_node
;
5178 expr
.original_code
= ERROR_MARK
;
5181 return c_parser_postfix_expression_after_primary (parser
, expr
);
5184 /* Parse a postfix expression after a parenthesized type name: the
5185 brace-enclosed initializer of a compound literal, possibly followed
5186 by some postfix operators. This is separate because it is not
5187 possible to tell until after the type name whether a cast
5188 expression has a cast or a compound literal, or whether the operand
5189 of sizeof is a parenthesized type name or starts with a compound
5192 static struct c_expr
5193 c_parser_postfix_expression_after_paren_type (c_parser
*parser
,
5194 struct c_type_name
*type_name
)
5199 start_init (NULL_TREE
, NULL
, 0);
5200 type
= groktypename (type_name
);
5201 if (C_TYPE_VARIABLE_SIZE (type
))
5203 error ("compound literal has variable size");
5204 type
= error_mark_node
;
5206 init
= c_parser_braced_init (parser
, type
, false);
5208 maybe_warn_string_init (type
, init
);
5210 if (pedantic
&& !flag_isoc99
)
5211 pedwarn ("ISO C90 forbids compound literals");
5212 expr
.value
= build_compound_literal (type
, init
.value
);
5213 expr
.original_code
= ERROR_MARK
;
5214 return c_parser_postfix_expression_after_primary (parser
, expr
);
5217 /* Parse a postfix expression after the initial primary or compound
5218 literal; that is, parse a series of postfix operators. */
5220 static struct c_expr
5221 c_parser_postfix_expression_after_primary (c_parser
*parser
,
5224 tree ident
, idx
, exprlist
;
5227 switch (c_parser_peek_token (parser
)->type
)
5229 case CPP_OPEN_SQUARE
:
5230 /* Array reference. */
5231 c_parser_consume_token (parser
);
5232 idx
= c_parser_expression (parser
).value
;
5233 c_parser_skip_until_found (parser
, CPP_CLOSE_SQUARE
,
5235 expr
.value
= build_array_ref (expr
.value
, idx
);
5236 expr
.original_code
= ERROR_MARK
;
5238 case CPP_OPEN_PAREN
:
5239 /* Function call. */
5240 c_parser_consume_token (parser
);
5241 if (c_parser_next_token_is (parser
, CPP_CLOSE_PAREN
))
5242 exprlist
= NULL_TREE
;
5244 exprlist
= c_parser_expr_list (parser
, true);
5245 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5247 expr
.value
= build_function_call (expr
.value
, exprlist
);
5248 expr
.original_code
= ERROR_MARK
;
5251 /* Structure element reference. */
5252 c_parser_consume_token (parser
);
5253 expr
.value
= default_function_array_conversion (expr
.value
);
5254 if (c_parser_next_token_is (parser
, CPP_NAME
))
5255 ident
= c_parser_peek_token (parser
)->value
;
5258 c_parser_error (parser
, "expected identifier");
5259 expr
.value
= error_mark_node
;
5260 expr
.original_code
= ERROR_MARK
;
5263 c_parser_consume_token (parser
);
5264 expr
.value
= build_component_ref (expr
.value
, ident
);
5265 expr
.original_code
= ERROR_MARK
;
5268 /* Structure element reference. */
5269 c_parser_consume_token (parser
);
5270 expr
.value
= default_function_array_conversion (expr
.value
);
5271 if (c_parser_next_token_is (parser
, CPP_NAME
))
5272 ident
= c_parser_peek_token (parser
)->value
;
5275 c_parser_error (parser
, "expected identifier");
5276 expr
.value
= error_mark_node
;
5277 expr
.original_code
= ERROR_MARK
;
5280 c_parser_consume_token (parser
);
5281 expr
.value
= build_component_ref (build_indirect_ref (expr
.value
,
5283 expr
.original_code
= ERROR_MARK
;
5286 /* Postincrement. */
5287 c_parser_consume_token (parser
);
5288 expr
.value
= default_function_array_conversion (expr
.value
);
5289 expr
.value
= build_unary_op (POSTINCREMENT_EXPR
, expr
.value
, 0);
5290 expr
.original_code
= ERROR_MARK
;
5292 case CPP_MINUS_MINUS
:
5293 /* Postdecrement. */
5294 c_parser_consume_token (parser
);
5295 expr
.value
= default_function_array_conversion (expr
.value
);
5296 expr
.value
= build_unary_op (POSTDECREMENT_EXPR
, expr
.value
, 0);
5297 expr
.original_code
= ERROR_MARK
;
5305 /* Parse an expression (C90 6.3.17, C99 6.5.17).
5308 assignment-expression
5309 expression , assignment-expression
5312 static struct c_expr
5313 c_parser_expression (c_parser
*parser
)
5316 expr
= c_parser_expr_no_commas (parser
, NULL
);
5317 while (c_parser_next_token_is (parser
, CPP_COMMA
))
5320 c_parser_consume_token (parser
);
5321 next
= c_parser_expr_no_commas (parser
, NULL
);
5322 next
.value
= default_function_array_conversion (next
.value
);
5323 expr
.value
= build_compound_expr (expr
.value
, next
.value
);
5324 expr
.original_code
= COMPOUND_EXPR
;
5329 /* Parse an expression and convert functions or arrays to
5332 static struct c_expr
5333 c_parser_expression_conv (c_parser
*parser
)
5336 expr
= c_parser_expression (parser
);
5337 expr
.value
= default_function_array_conversion (expr
.value
);
5341 /* Parse a non-empty list of expressions. If CONVERT_P, convert
5342 functions and arrays to pointers.
5345 assignment-expression
5346 nonempty-expr-list , assignment-expression
5350 c_parser_expr_list (c_parser
*parser
, bool convert_p
)
5354 expr
= c_parser_expr_no_commas (parser
, NULL
);
5356 expr
.value
= default_function_array_conversion (expr
.value
);
5357 ret
= cur
= build_tree_list (NULL_TREE
, expr
.value
);
5358 while (c_parser_next_token_is (parser
, CPP_COMMA
))
5360 c_parser_consume_token (parser
);
5361 expr
= c_parser_expr_no_commas (parser
, NULL
);
5363 expr
.value
= default_function_array_conversion (expr
.value
);
5364 cur
= TREE_CHAIN (cur
) = build_tree_list (NULL_TREE
, expr
.value
);
5370 /* Parse Objective-C-specific constructs. */
5372 /* Parse an objc-class-definition.
5374 objc-class-definition:
5375 @interface identifier objc-superclass[opt] objc-protocol-refs[opt]
5376 objc-class-instance-variables[opt] objc-methodprotolist @end
5377 @implementation identifier objc-superclass[opt]
5378 objc-class-instance-variables[opt]
5379 @interface identifier ( identifier ) objc-protocol-refs[opt]
5380 objc-methodprotolist @end
5381 @implementation identifier ( identifier )
5386 "@interface identifier (" must start "@interface identifier (
5387 identifier ) ...": objc-methodprotolist in the first production may
5388 not start with a parenthesized identifier as a declarator of a data
5389 definition with no declaration specifiers if the objc-superclass,
5390 objc-protocol-refs and objc-class-instance-variables are omitted. */
5393 c_parser_objc_class_definition (c_parser
*parser
)
5398 if (c_parser_next_token_is_keyword (parser
, RID_AT_INTERFACE
))
5400 else if (c_parser_next_token_is_keyword (parser
, RID_AT_IMPLEMENTATION
))
5404 c_parser_consume_token (parser
);
5405 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5407 c_parser_error (parser
, "expected identifier");
5410 id1
= c_parser_peek_token (parser
)->value
;
5411 c_parser_consume_token (parser
);
5412 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
5415 tree proto
= NULL_TREE
;
5416 c_parser_consume_token (parser
);
5417 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5419 c_parser_error (parser
, "expected identifier");
5420 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
5423 id2
= c_parser_peek_token (parser
)->value
;
5424 c_parser_consume_token (parser
);
5425 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
5428 objc_start_category_implementation (id1
, id2
);
5431 if (c_parser_next_token_is (parser
, CPP_LESS
))
5432 proto
= c_parser_objc_protocol_refs (parser
);
5433 objc_start_category_interface (id1
, id2
, proto
);
5434 c_parser_objc_methodprotolist (parser
);
5435 c_parser_require_keyword (parser
, RID_AT_END
, "expected %<@end%>");
5436 objc_finish_interface ();
5439 if (c_parser_next_token_is (parser
, CPP_COLON
))
5441 c_parser_consume_token (parser
);
5442 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5444 c_parser_error (parser
, "expected identifier");
5447 superclass
= c_parser_peek_token (parser
)->value
;
5448 c_parser_consume_token (parser
);
5451 superclass
= NULL_TREE
;
5454 tree proto
= NULL_TREE
;
5455 if (c_parser_next_token_is (parser
, CPP_LESS
))
5456 proto
= c_parser_objc_protocol_refs (parser
);
5457 objc_start_class_interface (id1
, superclass
, proto
);
5460 objc_start_class_implementation (id1
, superclass
);
5461 if (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
))
5462 c_parser_objc_class_instance_variables (parser
);
5465 objc_continue_interface ();
5466 c_parser_objc_methodprotolist (parser
);
5467 c_parser_require_keyword (parser
, RID_AT_END
, "expected %<@end%>");
5468 objc_finish_interface ();
5472 objc_continue_implementation ();
5477 /* Parse objc-class-instance-variables.
5479 objc-class-instance-variables:
5480 { objc-instance-variable-decl-list[opt] }
5482 objc-instance-variable-decl-list:
5483 objc-visibility-spec
5484 objc-instance-variable-decl ;
5486 objc-instance-variable-decl-list objc-visibility-spec
5487 objc-instance-variable-decl-list objc-instance-variable-decl ;
5488 objc-instance-variable-decl-list ;
5490 objc-visibility-spec:
5495 objc-instance-variable-decl:
5500 c_parser_objc_class_instance_variables (c_parser
*parser
)
5502 gcc_assert (c_parser_next_token_is (parser
, CPP_OPEN_BRACE
));
5503 c_parser_consume_token (parser
);
5504 while (c_parser_next_token_is_not (parser
, CPP_EOF
))
5507 /* Parse any stray semicolon. */
5508 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
5511 pedwarn ("extra semicolon in struct or union specified");
5512 c_parser_consume_token (parser
);
5515 /* Stop if at the end of the instance variables. */
5516 if (c_parser_next_token_is (parser
, CPP_CLOSE_BRACE
))
5518 c_parser_consume_token (parser
);
5521 /* Parse any objc-visibility-spec. */
5522 if (c_parser_next_token_is_keyword (parser
, RID_AT_PRIVATE
))
5524 c_parser_consume_token (parser
);
5525 objc_set_visibility (2);
5528 else if (c_parser_next_token_is_keyword (parser
, RID_AT_PROTECTED
))
5530 c_parser_consume_token (parser
);
5531 objc_set_visibility (0);
5534 else if (c_parser_next_token_is_keyword (parser
, RID_AT_PUBLIC
))
5536 c_parser_consume_token (parser
);
5537 objc_set_visibility (1);
5540 /* Parse some comma-separated declarations. */
5541 decls
= c_parser_struct_declaration (parser
);
5543 /* Comma-separated instance variables are chained together in
5544 reverse order; add them one by one. */
5545 tree ivar
= nreverse (decls
);
5546 for (; ivar
; ivar
= TREE_CHAIN (ivar
))
5547 objc_add_instance_variable (copy_node (ivar
));
5549 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
5553 /* Parse an objc-class-declaration.
5555 objc-class-declaration:
5556 @class identifier-list ;
5560 c_parser_objc_class_declaration (c_parser
*parser
)
5562 tree list
= NULL_TREE
;
5563 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_AT_CLASS
));
5564 c_parser_consume_token (parser
);
5565 /* Any identifiers, including those declared as type names, are OK
5570 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5572 c_parser_error (parser
, "expected identifier");
5575 id
= c_parser_peek_token (parser
)->value
;
5576 list
= chainon (list
, build_tree_list (NULL_TREE
, id
));
5577 c_parser_consume_token (parser
);
5578 if (c_parser_next_token_is (parser
, CPP_COMMA
))
5579 c_parser_consume_token (parser
);
5583 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
5584 objc_declare_class (list
);
5587 /* Parse an objc-alias-declaration.
5589 objc-alias-declaration:
5590 @compatibility_alias identifier identifier ;
5594 c_parser_objc_alias_declaration (c_parser
*parser
)
5597 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_AT_ALIAS
));
5598 c_parser_consume_token (parser
);
5599 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5601 c_parser_error (parser
, "expected identifier");
5602 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, NULL
);
5605 id1
= c_parser_peek_token (parser
)->value
;
5606 c_parser_consume_token (parser
);
5607 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5609 c_parser_error (parser
, "expected identifier");
5610 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, NULL
);
5613 id2
= c_parser_peek_token (parser
)->value
;
5614 c_parser_consume_token (parser
);
5615 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
5616 objc_declare_alias (id1
, id2
);
5619 /* Parse an objc-protocol-definition.
5621 objc-protocol-definition:
5622 @protocol identifier objc-protocol-refs[opt] objc-methodprotolist @end
5623 @protocol identifier-list ;
5625 "@protocol identifier ;" should be resolved as "@protocol
5626 identifier-list ;": objc-methodprotolist may not start with a
5627 semicolon in the first alternative if objc-protocol-refs are
5631 c_parser_objc_protocol_definition (c_parser
*parser
)
5633 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_AT_PROTOCOL
));
5634 c_parser_consume_token (parser
);
5635 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5637 c_parser_error (parser
, "expected identifier");
5640 if (c_parser_peek_2nd_token (parser
)->type
== CPP_COMMA
5641 || c_parser_peek_2nd_token (parser
)->type
== CPP_SEMICOLON
)
5643 tree list
= NULL_TREE
;
5644 /* Any identifiers, including those declared as type names, are
5649 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5651 c_parser_error (parser
, "expected identifier");
5654 id
= c_parser_peek_token (parser
)->value
;
5655 list
= chainon (list
, build_tree_list (NULL_TREE
, id
));
5656 c_parser_consume_token (parser
);
5657 if (c_parser_next_token_is (parser
, CPP_COMMA
))
5658 c_parser_consume_token (parser
);
5662 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
5663 objc_declare_protocols (list
);
5667 tree id
= c_parser_peek_token (parser
)->value
;
5668 tree proto
= NULL_TREE
;
5669 c_parser_consume_token (parser
);
5670 if (c_parser_next_token_is (parser
, CPP_LESS
))
5671 proto
= c_parser_objc_protocol_refs (parser
);
5672 objc_pq_context
= 1;
5673 objc_start_protocol (id
, proto
);
5674 c_parser_objc_methodprotolist (parser
);
5675 c_parser_require_keyword (parser
, RID_AT_END
, "expected %<@end%>");
5676 objc_pq_context
= 0;
5677 objc_finish_interface ();
5681 /* Parse an objc-method-type.
5688 static enum tree_code
5689 c_parser_objc_method_type (c_parser
*parser
)
5691 switch (c_parser_peek_token (parser
)->type
)
5694 c_parser_consume_token (parser
);
5697 c_parser_consume_token (parser
);
5704 /* Parse an objc-method-definition.
5706 objc-method-definition:
5707 objc-method-type objc-method-decl ;[opt] compound-statement
5711 c_parser_objc_method_definition (c_parser
*parser
)
5713 enum tree_code type
= c_parser_objc_method_type (parser
);
5715 objc_set_method_type (type
);
5716 objc_pq_context
= 1;
5717 decl
= c_parser_objc_method_decl (parser
);
5718 if (c_parser_next_token_is (parser
, CPP_SEMICOLON
))
5720 c_parser_consume_token (parser
);
5722 pedwarn ("extra semicolon in method definition specified");
5724 objc_pq_context
= 0;
5725 objc_start_method_definition (decl
);
5726 add_stmt (c_parser_compound_statement (parser
));
5727 objc_finish_method_definition (current_function_decl
);
5730 /* Parse an objc-methodprotolist.
5732 objc-methodprotolist:
5734 objc-methodprotolist objc-methodproto
5735 objc-methodprotolist declaration
5736 objc-methodprotolist ;
5738 The declaration is a data definition, which may be missing
5739 declaration specifiers under the same rules and diagnostics as
5740 other data definitions outside functions, and the stray semicolon
5741 is diagnosed the same way as a stray semicolon outside a
5745 c_parser_objc_methodprotolist (c_parser
*parser
)
5749 /* The list is terminated by @end. */
5750 switch (c_parser_peek_token (parser
)->type
)
5754 pedwarn ("ISO C does not allow extra %<;%> outside of a function");
5755 c_parser_consume_token (parser
);
5759 c_parser_objc_methodproto (parser
);
5764 if (c_parser_next_token_is_keyword (parser
, RID_AT_END
))
5766 c_parser_declaration_or_fndef (parser
, false, true, false, true);
5772 /* Parse an objc-methodproto.
5775 objc-method-type objc-method-decl ;
5779 c_parser_objc_methodproto (c_parser
*parser
)
5781 enum tree_code type
= c_parser_objc_method_type (parser
);
5783 objc_set_method_type (type
);
5784 /* Remember protocol qualifiers in prototypes. */
5785 objc_pq_context
= 1;
5786 decl
= c_parser_objc_method_decl (parser
);
5787 /* Forget protocol qualifiers here. */
5788 objc_pq_context
= 0;
5789 objc_add_method_declaration (decl
);
5790 c_parser_skip_until_found (parser
, CPP_SEMICOLON
, "expected %<;%>");
5793 /* Parse an objc-method-decl.
5796 ( objc-type-name ) objc-selector
5798 ( objc-type-name ) objc-keyword-selector objc-optparmlist
5799 objc-keyword-selector objc-optparmlist
5801 objc-keyword-selector:
5803 objc-keyword-selector objc-keyword-decl
5806 objc-selector : ( objc-type-name ) identifier
5807 objc-selector : identifier
5808 : ( objc-type-name ) identifier
5812 objc-optparms objc-optellipsis
5816 objc-opt-parms , parameter-declaration
5824 c_parser_objc_method_decl (c_parser
*parser
)
5826 tree type
= NULL_TREE
;
5828 tree parms
= NULL_TREE
;
5829 bool ellipsis
= false;
5831 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
5833 c_parser_consume_token (parser
);
5834 type
= c_parser_objc_type_name (parser
);
5835 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
5837 sel
= c_parser_objc_selector (parser
);
5838 /* If there is no selector, or a colon follows, we have an
5839 objc-keyword-selector. If there is a selector, and a colon does
5840 not follow, that selector ends the objc-method-decl. */
5841 if (!sel
|| c_parser_next_token_is (parser
, CPP_COLON
))
5844 tree list
= NULL_TREE
;
5847 tree atype
= NULL_TREE
, id
, keyworddecl
;
5848 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
5850 if (c_parser_next_token_is (parser
, CPP_OPEN_PAREN
))
5852 c_parser_consume_token (parser
);
5853 atype
= c_parser_objc_type_name (parser
);
5854 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
,
5857 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5859 c_parser_error (parser
, "expected identifier");
5860 return error_mark_node
;
5862 id
= c_parser_peek_token (parser
)->value
;
5863 c_parser_consume_token (parser
);
5864 keyworddecl
= objc_build_keyword_decl (tsel
, atype
, id
);
5865 list
= chainon (list
, keyworddecl
);
5866 tsel
= c_parser_objc_selector (parser
);
5867 if (!tsel
&& c_parser_next_token_is_not (parser
, CPP_COLON
))
5870 /* Parse the optional parameter list. Optional Objective-C
5871 method parameters follow the C syntax, and may include '...'
5872 to denote a variable number of arguments. */
5873 parms
= make_node (TREE_LIST
);
5874 while (c_parser_next_token_is (parser
, CPP_COMMA
))
5876 struct c_parm
*parm
;
5877 c_parser_consume_token (parser
);
5878 if (c_parser_next_token_is (parser
, CPP_ELLIPSIS
))
5881 c_parser_consume_token (parser
);
5884 parm
= c_parser_parameter_declaration (parser
, NULL_TREE
);
5887 parms
= chainon (parms
,
5888 build_tree_list (NULL_TREE
, grokparm (parm
)));
5892 return objc_build_method_signature (type
, sel
, parms
, ellipsis
);
5895 /* Parse an objc-type-name.
5898 objc-type-qualifiers[opt] type-name
5899 objc-type-qualifiers[opt]
5901 objc-type-qualifiers:
5903 objc-type-qualifiers objc-type-qualifier
5905 objc-type-qualifier: one of
5906 in out inout bycopy byref oneway
5910 c_parser_objc_type_name (c_parser
*parser
)
5912 tree quals
= NULL_TREE
;
5913 struct c_type_name
*typename
= NULL
;
5914 tree type
= NULL_TREE
;
5917 c_token
*token
= c_parser_peek_token (parser
);
5918 if (token
->type
== CPP_KEYWORD
5919 && (token
->keyword
== RID_IN
5920 || token
->keyword
== RID_OUT
5921 || token
->keyword
== RID_INOUT
5922 || token
->keyword
== RID_BYCOPY
5923 || token
->keyword
== RID_BYREF
5924 || token
->keyword
== RID_ONEWAY
))
5926 quals
= chainon (quals
, build_tree_list (NULL_TREE
, token
->value
));
5927 c_parser_consume_token (parser
);
5932 if (c_parser_next_token_starts_typename (parser
))
5933 typename
= c_parser_type_name (parser
);
5935 type
= groktypename (typename
);
5936 return build_tree_list (quals
, type
);
5939 /* Parse objc-protocol-refs.
5946 c_parser_objc_protocol_refs (c_parser
*parser
)
5948 tree list
= NULL_TREE
;
5949 gcc_assert (c_parser_next_token_is (parser
, CPP_LESS
));
5950 c_parser_consume_token (parser
);
5951 /* Any identifiers, including those declared as type names, are OK
5956 if (c_parser_next_token_is_not (parser
, CPP_NAME
))
5958 c_parser_error (parser
, "expected identifier");
5961 id
= c_parser_peek_token (parser
)->value
;
5962 list
= chainon (list
, build_tree_list (NULL_TREE
, id
));
5963 c_parser_consume_token (parser
);
5964 if (c_parser_next_token_is (parser
, CPP_COMMA
))
5965 c_parser_consume_token (parser
);
5969 c_parser_require (parser
, CPP_GREATER
, "expected %<>%>");
5973 /* Parse an objc-try-catch-statement.
5975 objc-try-catch-statement:
5976 @try compound-statement objc-catch-list[opt]
5977 @try compound-statement objc-catch-list[opt] @finally compound-statement
5980 @catch ( parameter-declaration ) compound-statement
5981 objc-catch-list @catch ( parameter-declaration ) compound-statement
5985 c_parser_objc_try_catch_statement (c_parser
*parser
)
5989 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_AT_TRY
));
5990 c_parser_consume_token (parser
);
5991 loc
= c_parser_peek_token (parser
)->location
;
5992 stmt
= c_parser_compound_statement (parser
);
5993 objc_begin_try_stmt (loc
, stmt
);
5994 while (c_parser_next_token_is_keyword (parser
, RID_AT_CATCH
))
5996 struct c_parm
*parm
;
5997 c_parser_consume_token (parser
);
5998 if (!c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
6000 parm
= c_parser_parameter_declaration (parser
, NULL_TREE
);
6003 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, NULL
);
6006 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
6007 objc_begin_catch_clause (grokparm (parm
));
6008 if (c_parser_require (parser
, CPP_OPEN_BRACE
, "expected %<{%>"))
6009 c_parser_compound_statement_nostart (parser
);
6010 objc_finish_catch_clause ();
6012 if (c_parser_next_token_is_keyword (parser
, RID_AT_FINALLY
))
6016 c_parser_consume_token (parser
);
6017 finloc
= c_parser_peek_token (parser
)->location
;
6018 finstmt
= c_parser_compound_statement (parser
);
6019 objc_build_finally_clause (finloc
, finstmt
);
6021 objc_finish_try_stmt ();
6024 /* Parse an objc-synchronized-statement.
6026 objc-synchronized-statement:
6027 @synchronized ( expression ) compound-statement
6031 c_parser_objc_synchronized_statement (c_parser
*parser
)
6035 gcc_assert (c_parser_next_token_is_keyword (parser
, RID_AT_SYNCHRONIZED
));
6036 c_parser_consume_token (parser
);
6037 loc
= c_parser_peek_token (parser
)->location
;
6038 if (c_parser_require (parser
, CPP_OPEN_PAREN
, "expected %<(%>"))
6040 expr
= c_parser_expression (parser
).value
;
6041 c_parser_skip_until_found (parser
, CPP_CLOSE_PAREN
, "expected %<)%>");
6044 expr
= error_mark_node
;
6045 stmt
= c_parser_compound_statement (parser
);
6046 objc_build_synchronized (loc
, expr
, stmt
);
6049 /* Parse an objc-selector; return NULL_TREE without an error if the
6050 next token is not an objc-selector.
6055 enum struct union if else while do for switch case default
6056 break continue return goto asm sizeof typeof __alignof
6057 unsigned long const short volatile signed restrict _Complex
6058 in out inout bycopy byref oneway int char float double void _Bool
6060 ??? Why this selection of keywords but not, for example, storage
6061 class specifiers? */
6064 c_parser_objc_selector (c_parser
*parser
)
6066 c_token
*token
= c_parser_peek_token (parser
);
6067 tree value
= token
->value
;
6068 if (token
->type
== CPP_NAME
)
6070 c_parser_consume_token (parser
);
6073 if (token
->type
!= CPP_KEYWORD
)
6075 switch (token
->keyword
)
6116 c_parser_consume_token (parser
);
6123 /* Parse an objc-selector-arg.
6127 objc-keywordname-list
6129 objc-keywordname-list:
6131 objc-keywordname-list objc-keywordname
6139 c_parser_objc_selector_arg (c_parser
*parser
)
6141 tree sel
= c_parser_objc_selector (parser
);
6142 tree list
= NULL_TREE
;
6143 if (sel
&& c_parser_next_token_is_not (parser
, CPP_COLON
))
6147 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
6149 list
= chainon (list
, build_tree_list (sel
, NULL_TREE
));
6150 sel
= c_parser_objc_selector (parser
);
6151 if (!sel
&& c_parser_next_token_is_not (parser
, CPP_COLON
))
6157 /* Parse an objc-receiver.
6166 c_parser_objc_receiver (c_parser
*parser
)
6168 if (c_parser_peek_token (parser
)->type
== CPP_NAME
6169 && (c_parser_peek_token (parser
)->id_kind
== C_ID_TYPENAME
6170 || c_parser_peek_token (parser
)->id_kind
== C_ID_CLASSNAME
))
6172 tree id
= c_parser_peek_token (parser
)->value
;
6173 c_parser_consume_token (parser
);
6174 return objc_get_class_reference (id
);
6176 return c_parser_expression (parser
).value
;
6179 /* Parse objc-message-args.
6183 objc-keywordarg-list
6185 objc-keywordarg-list:
6187 objc-keywordarg-list objc-keywordarg
6190 objc-selector : objc-keywordexpr
6195 c_parser_objc_message_args (c_parser
*parser
)
6197 tree sel
= c_parser_objc_selector (parser
);
6198 tree list
= NULL_TREE
;
6199 if (sel
&& c_parser_next_token_is_not (parser
, CPP_COLON
))
6204 if (!c_parser_require (parser
, CPP_COLON
, "expected %<:%>"))
6206 keywordexpr
= c_parser_objc_keywordexpr (parser
);
6207 list
= chainon (list
, build_tree_list (sel
, keywordexpr
));
6208 sel
= c_parser_objc_selector (parser
);
6209 if (!sel
&& c_parser_next_token_is_not (parser
, CPP_COLON
))
6215 /* Parse an objc-keywordexpr.
6222 c_parser_objc_keywordexpr (c_parser
*parser
)
6224 tree list
= c_parser_expr_list (parser
, true);
6225 if (TREE_CHAIN (list
) == NULL_TREE
)
6227 /* Just return the expression, remove a level of
6229 return TREE_VALUE (list
);
6233 /* We have a comma expression, we will collapse later. */
6239 /* The actual parser and external interface. ??? Does this need to be
6240 garbage-collected? */
6242 static GTY (()) c_parser
*the_parser
;
6244 /* Parse a single source file. */
6249 the_parser
= c_parser_new ();
6250 c_parser_translation_unit (the_parser
);
6254 #include "gt-c-parser.h"