1 | /* Parser for C and Objective-C. |
2 | Copyright (C) 1987-2017 Free Software Foundation, Inc. |
3 | |
4 | Parser actions based on the old Bison parser; structure somewhat |
5 | influenced by and fragments based on the C++ parser. |
6 | |
7 | This file is part of GCC. |
8 | |
9 | GCC is free software; you can redistribute it and/or modify it under |
10 | the terms of the GNU General Public License as published by the Free |
11 | Software Foundation; either version 3, or (at your option) any later |
12 | version. |
13 | |
14 | GCC is distributed in the hope that it will be useful, but WITHOUT ANY |
15 | WARRANTY; without even the implied warranty of MERCHANTABILITY or |
16 | FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
17 | for more details. |
18 | |
19 | You should have received a copy of the GNU General Public License |
20 | along with GCC; see the file COPYING3. If not see |
21 | <http://www.gnu.org/licenses/>. */ |
22 | |
23 | /* TODO: |
24 | |
25 | Make sure all relevant comments, and all relevant code from all |
26 | actions, brought over from old parser. Verify exact correspondence |
27 | of syntax accepted. |
28 | |
29 | Add testcases covering every input symbol in every state in old and |
30 | new parsers. |
31 | |
32 | Include full syntax for GNU C, including erroneous cases accepted |
33 | with error messages, in syntax productions in comments. |
34 | |
35 | Make more diagnostics in the front end generally take an explicit |
36 | location rather than implicitly using input_location. */ |
37 | |
38 | #include "config.h" |
39 | #define INCLUDE_UNIQUE_PTR |
40 | #include "system.h" |
41 | #include "coretypes.h" |
42 | #include "target.h" |
43 | #include "function.h" |
44 | #include "c-tree.h" |
45 | #include "timevar.h" |
46 | #include "stringpool.h" |
47 | #include "cgraph.h" |
48 | #include "attribs.h" |
49 | #include "stor-layout.h" |
50 | #include "varasm.h" |
51 | #include "trans-mem.h" |
52 | #include "c-family/c-pragma.h" |
53 | #include "c-lang.h" |
54 | #include "c-family/c-objc.h" |
55 | #include "plugin.h" |
56 | #include "omp-general.h" |
57 | #include "omp-offload.h" |
58 | #include "builtins.h" |
59 | #include "gomp-constants.h" |
60 | #include "c-family/c-indentation.h" |
61 | #include "gimple-expr.h" |
62 | #include "context.h" |
63 | #include "gcc-rich-location.h" |
64 | #include "c-parser.h" |
65 | #include "gimple-parser.h" |
66 | #include "read-rtl-function.h" |
67 | #include "run-rtl-passes.h" |
68 | #include "intl.h" |
69 | #include "c-family/name-hint.h" |
70 | #include "tree-iterator.h" |
71 | |
72 | /* We need to walk over decls with incomplete struct/union/enum types |
73 | after parsing the whole translation unit. |
74 | In finish_decl(), if the decl is static, has incomplete |
75 | struct/union/enum type, it is appeneded to incomplete_record_decls. |
76 | In c_parser_translation_unit(), we iterate over incomplete_record_decls |
77 | and report error if any of the decls are still incomplete. */ |
78 | |
79 | vec<tree> incomplete_record_decls; |
80 | |
81 | void |
82 | set_c_expr_source_range (c_expr *expr, |
83 | location_t start, location_t finish) |
84 | { |
85 | expr->src_range.m_start = start; |
86 | expr->src_range.m_finish = finish; |
87 | if (expr->value) |
88 | set_source_range (expr->value, start, finish); |
89 | } |
90 | |
91 | void |
92 | set_c_expr_source_range (c_expr *expr, |
93 | source_range src_range) |
94 | { |
95 | expr->src_range = src_range; |
96 | if (expr->value) |
97 | set_source_range (expr->value, src_range); |
98 | } |
99 | |
100 | |
101 | /* Initialization routine for this file. */ |
102 | |
103 | void |
104 | c_parse_init (void) |
105 | { |
106 | /* The only initialization required is of the reserved word |
107 | identifiers. */ |
108 | unsigned int i; |
109 | tree id; |
110 | int mask = 0; |
111 | |
112 | /* Make sure RID_MAX hasn't grown past the 8 bits used to hold the keyword in |
113 | the c_token structure. */ |
114 | gcc_assert (RID_MAX <= 255); |
115 | |
116 | mask |= D_CXXONLY; |
117 | if (!flag_isoc99) |
118 | mask |= D_C99; |
119 | if (flag_no_asm) |
120 | { |
121 | mask |= D_ASM | D_EXT; |
122 | if (!flag_isoc99) |
123 | mask |= D_EXT89; |
124 | } |
125 | if (!c_dialect_objc ()) |
126 | mask |= D_OBJC | D_CXX_OBJC; |
127 | |
128 | ridpointers = ggc_cleared_vec_alloc<tree> ((int) RID_MAX); |
129 | for (i = 0; i < num_c_common_reswords; i++) |
130 | { |
131 | /* If a keyword is disabled, do not enter it into the table |
132 | and so create a canonical spelling that isn't a keyword. */ |
133 | if (c_common_reswords[i].disable & mask) |
134 | { |
135 | if (warn_cxx_compat |
136 | && (c_common_reswords[i].disable & D_CXXWARN)) |
137 | { |
138 | id = get_identifier (c_common_reswords[i].word); |
139 | C_SET_RID_CODE (id, RID_CXX_COMPAT_WARN); |
140 | C_IS_RESERVED_WORD (id) = 1; |
141 | } |
142 | continue; |
143 | } |
144 | |
145 | id = get_identifier (c_common_reswords[i].word); |
146 | C_SET_RID_CODE (id, c_common_reswords[i].rid); |
147 | C_IS_RESERVED_WORD (id) = 1; |
148 | ridpointers [(int) c_common_reswords[i].rid] = id; |
149 | } |
150 | |
151 | for (i = 0; i < NUM_INT_N_ENTS; i++) |
152 | { |
153 | /* We always create the symbols but they aren't always supported. */ |
154 | char name[50]; |
155 | sprintf (name, "__int%d" , int_n_data[i].bitsize); |
156 | id = get_identifier (name); |
157 | C_SET_RID_CODE (id, RID_FIRST_INT_N + i); |
158 | C_IS_RESERVED_WORD (id) = 1; |
159 | } |
160 | } |
161 | |
162 | /* A parser structure recording information about the state and |
163 | context of parsing. Includes lexer information with up to two |
164 | tokens of look-ahead; more are not needed for C. */ |
165 | struct GTY(()) c_parser { |
166 | /* The look-ahead tokens. */ |
167 | c_token * GTY((skip)) tokens; |
168 | /* Buffer for look-ahead tokens. */ |
169 | c_token tokens_buf[4]; |
170 | /* How many look-ahead tokens are available (0 - 4, or |
171 | more if parsing from pre-lexed tokens). */ |
172 | unsigned int tokens_avail; |
173 | /* True if a syntax error is being recovered from; false otherwise. |
174 | c_parser_error sets this flag. It should clear this flag when |
175 | enough tokens have been consumed to recover from the error. */ |
176 | BOOL_BITFIELD error : 1; |
177 | /* True if we're processing a pragma, and shouldn't automatically |
178 | consume CPP_PRAGMA_EOL. */ |
179 | BOOL_BITFIELD in_pragma : 1; |
180 | /* True if we're parsing the outermost block of an if statement. */ |
181 | BOOL_BITFIELD in_if_block : 1; |
182 | /* True if we want to lex an untranslated string. */ |
183 | BOOL_BITFIELD lex_untranslated_string : 1; |
184 | |
185 | /* Objective-C specific parser/lexer information. */ |
186 | |
187 | /* True if we are in a context where the Objective-C "PQ" keywords |
188 | are considered keywords. */ |
189 | BOOL_BITFIELD objc_pq_context : 1; |
190 | /* True if we are parsing a (potential) Objective-C foreach |
191 | statement. This is set to true after we parsed 'for (' and while |
192 | we wait for 'in' or ';' to decide if it's a standard C for loop or an |
193 | Objective-C foreach loop. */ |
194 | BOOL_BITFIELD objc_could_be_foreach_context : 1; |
195 | /* The following flag is needed to contextualize Objective-C lexical |
196 | analysis. In some cases (e.g., 'int NSObject;'), it is |
197 | undesirable to bind an identifier to an Objective-C class, even |
198 | if a class with that name exists. */ |
199 | BOOL_BITFIELD objc_need_raw_identifier : 1; |
200 | /* Nonzero if we're processing a __transaction statement. The value |
201 | is 1 | TM_STMT_ATTR_*. */ |
202 | unsigned int in_transaction : 4; |
203 | /* True if we are in a context where the Objective-C "Property attribute" |
204 | keywords are valid. */ |
205 | BOOL_BITFIELD objc_property_attr_context : 1; |
206 | |
207 | /* Location of the last consumed token. */ |
208 | location_t last_token_location; |
209 | }; |
210 | |
211 | /* Return a pointer to the Nth token in PARSERs tokens_buf. */ |
212 | |
213 | c_token * |
214 | c_parser_tokens_buf (c_parser *parser, unsigned n) |
215 | { |
216 | return &parser->tokens_buf[n]; |
217 | } |
218 | |
219 | /* Return the error state of PARSER. */ |
220 | |
221 | bool |
222 | c_parser_error (c_parser *parser) |
223 | { |
224 | return parser->error; |
225 | } |
226 | |
227 | /* Set the error state of PARSER to ERR. */ |
228 | |
229 | void |
230 | c_parser_set_error (c_parser *parser, bool err) |
231 | { |
232 | parser->error = err; |
233 | } |
234 | |
235 | |
236 | /* The actual parser and external interface. ??? Does this need to be |
237 | garbage-collected? */ |
238 | |
239 | static GTY (()) c_parser *the_parser; |
240 | |
241 | /* Read in and lex a single token, storing it in *TOKEN. */ |
242 | |
243 | static void |
244 | c_lex_one_token (c_parser *parser, c_token *token) |
245 | { |
246 | timevar_push (TV_LEX); |
247 | |
248 | token->type = c_lex_with_flags (&token->value, &token->location, |
249 | &token->flags, |
250 | (parser->lex_untranslated_string |
251 | ? C_LEX_STRING_NO_TRANSLATE : 0)); |
252 | token->id_kind = C_ID_NONE; |
253 | token->keyword = RID_MAX; |
254 | token->pragma_kind = PRAGMA_NONE; |
255 | |
256 | switch (token->type) |
257 | { |
258 | case CPP_NAME: |
259 | { |
260 | tree decl; |
261 | |
262 | bool objc_force_identifier = parser->objc_need_raw_identifier; |
263 | if (c_dialect_objc ()) |
264 | parser->objc_need_raw_identifier = false; |
265 | |
266 | if (C_IS_RESERVED_WORD (token->value)) |
267 | { |
268 | enum rid rid_code = C_RID_CODE (token->value); |
269 | |
270 | if (rid_code == RID_CXX_COMPAT_WARN) |
271 | { |
272 | warning_at (token->location, |
273 | OPT_Wc___compat, |
274 | "identifier %qE conflicts with C++ keyword" , |
275 | token->value); |
276 | } |
277 | else if (rid_code >= RID_FIRST_ADDR_SPACE |
278 | && rid_code <= RID_LAST_ADDR_SPACE) |
279 | { |
280 | addr_space_t as; |
281 | as = (addr_space_t) (rid_code - RID_FIRST_ADDR_SPACE); |
282 | targetm.addr_space.diagnose_usage (as, token->location); |
283 | token->id_kind = C_ID_ADDRSPACE; |
284 | token->keyword = rid_code; |
285 | break; |
286 | } |
287 | else if (c_dialect_objc () && OBJC_IS_PQ_KEYWORD (rid_code)) |
288 | { |
289 | /* We found an Objective-C "pq" keyword (in, out, |
290 | inout, bycopy, byref, oneway). They need special |
291 | care because the interpretation depends on the |
292 | context. */ |
293 | if (parser->objc_pq_context) |
294 | { |
295 | token->type = CPP_KEYWORD; |
296 | token->keyword = rid_code; |
297 | break; |
298 | } |
299 | else if (parser->objc_could_be_foreach_context |
300 | && rid_code == RID_IN) |
301 | { |
302 | /* We are in Objective-C, inside a (potential) |
303 | foreach context (which means after having |
304 | parsed 'for (', but before having parsed ';'), |
305 | and we found 'in'. We consider it the keyword |
306 | which terminates the declaration at the |
307 | beginning of a foreach-statement. Note that |
308 | this means you can't use 'in' for anything else |
309 | in that context; in particular, in Objective-C |
310 | you can't use 'in' as the name of the running |
311 | variable in a C for loop. We could potentially |
312 | try to add code here to disambiguate, but it |
313 | seems a reasonable limitation. */ |
314 | token->type = CPP_KEYWORD; |
315 | token->keyword = rid_code; |
316 | break; |
317 | } |
318 | /* Else, "pq" keywords outside of the "pq" context are |
319 | not keywords, and we fall through to the code for |
320 | normal tokens. */ |
321 | } |
322 | else if (c_dialect_objc () && OBJC_IS_PATTR_KEYWORD (rid_code)) |
323 | { |
324 | /* We found an Objective-C "property attribute" |
325 | keyword (getter, setter, readonly, etc). These are |
326 | only valid in the property context. */ |
327 | if (parser->objc_property_attr_context) |
328 | { |
329 | token->type = CPP_KEYWORD; |
330 | token->keyword = rid_code; |
331 | break; |
332 | } |
333 | /* Else they are not special keywords. |
334 | */ |
335 | } |
336 | else if (c_dialect_objc () |
337 | && (OBJC_IS_AT_KEYWORD (rid_code) |
338 | || OBJC_IS_CXX_KEYWORD (rid_code))) |
339 | { |
340 | /* We found one of the Objective-C "@" keywords (defs, |
341 | selector, synchronized, etc) or one of the |
342 | Objective-C "cxx" keywords (class, private, |
343 | protected, public, try, catch, throw) without a |
344 | preceding '@' sign. Do nothing and fall through to |
345 | the code for normal tokens (in C++ we would still |
346 | consider the CXX ones keywords, but not in C). */ |
347 | ; |
348 | } |
349 | else |
350 | { |
351 | token->type = CPP_KEYWORD; |
352 | token->keyword = rid_code; |
353 | break; |
354 | } |
355 | } |
356 | |
357 | decl = lookup_name (token->value); |
358 | if (decl) |
359 | { |
360 | if (TREE_CODE (decl) == TYPE_DECL) |
361 | { |
362 | token->id_kind = C_ID_TYPENAME; |
363 | break; |
364 | } |
365 | } |
366 | else if (c_dialect_objc ()) |
367 | { |
368 | tree objc_interface_decl = objc_is_class_name (token->value); |
369 | /* Objective-C class names are in the same namespace as |
370 | variables and typedefs, and hence are shadowed by local |
371 | declarations. */ |
372 | if (objc_interface_decl |
373 | && (!objc_force_identifier || global_bindings_p ())) |
374 | { |
375 | token->value = objc_interface_decl; |
376 | token->id_kind = C_ID_CLASSNAME; |
377 | break; |
378 | } |
379 | } |
380 | token->id_kind = C_ID_ID; |
381 | } |
382 | break; |
383 | case CPP_AT_NAME: |
384 | /* This only happens in Objective-C; it must be a keyword. */ |
385 | token->type = CPP_KEYWORD; |
386 | switch (C_RID_CODE (token->value)) |
387 | { |
388 | /* Replace 'class' with '@class', 'private' with '@private', |
389 | etc. This prevents confusion with the C++ keyword |
390 | 'class', and makes the tokens consistent with other |
391 | Objective-C 'AT' keywords. For example '@class' is |
392 | reported as RID_AT_CLASS which is consistent with |
393 | '@synchronized', which is reported as |
394 | RID_AT_SYNCHRONIZED. |
395 | */ |
396 | case RID_CLASS: token->keyword = RID_AT_CLASS; break; |
397 | case RID_PRIVATE: token->keyword = RID_AT_PRIVATE; break; |
398 | case RID_PROTECTED: token->keyword = RID_AT_PROTECTED; break; |
399 | case RID_PUBLIC: token->keyword = RID_AT_PUBLIC; break; |
400 | case RID_THROW: token->keyword = RID_AT_THROW; break; |
401 | case RID_TRY: token->keyword = RID_AT_TRY; break; |
402 | case RID_CATCH: token->keyword = RID_AT_CATCH; break; |
403 | case RID_SYNCHRONIZED: token->keyword = RID_AT_SYNCHRONIZED; break; |
404 | default: token->keyword = C_RID_CODE (token->value); |
405 | } |
406 | break; |
407 | case CPP_COLON: |
408 | case CPP_COMMA: |
409 | case CPP_CLOSE_PAREN: |
410 | case CPP_SEMICOLON: |
411 | /* These tokens may affect the interpretation of any identifiers |
412 | following, if doing Objective-C. */ |
413 | if (c_dialect_objc ()) |
414 | parser->objc_need_raw_identifier = false; |
415 | break; |
416 | case CPP_PRAGMA: |
417 | /* We smuggled the cpp_token->u.pragma value in an INTEGER_CST. */ |
418 | token->pragma_kind = (enum pragma_kind) TREE_INT_CST_LOW (token->value); |
419 | token->value = NULL; |
420 | break; |
421 | default: |
422 | break; |
423 | } |
424 | timevar_pop (TV_LEX); |
425 | } |
426 | |
427 | /* Return a pointer to the next token from PARSER, reading it in if |
428 | necessary. */ |
429 | |
430 | c_token * |
431 | c_parser_peek_token (c_parser *parser) |
432 | { |
433 | if (parser->tokens_avail == 0) |
434 | { |
435 | c_lex_one_token (parser, &parser->tokens[0]); |
436 | parser->tokens_avail = 1; |
437 | } |
438 | return &parser->tokens[0]; |
439 | } |
440 | |
441 | /* Return a pointer to the next-but-one token from PARSER, reading it |
442 | in if necessary. The next token is already read in. */ |
443 | |
444 | c_token * |
445 | c_parser_peek_2nd_token (c_parser *parser) |
446 | { |
447 | if (parser->tokens_avail >= 2) |
448 | return &parser->tokens[1]; |
449 | gcc_assert (parser->tokens_avail == 1); |
450 | gcc_assert (parser->tokens[0].type != CPP_EOF); |
451 | gcc_assert (parser->tokens[0].type != CPP_PRAGMA_EOL); |
452 | c_lex_one_token (parser, &parser->tokens[1]); |
453 | parser->tokens_avail = 2; |
454 | return &parser->tokens[1]; |
455 | } |
456 | |
457 | /* Return a pointer to the Nth token from PARSER, reading it |
458 | in if necessary. The N-1th token is already read in. */ |
459 | |
460 | c_token * |
461 | c_parser_peek_nth_token (c_parser *parser, unsigned int n) |
462 | { |
463 | /* N is 1-based, not zero-based. */ |
464 | gcc_assert (n > 0); |
465 | |
466 | if (parser->tokens_avail >= n) |
467 | return &parser->tokens[n - 1]; |
468 | gcc_assert (parser->tokens_avail == n - 1); |
469 | c_lex_one_token (parser, &parser->tokens[n - 1]); |
470 | parser->tokens_avail = n; |
471 | return &parser->tokens[n - 1]; |
472 | } |
473 | |
474 | bool |
475 | c_keyword_starts_typename (enum rid keyword) |
476 | { |
477 | switch (keyword) |
478 | { |
479 | case RID_UNSIGNED: |
480 | case RID_LONG: |
481 | case RID_SHORT: |
482 | case RID_SIGNED: |
483 | case RID_COMPLEX: |
484 | case RID_INT: |
485 | case RID_CHAR: |
486 | case RID_FLOAT: |
487 | case RID_DOUBLE: |
488 | case RID_VOID: |
489 | case RID_DFLOAT32: |
490 | case RID_DFLOAT64: |
491 | case RID_DFLOAT128: |
492 | CASE_RID_FLOATN_NX: |
493 | case RID_BOOL: |
494 | case RID_ENUM: |
495 | case RID_STRUCT: |
496 | case RID_UNION: |
497 | case RID_TYPEOF: |
498 | case RID_CONST: |
499 | case RID_ATOMIC: |
500 | case RID_VOLATILE: |
501 | case RID_RESTRICT: |
502 | case RID_ATTRIBUTE: |
503 | case RID_FRACT: |
504 | case RID_ACCUM: |
505 | case RID_SAT: |
506 | case RID_AUTO_TYPE: |
507 | case RID_ALIGNAS: |
508 | return true; |
509 | default: |
510 | if (keyword >= RID_FIRST_INT_N |
511 | && keyword < RID_FIRST_INT_N + NUM_INT_N_ENTS |
512 | && int_n_enabled_p[keyword - RID_FIRST_INT_N]) |
513 | return true; |
514 | return false; |
515 | } |
516 | } |
517 | |
518 | /* Return true if TOKEN can start a type name, |
519 | false otherwise. */ |
520 | bool |
521 | c_token_starts_typename (c_token *token) |
522 | { |
523 | switch (token->type) |
524 | { |
525 | case CPP_NAME: |
526 | switch (token->id_kind) |
527 | { |
528 | case C_ID_ID: |
529 | return false; |
530 | case C_ID_ADDRSPACE: |
531 | return true; |
532 | case C_ID_TYPENAME: |
533 | return true; |
534 | case C_ID_CLASSNAME: |
535 | gcc_assert (c_dialect_objc ()); |
536 | return true; |
537 | default: |
538 | gcc_unreachable (); |
539 | } |
540 | case CPP_KEYWORD: |
541 | return c_keyword_starts_typename (token->keyword); |
542 | case CPP_LESS: |
543 | if (c_dialect_objc ()) |
544 | return true; |
545 | return false; |
546 | default: |
547 | return false; |
548 | } |
549 | } |
550 | |
551 | /* Return true if the next token from PARSER can start a type name, |
552 | false otherwise. LA specifies how to do lookahead in order to |
553 | detect unknown type names. If unsure, pick CLA_PREFER_ID. */ |
554 | |
555 | static inline bool |
556 | c_parser_next_tokens_start_typename (c_parser *parser, enum c_lookahead_kind la) |
557 | { |
558 | c_token *token = c_parser_peek_token (parser); |
559 | if (c_token_starts_typename (token)) |
560 | return true; |
561 | |
562 | /* Try a bit harder to detect an unknown typename. */ |
563 | if (la != cla_prefer_id |
564 | && token->type == CPP_NAME |
565 | && token->id_kind == C_ID_ID |
566 | |
567 | /* Do not try too hard when we could have "object in array". */ |
568 | && !parser->objc_could_be_foreach_context |
569 | |
570 | && (la == cla_prefer_type |
571 | || c_parser_peek_2nd_token (parser)->type == CPP_NAME |
572 | || c_parser_peek_2nd_token (parser)->type == CPP_MULT) |
573 | |
574 | /* Only unknown identifiers. */ |
575 | && !lookup_name (token->value)) |
576 | return true; |
577 | |
578 | return false; |
579 | } |
580 | |
581 | /* Return true if TOKEN is a type qualifier, false otherwise. */ |
582 | static bool |
583 | c_token_is_qualifier (c_token *token) |
584 | { |
585 | switch (token->type) |
586 | { |
587 | case CPP_NAME: |
588 | switch (token->id_kind) |
589 | { |
590 | case C_ID_ADDRSPACE: |
591 | return true; |
592 | default: |
593 | return false; |
594 | } |
595 | case CPP_KEYWORD: |
596 | switch (token->keyword) |
597 | { |
598 | case RID_CONST: |
599 | case RID_VOLATILE: |
600 | case RID_RESTRICT: |
601 | case RID_ATTRIBUTE: |
602 | case RID_ATOMIC: |
603 | return true; |
604 | default: |
605 | return false; |
606 | } |
607 | case CPP_LESS: |
608 | return false; |
609 | default: |
610 | gcc_unreachable (); |
611 | } |
612 | } |
613 | |
614 | /* Return true if the next token from PARSER is a type qualifier, |
615 | false otherwise. */ |
616 | static inline bool |
617 | c_parser_next_token_is_qualifier (c_parser *parser) |
618 | { |
619 | c_token *token = c_parser_peek_token (parser); |
620 | return c_token_is_qualifier (token); |
621 | } |
622 | |
623 | /* Return true if TOKEN can start declaration specifiers, false |
624 | otherwise. */ |
625 | static bool |
626 | c_token_starts_declspecs (c_token *token) |
627 | { |
628 | switch (token->type) |
629 | { |
630 | case CPP_NAME: |
631 | switch (token->id_kind) |
632 | { |
633 | case C_ID_ID: |
634 | return false; |
635 | case C_ID_ADDRSPACE: |
636 | return true; |
637 | case C_ID_TYPENAME: |
638 | return true; |
639 | case C_ID_CLASSNAME: |
640 | gcc_assert (c_dialect_objc ()); |
641 | return true; |
642 | default: |
643 | gcc_unreachable (); |
644 | } |
645 | case CPP_KEYWORD: |
646 | switch (token->keyword) |
647 | { |
648 | case RID_STATIC: |
649 | case RID_EXTERN: |
650 | case RID_REGISTER: |
651 | case RID_TYPEDEF: |
652 | case RID_INLINE: |
653 | case RID_NORETURN: |
654 | case RID_AUTO: |
655 | case RID_THREAD: |
656 | case RID_UNSIGNED: |
657 | case RID_LONG: |
658 | case RID_SHORT: |
659 | case RID_SIGNED: |
660 | case RID_COMPLEX: |
661 | case RID_INT: |
662 | case RID_CHAR: |
663 | case RID_FLOAT: |
664 | case RID_DOUBLE: |
665 | case RID_VOID: |
666 | case RID_DFLOAT32: |
667 | case RID_DFLOAT64: |
668 | case RID_DFLOAT128: |
669 | CASE_RID_FLOATN_NX: |
670 | case RID_BOOL: |
671 | case RID_ENUM: |
672 | case RID_STRUCT: |
673 | case RID_UNION: |
674 | case RID_TYPEOF: |
675 | case RID_CONST: |
676 | case RID_VOLATILE: |
677 | case RID_RESTRICT: |
678 | case RID_ATTRIBUTE: |
679 | case RID_FRACT: |
680 | case RID_ACCUM: |
681 | case RID_SAT: |
682 | case RID_ALIGNAS: |
683 | case RID_ATOMIC: |
684 | case RID_AUTO_TYPE: |
685 | return true; |
686 | default: |
687 | if (token->keyword >= RID_FIRST_INT_N |
688 | && token->keyword < RID_FIRST_INT_N + NUM_INT_N_ENTS |
689 | && int_n_enabled_p[token->keyword - RID_FIRST_INT_N]) |
690 | return true; |
691 | return false; |
692 | } |
693 | case CPP_LESS: |
694 | if (c_dialect_objc ()) |
695 | return true; |
696 | return false; |
697 | default: |
698 | return false; |
699 | } |
700 | } |
701 | |
702 | |
703 | /* Return true if TOKEN can start declaration specifiers or a static |
704 | assertion, false otherwise. */ |
705 | static bool |
706 | c_token_starts_declaration (c_token *token) |
707 | { |
708 | if (c_token_starts_declspecs (token) |
709 | || token->keyword == RID_STATIC_ASSERT) |
710 | return true; |
711 | else |
712 | return false; |
713 | } |
714 | |
715 | /* Return true if the next token from PARSER can start declaration |
716 | specifiers, false otherwise. */ |
717 | bool |
718 | c_parser_next_token_starts_declspecs (c_parser *parser) |
719 | { |
720 | c_token *token = c_parser_peek_token (parser); |
721 | |
722 | /* In Objective-C, a classname normally starts a declspecs unless it |
723 | is immediately followed by a dot. In that case, it is the |
724 | Objective-C 2.0 "dot-syntax" for class objects, ie, calls the |
725 | setter/getter on the class. c_token_starts_declspecs() can't |
726 | differentiate between the two cases because it only checks the |
727 | current token, so we have a special check here. */ |
728 | if (c_dialect_objc () |
729 | && token->type == CPP_NAME |
730 | && token->id_kind == C_ID_CLASSNAME |
731 | && c_parser_peek_2nd_token (parser)->type == CPP_DOT) |
732 | return false; |
733 | |
734 | return c_token_starts_declspecs (token); |
735 | } |
736 | |
737 | /* Return true if the next tokens from PARSER can start declaration |
738 | specifiers or a static assertion, false otherwise. */ |
739 | bool |
740 | c_parser_next_tokens_start_declaration (c_parser *parser) |
741 | { |
742 | c_token *token = c_parser_peek_token (parser); |
743 | |
744 | /* Same as above. */ |
745 | if (c_dialect_objc () |
746 | && token->type == CPP_NAME |
747 | && token->id_kind == C_ID_CLASSNAME |
748 | && c_parser_peek_2nd_token (parser)->type == CPP_DOT) |
749 | return false; |
750 | |
751 | /* Labels do not start declarations. */ |
752 | if (token->type == CPP_NAME |
753 | && c_parser_peek_2nd_token (parser)->type == CPP_COLON) |
754 | return false; |
755 | |
756 | if (c_token_starts_declaration (token)) |
757 | return true; |
758 | |
759 | if (c_parser_next_tokens_start_typename (parser, cla_nonabstract_decl)) |
760 | return true; |
761 | |
762 | return false; |
763 | } |
764 | |
765 | /* Consume the next token from PARSER. */ |
766 | |
767 | void |
768 | c_parser_consume_token (c_parser *parser) |
769 | { |
770 | gcc_assert (parser->tokens_avail >= 1); |
771 | gcc_assert (parser->tokens[0].type != CPP_EOF); |
772 | gcc_assert (!parser->in_pragma || parser->tokens[0].type != CPP_PRAGMA_EOL); |
773 | gcc_assert (parser->error || parser->tokens[0].type != CPP_PRAGMA); |
774 | parser->last_token_location = parser->tokens[0].location; |
775 | if (parser->tokens != &parser->tokens_buf[0]) |
776 | parser->tokens++; |
777 | else if (parser->tokens_avail == 2) |
778 | parser->tokens[0] = parser->tokens[1]; |
779 | parser->tokens_avail--; |
780 | } |
781 | |
782 | /* Expect the current token to be a #pragma. Consume it and remember |
783 | that we've begun parsing a pragma. */ |
784 | |
785 | static void |
786 | c_parser_consume_pragma (c_parser *parser) |
787 | { |
788 | gcc_assert (!parser->in_pragma); |
789 | gcc_assert (parser->tokens_avail >= 1); |
790 | gcc_assert (parser->tokens[0].type == CPP_PRAGMA); |
791 | if (parser->tokens != &parser->tokens_buf[0]) |
792 | parser->tokens++; |
793 | else if (parser->tokens_avail == 2) |
794 | parser->tokens[0] = parser->tokens[1]; |
795 | parser->tokens_avail--; |
796 | parser->in_pragma = true; |
797 | } |
798 | |
799 | /* Update the global input_location from TOKEN. */ |
800 | static inline void |
801 | c_parser_set_source_position_from_token (c_token *token) |
802 | { |
803 | if (token->type != CPP_EOF) |
804 | { |
805 | input_location = token->location; |
806 | } |
807 | } |
808 | |
809 | /* Helper function for c_parser_error. |
810 | Having peeked a token of kind TOK1_KIND that might signify |
811 | a conflict marker, peek successor tokens to determine |
812 | if we actually do have a conflict marker. |
813 | Specifically, we consider a run of 7 '<', '=' or '>' characters |
814 | at the start of a line as a conflict marker. |
815 | These come through the lexer as three pairs and a single, |
816 | e.g. three CPP_LSHIFT ("<<") and a CPP_LESS ('<'). |
817 | If it returns true, *OUT_LOC is written to with the location/range |
818 | of the marker. */ |
819 | |
820 | static bool |
821 | c_parser_peek_conflict_marker (c_parser *parser, enum cpp_ttype tok1_kind, |
822 | location_t *out_loc) |
823 | { |
824 | c_token *token2 = c_parser_peek_2nd_token (parser); |
825 | if (token2->type != tok1_kind) |
826 | return false; |
827 | c_token *token3 = c_parser_peek_nth_token (parser, 3); |
828 | if (token3->type != tok1_kind) |
829 | return false; |
830 | c_token *token4 = c_parser_peek_nth_token (parser, 4); |
831 | if (token4->type != conflict_marker_get_final_tok_kind (tok1_kind)) |
832 | return false; |
833 | |
834 | /* It must be at the start of the line. */ |
835 | location_t start_loc = c_parser_peek_token (parser)->location; |
836 | if (LOCATION_COLUMN (start_loc) != 1) |
837 | return false; |
838 | |
839 | /* We have a conflict marker. Construct a location of the form: |
840 | <<<<<<< |
841 | ^~~~~~~ |
842 | with start == caret, finishing at the end of the marker. */ |
843 | location_t finish_loc = get_finish (token4->location); |
844 | *out_loc = make_location (start_loc, start_loc, finish_loc); |
845 | |
846 | return true; |
847 | } |
848 | |
849 | /* Issue a diagnostic of the form |
850 | FILE:LINE: MESSAGE before TOKEN |
851 | where TOKEN is the next token in the input stream of PARSER. |
852 | MESSAGE (specified by the caller) is usually of the form "expected |
853 | OTHER-TOKEN". |
854 | |
855 | Use RICHLOC as the location of the diagnostic. |
856 | |
857 | Do not issue a diagnostic if still recovering from an error. |
858 | |
859 | Return true iff an error was actually emitted. |
860 | |
861 | ??? This is taken from the C++ parser, but building up messages in |
862 | this way is not i18n-friendly and some other approach should be |
863 | used. */ |
864 | |
865 | static bool |
866 | c_parser_error_richloc (c_parser *parser, const char *gmsgid, |
867 | rich_location *richloc) |
868 | { |
869 | c_token *token = c_parser_peek_token (parser); |
870 | if (parser->error) |
871 | return false; |
872 | parser->error = true; |
873 | if (!gmsgid) |
874 | return false; |
875 | |
876 | /* If this is actually a conflict marker, report it as such. */ |
877 | if (token->type == CPP_LSHIFT |
878 | || token->type == CPP_RSHIFT |
879 | || token->type == CPP_EQ_EQ) |
880 | { |
881 | location_t loc; |
882 | if (c_parser_peek_conflict_marker (parser, token->type, &loc)) |
883 | { |
884 | error_at (loc, "version control conflict marker in file" ); |
885 | return true; |
886 | } |
887 | } |
888 | |
889 | c_parse_error (gmsgid, |
890 | /* Because c_parse_error does not understand |
891 | CPP_KEYWORD, keywords are treated like |
892 | identifiers. */ |
893 | (token->type == CPP_KEYWORD ? CPP_NAME : token->type), |
894 | /* ??? The C parser does not save the cpp flags of a |
895 | token, we need to pass 0 here and we will not get |
896 | the source spelling of some tokens but rather the |
897 | canonical spelling. */ |
898 | token->value, /*flags=*/0, richloc); |
899 | return true; |
900 | } |
901 | |
902 | /* As c_parser_error_richloc, but issue the message at the |
903 | location of PARSER's next token, or at input_location |
904 | if the next token is EOF. */ |
905 | |
906 | bool |
907 | c_parser_error (c_parser *parser, const char *gmsgid) |
908 | { |
909 | c_token *token = c_parser_peek_token (parser); |
910 | c_parser_set_source_position_from_token (token); |
911 | rich_location richloc (line_table, input_location); |
912 | return c_parser_error_richloc (parser, gmsgid, &richloc); |
913 | } |
914 | |
915 | /* Some tokens naturally come in pairs e.g.'(' and ')'. |
916 | This class is for tracking such a matching pair of symbols. |
917 | In particular, it tracks the location of the first token, |
918 | so that if the second token is missing, we can highlight the |
919 | location of the first token when notifying the user about the |
920 | problem. */ |
921 | |
922 | template <typename traits_t> |
923 | class token_pair |
924 | { |
925 | public: |
926 | /* token_pair's ctor. */ |
927 | token_pair () : m_open_loc (UNKNOWN_LOCATION) {} |
928 | |
929 | /* If the next token is the opening symbol for this pair, consume it and |
930 | return true. |
931 | Otherwise, issue an error and return false. |
932 | In either case, record the location of the opening token. */ |
933 | |
934 | bool require_open (c_parser *parser) |
935 | { |
936 | c_token *token = c_parser_peek_token (parser); |
937 | if (token) |
938 | m_open_loc = token->location; |
939 | |
940 | return c_parser_require (parser, traits_t::open_token_type, |
941 | traits_t::open_gmsgid); |
942 | } |
943 | |
944 | /* Consume the next token from PARSER, recording its location as |
945 | that of the opening token within the pair. */ |
946 | |
947 | void consume_open (c_parser *parser) |
948 | { |
949 | c_token *token = c_parser_peek_token (parser); |
950 | gcc_assert (token->type == traits_t::open_token_type); |
951 | m_open_loc = token->location; |
952 | c_parser_consume_token (parser); |
953 | } |
954 | |
955 | /* If the next token is the closing symbol for this pair, consume it |
956 | and return true. |
957 | Otherwise, issue an error, highlighting the location of the |
958 | corresponding opening token, and return false. */ |
959 | |
960 | bool require_close (c_parser *parser) const |
961 | { |
962 | return c_parser_require (parser, traits_t::close_token_type, |
963 | traits_t::close_gmsgid, m_open_loc); |
964 | } |
965 | |
966 | /* Like token_pair::require_close, except that tokens will be skipped |
967 | until the desired token is found. An error message is still produced |
968 | if the next token is not as expected. */ |
969 | |
970 | void skip_until_found_close (c_parser *parser) const |
971 | { |
972 | c_parser_skip_until_found (parser, traits_t::close_token_type, |
973 | traits_t::close_gmsgid, m_open_loc); |
974 | } |
975 | |
976 | private: |
977 | location_t m_open_loc; |
978 | }; |
979 | |
980 | /* Traits for token_pair<T> for tracking matching pairs of parentheses. */ |
981 | |
982 | struct matching_paren_traits |
983 | { |
984 | static const enum cpp_ttype open_token_type = CPP_OPEN_PAREN; |
985 | static const char * const open_gmsgid; |
986 | static const enum cpp_ttype close_token_type = CPP_CLOSE_PAREN; |
987 | static const char * const close_gmsgid; |
988 | }; |
989 | |
990 | const char * const matching_paren_traits::open_gmsgid = "expected %<(%>" ; |
991 | const char * const matching_paren_traits::close_gmsgid = "expected %<)%>" ; |
992 | |
993 | /* "matching_parens" is a token_pair<T> class for tracking matching |
994 | pairs of parentheses. */ |
995 | |
996 | typedef token_pair<matching_paren_traits> matching_parens; |
997 | |
998 | /* Traits for token_pair<T> for tracking matching pairs of braces. */ |
999 | |
1000 | struct matching_brace_traits |
1001 | { |
1002 | static const enum cpp_ttype open_token_type = CPP_OPEN_BRACE; |
1003 | static const char * const open_gmsgid; |
1004 | static const enum cpp_ttype close_token_type = CPP_CLOSE_BRACE; |
1005 | static const char * const close_gmsgid; |
1006 | }; |
1007 | |
1008 | const char * const matching_brace_traits::open_gmsgid = "expected %<{%>" ; |
1009 | const char * const matching_brace_traits::close_gmsgid = "expected %<}%>" ; |
1010 | |
1011 | /* "matching_braces" is a token_pair<T> class for tracking matching |
1012 | pairs of braces. */ |
1013 | |
1014 | typedef token_pair<matching_brace_traits> matching_braces; |
1015 | |
1016 | /* Get a description of the matching symbol to TYPE e.g. "(" for |
1017 | CPP_CLOSE_PAREN. */ |
1018 | |
1019 | static const char * |
1020 | get_matching_symbol (enum cpp_ttype type) |
1021 | { |
1022 | switch (type) |
1023 | { |
1024 | default: |
1025 | gcc_unreachable (); |
1026 | return "" ; |
1027 | case CPP_CLOSE_PAREN: |
1028 | return "(" ; |
1029 | case CPP_CLOSE_BRACE: |
1030 | return "{" ; |
1031 | } |
1032 | } |
1033 | |
1034 | /* If the next token is of the indicated TYPE, consume it. Otherwise, |
1035 | issue the error MSGID. If MSGID is NULL then a message has already |
1036 | been produced and no message will be produced this time. Returns |
1037 | true if found, false otherwise. |
1038 | |
1039 | If MATCHING_LOCATION is not UNKNOWN_LOCATION, then highlight it |
1040 | within any error as the location of an "opening" token matching |
1041 | the close token TYPE (e.g. the location of the '(' when TYPE is |
1042 | CPP_CLOSE_PAREN). |
1043 | |
1044 | If TYPE_IS_UNIQUE is true (the default) then msgid describes exactly |
1045 | one type (e.g. "expected %<)%>") and thus it may be reasonable to |
1046 | attempt to generate a fix-it hint for the problem. |
1047 | Otherwise msgid describes multiple token types (e.g. |
1048 | "expected %<;%>, %<,%> or %<)%>"), and thus we shouldn't attempt to |
1049 | generate a fix-it hint. */ |
1050 | |
1051 | bool |
1052 | c_parser_require (c_parser *parser, |
1053 | enum cpp_ttype type, |
1054 | const char *msgid, |
1055 | location_t matching_location, |
1056 | bool type_is_unique) |
1057 | { |
1058 | if (c_parser_next_token_is (parser, type)) |
1059 | { |
1060 | c_parser_consume_token (parser); |
1061 | return true; |
1062 | } |
1063 | else |
1064 | { |
1065 | location_t next_token_loc = c_parser_peek_token (parser)->location; |
1066 | gcc_rich_location richloc (next_token_loc); |
1067 | |
1068 | /* Potentially supply a fix-it hint, suggesting to add the |
1069 | missing token immediately after the *previous* token. |
1070 | This may move the primary location within richloc. */ |
1071 | if (!parser->error && type_is_unique) |
1072 | maybe_suggest_missing_token_insertion (&richloc, type, |
1073 | parser->last_token_location); |
1074 | |
1075 | /* If matching_location != UNKNOWN_LOCATION, highlight it. |
1076 | Attempt to consolidate diagnostics by printing it as a |
1077 | secondary range within the main diagnostic. */ |
1078 | bool added_matching_location = false; |
1079 | if (matching_location != UNKNOWN_LOCATION) |
1080 | added_matching_location |
1081 | = richloc.add_location_if_nearby (matching_location); |
1082 | |
1083 | if (c_parser_error_richloc (parser, msgid, &richloc)) |
1084 | /* If we weren't able to consolidate matching_location, then |
1085 | print it as a secondary diagnostic. */ |
1086 | if (matching_location != UNKNOWN_LOCATION && !added_matching_location) |
1087 | inform (matching_location, "to match this %qs" , |
1088 | get_matching_symbol (type)); |
1089 | |
1090 | return false; |
1091 | } |
1092 | } |
1093 | |
1094 | /* If the next token is the indicated keyword, consume it. Otherwise, |
1095 | issue the error MSGID. Returns true if found, false otherwise. */ |
1096 | |
1097 | static bool |
1098 | c_parser_require_keyword (c_parser *parser, |
1099 | enum rid keyword, |
1100 | const char *msgid) |
1101 | { |
1102 | if (c_parser_next_token_is_keyword (parser, keyword)) |
1103 | { |
1104 | c_parser_consume_token (parser); |
1105 | return true; |
1106 | } |
1107 | else |
1108 | { |
1109 | c_parser_error (parser, msgid); |
1110 | return false; |
1111 | } |
1112 | } |
1113 | |
1114 | /* Like c_parser_require, except that tokens will be skipped until the |
1115 | desired token is found. An error message is still produced if the |
1116 | next token is not as expected. If MSGID is NULL then a message has |
1117 | already been produced and no message will be produced this |
1118 | time. |
1119 | |
1120 | If MATCHING_LOCATION is not UNKNOWN_LOCATION, then highlight it |
1121 | within any error as the location of an "opening" token matching |
1122 | the close token TYPE (e.g. the location of the '(' when TYPE is |
1123 | CPP_CLOSE_PAREN). */ |
1124 | |
1125 | void |
1126 | c_parser_skip_until_found (c_parser *parser, |
1127 | enum cpp_ttype type, |
1128 | const char *msgid, |
1129 | location_t matching_location) |
1130 | { |
1131 | unsigned nesting_depth = 0; |
1132 | |
1133 | if (c_parser_require (parser, type, msgid, matching_location)) |
1134 | return; |
1135 | |
1136 | /* Skip tokens until the desired token is found. */ |
1137 | while (true) |
1138 | { |
1139 | /* Peek at the next token. */ |
1140 | c_token *token = c_parser_peek_token (parser); |
1141 | /* If we've reached the token we want, consume it and stop. */ |
1142 | if (token->type == type && !nesting_depth) |
1143 | { |
1144 | c_parser_consume_token (parser); |
1145 | break; |
1146 | } |
1147 | |
1148 | /* If we've run out of tokens, stop. */ |
1149 | if (token->type == CPP_EOF) |
1150 | return; |
1151 | if (token->type == CPP_PRAGMA_EOL && parser->in_pragma) |
1152 | return; |
1153 | if (token->type == CPP_OPEN_BRACE |
1154 | || token->type == CPP_OPEN_PAREN |
1155 | || token->type == CPP_OPEN_SQUARE) |
1156 | ++nesting_depth; |
1157 | else if (token->type == CPP_CLOSE_BRACE |
1158 | || token->type == CPP_CLOSE_PAREN |
1159 | || token->type == CPP_CLOSE_SQUARE) |
1160 | { |
1161 | if (nesting_depth-- == 0) |
1162 | break; |
1163 | } |
1164 | /* Consume this token. */ |
1165 | c_parser_consume_token (parser); |
1166 | } |
1167 | parser->error = false; |
1168 | } |
1169 | |
1170 | /* Skip tokens until the end of a parameter is found, but do not |
1171 | consume the comma, semicolon or closing delimiter. */ |
1172 | |
1173 | static void |
1174 | c_parser_skip_to_end_of_parameter (c_parser *parser) |
1175 | { |
1176 | unsigned nesting_depth = 0; |
1177 | |
1178 | while (true) |
1179 | { |
1180 | c_token *token = c_parser_peek_token (parser); |
1181 | if ((token->type == CPP_COMMA || token->type == CPP_SEMICOLON) |
1182 | && !nesting_depth) |
1183 | break; |
1184 | /* If we've run out of tokens, stop. */ |
1185 | if (token->type == CPP_EOF) |
1186 | return; |
1187 | if (token->type == CPP_PRAGMA_EOL && parser->in_pragma) |
1188 | return; |
1189 | if (token->type == CPP_OPEN_BRACE |
1190 | || token->type == CPP_OPEN_PAREN |
1191 | || token->type == CPP_OPEN_SQUARE) |
1192 | ++nesting_depth; |
1193 | else if (token->type == CPP_CLOSE_BRACE |
1194 | || token->type == CPP_CLOSE_PAREN |
1195 | || token->type == CPP_CLOSE_SQUARE) |
1196 | { |
1197 | if (nesting_depth-- == 0) |
1198 | break; |
1199 | } |
1200 | /* Consume this token. */ |
1201 | c_parser_consume_token (parser); |
1202 | } |
1203 | parser->error = false; |
1204 | } |
1205 | |
1206 | /* Expect to be at the end of the pragma directive and consume an |
1207 | end of line marker. */ |
1208 | |
1209 | static void |
1210 | c_parser_skip_to_pragma_eol (c_parser *parser, bool error_if_not_eol = true) |
1211 | { |
1212 | gcc_assert (parser->in_pragma); |
1213 | parser->in_pragma = false; |
1214 | |
1215 | if (error_if_not_eol && c_parser_peek_token (parser)->type != CPP_PRAGMA_EOL) |
1216 | c_parser_error (parser, "expected end of line" ); |
1217 | |
1218 | cpp_ttype token_type; |
1219 | do |
1220 | { |
1221 | c_token *token = c_parser_peek_token (parser); |
1222 | token_type = token->type; |
1223 | if (token_type == CPP_EOF) |
1224 | break; |
1225 | c_parser_consume_token (parser); |
1226 | } |
1227 | while (token_type != CPP_PRAGMA_EOL); |
1228 | |
1229 | parser->error = false; |
1230 | } |
1231 | |
1232 | /* Skip tokens until we have consumed an entire block, or until we |
1233 | have consumed a non-nested ';'. */ |
1234 | |
1235 | static void |
1236 | c_parser_skip_to_end_of_block_or_statement (c_parser *parser) |
1237 | { |
1238 | unsigned nesting_depth = 0; |
1239 | bool save_error = parser->error; |
1240 | |
1241 | while (true) |
1242 | { |
1243 | c_token *token; |
1244 | |
1245 | /* Peek at the next token. */ |
1246 | token = c_parser_peek_token (parser); |
1247 | |
1248 | switch (token->type) |
1249 | { |
1250 | case CPP_EOF: |
1251 | return; |
1252 | |
1253 | case CPP_PRAGMA_EOL: |
1254 | if (parser->in_pragma) |
1255 | return; |
1256 | break; |
1257 | |
1258 | case CPP_SEMICOLON: |
1259 | /* If the next token is a ';', we have reached the |
1260 | end of the statement. */ |
1261 | if (!nesting_depth) |
1262 | { |
1263 | /* Consume the ';'. */ |
1264 | c_parser_consume_token (parser); |
1265 | goto finished; |
1266 | } |
1267 | break; |
1268 | |
1269 | case CPP_CLOSE_BRACE: |
1270 | /* If the next token is a non-nested '}', then we have |
1271 | reached the end of the current block. */ |
1272 | if (nesting_depth == 0 || --nesting_depth == 0) |
1273 | { |
1274 | c_parser_consume_token (parser); |
1275 | goto finished; |
1276 | } |
1277 | break; |
1278 | |
1279 | case CPP_OPEN_BRACE: |
1280 | /* If it the next token is a '{', then we are entering a new |
1281 | block. Consume the entire block. */ |
1282 | ++nesting_depth; |
1283 | break; |
1284 | |
1285 | case CPP_PRAGMA: |
1286 | /* If we see a pragma, consume the whole thing at once. We |
1287 | have some safeguards against consuming pragmas willy-nilly. |
1288 | Normally, we'd expect to be here with parser->error set, |
1289 | which disables these safeguards. But it's possible to get |
1290 | here for secondary error recovery, after parser->error has |
1291 | been cleared. */ |
1292 | c_parser_consume_pragma (parser); |
1293 | c_parser_skip_to_pragma_eol (parser); |
1294 | parser->error = save_error; |
1295 | continue; |
1296 | |
1297 | default: |
1298 | break; |
1299 | } |
1300 | |
1301 | c_parser_consume_token (parser); |
1302 | } |
1303 | |
1304 | finished: |
1305 | parser->error = false; |
1306 | } |
1307 | |
1308 | /* CPP's options (initialized by c-opts.c). */ |
1309 | extern cpp_options *cpp_opts; |
1310 | |
1311 | /* Save the warning flags which are controlled by __extension__. */ |
1312 | |
1313 | static inline int |
1314 | disable_extension_diagnostics (void) |
1315 | { |
1316 | int ret = (pedantic |
1317 | | (warn_pointer_arith << 1) |
1318 | | (warn_traditional << 2) |
1319 | | (flag_iso << 3) |
1320 | | (warn_long_long << 4) |
1321 | | (warn_cxx_compat << 5) |
1322 | | (warn_overlength_strings << 6) |
1323 | /* warn_c90_c99_compat has three states: -1/0/1, so we must |
1324 | play tricks to properly restore it. */ |
1325 | | ((warn_c90_c99_compat == 1) << 7) |
1326 | | ((warn_c90_c99_compat == -1) << 8) |
1327 | /* Similarly for warn_c99_c11_compat. */ |
1328 | | ((warn_c99_c11_compat == 1) << 9) |
1329 | | ((warn_c99_c11_compat == -1) << 10) |
1330 | ); |
1331 | cpp_opts->cpp_pedantic = pedantic = 0; |
1332 | warn_pointer_arith = 0; |
1333 | cpp_opts->cpp_warn_traditional = warn_traditional = 0; |
1334 | flag_iso = 0; |
1335 | cpp_opts->cpp_warn_long_long = warn_long_long = 0; |
1336 | warn_cxx_compat = 0; |
1337 | warn_overlength_strings = 0; |
1338 | warn_c90_c99_compat = 0; |
1339 | warn_c99_c11_compat = 0; |
1340 | return ret; |
1341 | } |
1342 | |
1343 | /* Restore the warning flags which are controlled by __extension__. |
1344 | FLAGS is the return value from disable_extension_diagnostics. */ |
1345 | |
1346 | static inline void |
1347 | restore_extension_diagnostics (int flags) |
1348 | { |
1349 | cpp_opts->cpp_pedantic = pedantic = flags & 1; |
1350 | warn_pointer_arith = (flags >> 1) & 1; |
1351 | cpp_opts->cpp_warn_traditional = warn_traditional = (flags >> 2) & 1; |
1352 | flag_iso = (flags >> 3) & 1; |
1353 | cpp_opts->cpp_warn_long_long = warn_long_long = (flags >> 4) & 1; |
1354 | warn_cxx_compat = (flags >> 5) & 1; |
1355 | warn_overlength_strings = (flags >> 6) & 1; |
1356 | /* See above for why is this needed. */ |
1357 | warn_c90_c99_compat = (flags >> 7) & 1 ? 1 : ((flags >> 8) & 1 ? -1 : 0); |
1358 | warn_c99_c11_compat = (flags >> 9) & 1 ? 1 : ((flags >> 10) & 1 ? -1 : 0); |
1359 | } |
1360 | |
1361 | /* Helper data structure for parsing #pragma acc routine. */ |
1362 | struct oacc_routine_data { |
1363 | bool error_seen; /* Set if error has been reported. */ |
1364 | bool fndecl_seen; /* Set if one fn decl/definition has been seen already. */ |
1365 | tree clauses; |
1366 | location_t loc; |
1367 | }; |
1368 | |
1369 | static void c_parser_external_declaration (c_parser *); |
1370 | static void c_parser_asm_definition (c_parser *); |
1371 | static void c_parser_declaration_or_fndef (c_parser *, bool, bool, bool, |
1372 | bool, bool, tree *, vec<c_token>, |
1373 | struct oacc_routine_data * = NULL, |
1374 | bool * = NULL); |
1375 | static void c_parser_static_assert_declaration_no_semi (c_parser *); |
1376 | static void c_parser_static_assert_declaration (c_parser *); |
1377 | static struct c_typespec c_parser_enum_specifier (c_parser *); |
1378 | static struct c_typespec c_parser_struct_or_union_specifier (c_parser *); |
1379 | static tree c_parser_struct_declaration (c_parser *); |
1380 | static struct c_typespec c_parser_typeof_specifier (c_parser *); |
1381 | static tree c_parser_alignas_specifier (c_parser *); |
1382 | static struct c_declarator *c_parser_direct_declarator (c_parser *, bool, |
1383 | c_dtr_syn, bool *); |
1384 | static struct c_declarator *c_parser_direct_declarator_inner (c_parser *, |
1385 | bool, |
1386 | struct c_declarator *); |
1387 | static struct c_arg_info *c_parser_parms_declarator (c_parser *, bool, tree); |
1388 | static struct c_arg_info *c_parser_parms_list_declarator (c_parser *, tree, |
1389 | tree); |
1390 | static struct c_parm *c_parser_parameter_declaration (c_parser *, tree); |
1391 | static tree c_parser_simple_asm_expr (c_parser *); |
1392 | static tree c_parser_attributes (c_parser *); |
1393 | static struct c_expr c_parser_initializer (c_parser *); |
1394 | static struct c_expr c_parser_braced_init (c_parser *, tree, bool, |
1395 | struct obstack *); |
1396 | static void c_parser_initelt (c_parser *, struct obstack *); |
1397 | static void c_parser_initval (c_parser *, struct c_expr *, |
1398 | struct obstack *); |
1399 | static tree c_parser_compound_statement (c_parser *); |
1400 | static void c_parser_compound_statement_nostart (c_parser *); |
1401 | static void c_parser_label (c_parser *); |
1402 | static void c_parser_statement (c_parser *, bool *, location_t * = NULL); |
1403 | static void c_parser_statement_after_labels (c_parser *, bool *, |
1404 | vec<tree> * = NULL); |
1405 | static tree c_parser_c99_block_statement (c_parser *, bool *, |
1406 | location_t * = NULL); |
1407 | static void c_parser_if_statement (c_parser *, bool *, vec<tree> *); |
1408 | static void c_parser_switch_statement (c_parser *, bool *); |
1409 | static void c_parser_while_statement (c_parser *, bool, bool *); |
1410 | static void c_parser_do_statement (c_parser *, bool); |
1411 | static void c_parser_for_statement (c_parser *, bool, bool *); |
1412 | static tree c_parser_asm_statement (c_parser *); |
1413 | static tree c_parser_asm_operands (c_parser *); |
1414 | static tree c_parser_asm_goto_operands (c_parser *); |
1415 | static tree c_parser_asm_clobbers (c_parser *); |
1416 | static struct c_expr c_parser_expr_no_commas (c_parser *, struct c_expr *, |
1417 | tree = NULL_TREE); |
1418 | static struct c_expr c_parser_conditional_expression (c_parser *, |
1419 | struct c_expr *, tree); |
1420 | static struct c_expr c_parser_binary_expression (c_parser *, struct c_expr *, |
1421 | tree); |
1422 | static struct c_expr c_parser_cast_expression (c_parser *, struct c_expr *); |
1423 | static struct c_expr c_parser_unary_expression (c_parser *); |
1424 | static struct c_expr c_parser_sizeof_expression (c_parser *); |
1425 | static struct c_expr c_parser_alignof_expression (c_parser *); |
1426 | static struct c_expr c_parser_postfix_expression (c_parser *); |
1427 | static struct c_expr c_parser_postfix_expression_after_paren_type (c_parser *, |
1428 | struct c_type_name *, |
1429 | location_t); |
1430 | static struct c_expr c_parser_postfix_expression_after_primary (c_parser *, |
1431 | location_t loc, |
1432 | struct c_expr); |
1433 | static tree c_parser_transaction (c_parser *, enum rid); |
1434 | static struct c_expr c_parser_transaction_expression (c_parser *, enum rid); |
1435 | static tree c_parser_transaction_cancel (c_parser *); |
1436 | static struct c_expr c_parser_expression (c_parser *); |
1437 | static struct c_expr c_parser_expression_conv (c_parser *); |
1438 | static vec<tree, va_gc> *c_parser_expr_list (c_parser *, bool, bool, |
1439 | vec<tree, va_gc> **, location_t *, |
1440 | tree *, vec<location_t> *, |
1441 | unsigned int * = NULL); |
1442 | static void c_parser_oacc_declare (c_parser *); |
1443 | static void c_parser_oacc_enter_exit_data (c_parser *, bool); |
1444 | static void c_parser_oacc_update (c_parser *); |
1445 | static void c_parser_omp_construct (c_parser *, bool *); |
1446 | static void c_parser_omp_threadprivate (c_parser *); |
1447 | static void c_parser_omp_barrier (c_parser *); |
1448 | static void c_parser_omp_flush (c_parser *); |
1449 | static tree c_parser_omp_for_loop (location_t, c_parser *, enum tree_code, |
1450 | tree, tree *, bool *); |
1451 | static void c_parser_omp_taskwait (c_parser *); |
1452 | static void c_parser_omp_taskyield (c_parser *); |
1453 | static void c_parser_omp_cancel (c_parser *); |
1454 | |
1455 | enum pragma_context { pragma_external, pragma_struct, pragma_param, |
1456 | pragma_stmt, pragma_compound }; |
1457 | static bool c_parser_pragma (c_parser *, enum pragma_context, bool *); |
1458 | static void c_parser_omp_cancellation_point (c_parser *, enum pragma_context); |
1459 | static bool c_parser_omp_target (c_parser *, enum pragma_context, bool *); |
1460 | static void c_parser_omp_end_declare_target (c_parser *); |
1461 | static void c_parser_omp_declare (c_parser *, enum pragma_context); |
1462 | static bool c_parser_omp_ordered (c_parser *, enum pragma_context, bool *); |
1463 | static void c_parser_oacc_routine (c_parser *, enum pragma_context); |
1464 | |
1465 | /* These Objective-C parser functions are only ever called when |
1466 | compiling Objective-C. */ |
1467 | static void c_parser_objc_class_definition (c_parser *, tree); |
1468 | static void c_parser_objc_class_instance_variables (c_parser *); |
1469 | static void c_parser_objc_class_declaration (c_parser *); |
1470 | static void c_parser_objc_alias_declaration (c_parser *); |
1471 | static void c_parser_objc_protocol_definition (c_parser *, tree); |
1472 | static bool c_parser_objc_method_type (c_parser *); |
1473 | static void c_parser_objc_method_definition (c_parser *); |
1474 | static void c_parser_objc_methodprotolist (c_parser *); |
1475 | static void c_parser_objc_methodproto (c_parser *); |
1476 | static tree c_parser_objc_method_decl (c_parser *, bool, tree *, tree *); |
1477 | static tree c_parser_objc_type_name (c_parser *); |
1478 | static tree c_parser_objc_protocol_refs (c_parser *); |
1479 | static void c_parser_objc_try_catch_finally_statement (c_parser *); |
1480 | static void c_parser_objc_synchronized_statement (c_parser *); |
1481 | static tree c_parser_objc_selector (c_parser *); |
1482 | static tree c_parser_objc_selector_arg (c_parser *); |
1483 | static tree c_parser_objc_receiver (c_parser *); |
1484 | static tree c_parser_objc_message_args (c_parser *); |
1485 | static tree c_parser_objc_keywordexpr (c_parser *); |
1486 | static void c_parser_objc_at_property_declaration (c_parser *); |
1487 | static void c_parser_objc_at_synthesize_declaration (c_parser *); |
1488 | static void c_parser_objc_at_dynamic_declaration (c_parser *); |
1489 | static bool c_parser_objc_diagnose_bad_element_prefix |
1490 | (c_parser *, struct c_declspecs *); |
1491 | |
1492 | static void c_parser_parse_rtl_body (c_parser *parser, char *start_with_pass); |
1493 | |
1494 | /* Parse a translation unit (C90 6.7, C99 6.9, C11 6.9). |
1495 | |
1496 | translation-unit: |
1497 | external-declarations |
1498 | |
1499 | external-declarations: |
1500 | external-declaration |
1501 | external-declarations external-declaration |
1502 | |
1503 | GNU extensions: |
1504 | |
1505 | translation-unit: |
1506 | empty |
1507 | */ |
1508 | |
1509 | static void |
1510 | c_parser_translation_unit (c_parser *parser) |
1511 | { |
1512 | if (c_parser_next_token_is (parser, CPP_EOF)) |
1513 | { |
1514 | pedwarn (c_parser_peek_token (parser)->location, OPT_Wpedantic, |
1515 | "ISO C forbids an empty translation unit" ); |
1516 | } |
1517 | else |
1518 | { |
1519 | void *obstack_position = obstack_alloc (&parser_obstack, 0); |
1520 | mark_valid_location_for_stdc_pragma (false); |
1521 | do |
1522 | { |
1523 | ggc_collect (); |
1524 | c_parser_external_declaration (parser); |
1525 | obstack_free (&parser_obstack, obstack_position); |
1526 | } |
1527 | while (c_parser_next_token_is_not (parser, CPP_EOF)); |
1528 | } |
1529 | |
1530 | unsigned int i; |
1531 | tree decl; |
1532 | FOR_EACH_VEC_ELT (incomplete_record_decls, i, decl) |
1533 | if (DECL_SIZE (decl) == NULL_TREE && TREE_TYPE (decl) != error_mark_node) |
1534 | error ("storage size of %q+D isn%'t known" , decl); |
1535 | } |
1536 | |
1537 | /* Parse an external declaration (C90 6.7, C99 6.9, C11 6.9). |
1538 | |
1539 | external-declaration: |
1540 | function-definition |
1541 | declaration |
1542 | |
1543 | GNU extensions: |
1544 | |
1545 | external-declaration: |
1546 | asm-definition |
1547 | ; |
1548 | __extension__ external-declaration |
1549 | |
1550 | Objective-C: |
1551 | |
1552 | external-declaration: |
1553 | objc-class-definition |
1554 | objc-class-declaration |
1555 | objc-alias-declaration |
1556 | objc-protocol-definition |
1557 | objc-method-definition |
1558 | @end |
1559 | */ |
1560 | |
1561 | static void |
1562 | c_parser_external_declaration (c_parser *parser) |
1563 | { |
1564 | int ext; |
1565 | switch (c_parser_peek_token (parser)->type) |
1566 | { |
1567 | case CPP_KEYWORD: |
1568 | switch (c_parser_peek_token (parser)->keyword) |
1569 | { |
1570 | case RID_EXTENSION: |
1571 | ext = disable_extension_diagnostics (); |
1572 | c_parser_consume_token (parser); |
1573 | c_parser_external_declaration (parser); |
1574 | restore_extension_diagnostics (ext); |
1575 | break; |
1576 | case RID_ASM: |
1577 | c_parser_asm_definition (parser); |
1578 | break; |
1579 | case RID_AT_INTERFACE: |
1580 | case RID_AT_IMPLEMENTATION: |
1581 | gcc_assert (c_dialect_objc ()); |
1582 | c_parser_objc_class_definition (parser, NULL_TREE); |
1583 | break; |
1584 | case RID_AT_CLASS: |
1585 | gcc_assert (c_dialect_objc ()); |
1586 | c_parser_objc_class_declaration (parser); |
1587 | break; |
1588 | case RID_AT_ALIAS: |
1589 | gcc_assert (c_dialect_objc ()); |
1590 | c_parser_objc_alias_declaration (parser); |
1591 | break; |
1592 | case RID_AT_PROTOCOL: |
1593 | gcc_assert (c_dialect_objc ()); |
1594 | c_parser_objc_protocol_definition (parser, NULL_TREE); |
1595 | break; |
1596 | case RID_AT_PROPERTY: |
1597 | gcc_assert (c_dialect_objc ()); |
1598 | c_parser_objc_at_property_declaration (parser); |
1599 | break; |
1600 | case RID_AT_SYNTHESIZE: |
1601 | gcc_assert (c_dialect_objc ()); |
1602 | c_parser_objc_at_synthesize_declaration (parser); |
1603 | break; |
1604 | case RID_AT_DYNAMIC: |
1605 | gcc_assert (c_dialect_objc ()); |
1606 | c_parser_objc_at_dynamic_declaration (parser); |
1607 | break; |
1608 | case RID_AT_END: |
1609 | gcc_assert (c_dialect_objc ()); |
1610 | c_parser_consume_token (parser); |
1611 | objc_finish_implementation (); |
1612 | break; |
1613 | default: |
1614 | goto decl_or_fndef; |
1615 | } |
1616 | break; |
1617 | case CPP_SEMICOLON: |
1618 | pedwarn (c_parser_peek_token (parser)->location, OPT_Wpedantic, |
1619 | "ISO C does not allow extra %<;%> outside of a function" ); |
1620 | c_parser_consume_token (parser); |
1621 | break; |
1622 | case CPP_PRAGMA: |
1623 | mark_valid_location_for_stdc_pragma (true); |
1624 | c_parser_pragma (parser, pragma_external, NULL); |
1625 | mark_valid_location_for_stdc_pragma (false); |
1626 | break; |
1627 | case CPP_PLUS: |
1628 | case CPP_MINUS: |
1629 | if (c_dialect_objc ()) |
1630 | { |
1631 | c_parser_objc_method_definition (parser); |
1632 | break; |
1633 | } |
1634 | /* Else fall through, and yield a syntax error trying to parse |
1635 | as a declaration or function definition. */ |
1636 | /* FALLTHRU */ |
1637 | default: |
1638 | decl_or_fndef: |
1639 | /* A declaration or a function definition (or, in Objective-C, |
1640 | an @interface or @protocol with prefix attributes). We can |
1641 | only tell which after parsing the declaration specifiers, if |
1642 | any, and the first declarator. */ |
1643 | c_parser_declaration_or_fndef (parser, true, true, true, false, true, |
1644 | NULL, vNULL); |
1645 | break; |
1646 | } |
1647 | } |
1648 | |
1649 | static void c_finish_omp_declare_simd (c_parser *, tree, tree, vec<c_token>); |
1650 | static void c_finish_oacc_routine (struct oacc_routine_data *, tree, bool); |
1651 | |
1652 | /* Build and add a DEBUG_BEGIN_STMT statement with location LOC. */ |
1653 | |
1654 | static void |
1655 | add_debug_begin_stmt (location_t loc) |
1656 | { |
1657 | if (!MAY_HAVE_DEBUG_MARKER_STMTS) |
1658 | return; |
1659 | |
1660 | tree stmt = build0 (DEBUG_BEGIN_STMT, void_type_node); |
1661 | SET_EXPR_LOCATION (stmt, loc); |
1662 | add_stmt (stmt); |
1663 | } |
1664 | |
1665 | /* Parse a declaration or function definition (C90 6.5, 6.7.1, C99 |
1666 | 6.7, 6.9.1, C11 6.7, 6.9.1). If FNDEF_OK is true, a function definition |
1667 | is accepted; otherwise (old-style parameter declarations) only other |
1668 | declarations are accepted. If STATIC_ASSERT_OK is true, a static |
1669 | assertion is accepted; otherwise (old-style parameter declarations) |
1670 | it is not. If NESTED is true, we are inside a function or parsing |
1671 | old-style parameter declarations; any functions encountered are |
1672 | nested functions and declaration specifiers are required; otherwise |
1673 | we are at top level and functions are normal functions and |
1674 | declaration specifiers may be optional. If EMPTY_OK is true, empty |
1675 | declarations are OK (subject to all other constraints); otherwise |
1676 | (old-style parameter declarations) they are diagnosed. If |
1677 | START_ATTR_OK is true, the declaration specifiers may start with |
1678 | attributes; otherwise they may not. |
1679 | OBJC_FOREACH_OBJECT_DECLARATION can be used to get back the parsed |
1680 | declaration when parsing an Objective-C foreach statement. |
1681 | FALLTHRU_ATTR_P is used to signal whether this function parsed |
1682 | "__attribute__((fallthrough));". |
1683 | |
1684 | declaration: |
1685 | declaration-specifiers init-declarator-list[opt] ; |
1686 | static_assert-declaration |
1687 | |
1688 | function-definition: |
1689 | declaration-specifiers[opt] declarator declaration-list[opt] |
1690 | compound-statement |
1691 | |
1692 | declaration-list: |
1693 | declaration |
1694 | declaration-list declaration |
1695 | |
1696 | init-declarator-list: |
1697 | init-declarator |
1698 | init-declarator-list , init-declarator |
1699 | |
1700 | init-declarator: |
1701 | declarator simple-asm-expr[opt] attributes[opt] |
1702 | declarator simple-asm-expr[opt] attributes[opt] = initializer |
1703 | |
1704 | GNU extensions: |
1705 | |
1706 | nested-function-definition: |
1707 | declaration-specifiers declarator declaration-list[opt] |
1708 | compound-statement |
1709 | |
1710 | attribute ; |
1711 | |
1712 | Objective-C: |
1713 | attributes objc-class-definition |
1714 | attributes objc-category-definition |
1715 | attributes objc-protocol-definition |
1716 | |
1717 | The simple-asm-expr and attributes are GNU extensions. |
1718 | |
1719 | This function does not handle __extension__; that is handled in its |
1720 | callers. ??? Following the old parser, __extension__ may start |
1721 | external declarations, declarations in functions and declarations |
1722 | at the start of "for" loops, but not old-style parameter |
1723 | declarations. |
1724 | |
1725 | C99 requires declaration specifiers in a function definition; the |
1726 | absence is diagnosed through the diagnosis of implicit int. In GNU |
1727 | C we also allow but diagnose declarations without declaration |
1728 | specifiers, but only at top level (elsewhere they conflict with |
1729 | other syntax). |
1730 | |
1731 | In Objective-C, declarations of the looping variable in a foreach |
1732 | statement are exceptionally terminated by 'in' (for example, 'for |
1733 | (NSObject *object in array) { ... }'). |
1734 | |
1735 | OpenMP: |
1736 | |
1737 | declaration: |
1738 | threadprivate-directive |
1739 | |
1740 | GIMPLE: |
1741 | |
1742 | gimple-function-definition: |
1743 | declaration-specifiers[opt] __GIMPLE (gimple-or-rtl-pass-list) declarator |
1744 | declaration-list[opt] compound-statement |
1745 | |
1746 | rtl-function-definition: |
1747 | declaration-specifiers[opt] __RTL (gimple-or-rtl-pass-list) declarator |
1748 | declaration-list[opt] compound-statement */ |
1749 | |
1750 | static void |
1751 | c_parser_declaration_or_fndef (c_parser *parser, bool fndef_ok, |
1752 | bool static_assert_ok, bool empty_ok, |
1753 | bool nested, bool start_attr_ok, |
1754 | tree *objc_foreach_object_declaration, |
1755 | vec<c_token> omp_declare_simd_clauses, |
1756 | struct oacc_routine_data *oacc_routine_data, |
1757 | bool *fallthru_attr_p) |
1758 | { |
1759 | struct c_declspecs *specs; |
1760 | tree prefix_attrs; |
1761 | tree all_prefix_attrs; |
1762 | bool diagnosed_no_specs = false; |
1763 | location_t here = c_parser_peek_token (parser)->location; |
1764 | |
1765 | add_debug_begin_stmt (c_parser_peek_token (parser)->location); |
1766 | |
1767 | if (static_assert_ok |
1768 | && c_parser_next_token_is_keyword (parser, RID_STATIC_ASSERT)) |
1769 | { |
1770 | c_parser_static_assert_declaration (parser); |
1771 | return; |
1772 | } |
1773 | specs = build_null_declspecs (); |
1774 | |
1775 | /* Try to detect an unknown type name when we have "A B" or "A *B". */ |
1776 | if (c_parser_peek_token (parser)->type == CPP_NAME |
1777 | && c_parser_peek_token (parser)->id_kind == C_ID_ID |
1778 | && (c_parser_peek_2nd_token (parser)->type == CPP_NAME |
1779 | || c_parser_peek_2nd_token (parser)->type == CPP_MULT) |
1780 | && (!nested || !lookup_name (c_parser_peek_token (parser)->value))) |
1781 | { |
1782 | tree name = c_parser_peek_token (parser)->value; |
1783 | |
1784 | /* Issue a warning about NAME being an unknown type name, perhaps |
1785 | with some kind of hint. |
1786 | If the user forgot a "struct" etc, suggest inserting |
1787 | it. Otherwise, attempt to look for misspellings. */ |
1788 | gcc_rich_location richloc (here); |
1789 | if (tag_exists_p (RECORD_TYPE, name)) |
1790 | { |
1791 | /* This is not C++ with its implicit typedef. */ |
1792 | richloc.add_fixit_insert_before ("struct " ); |
1793 | error_at (&richloc, |
1794 | "unknown type name %qE;" |
1795 | " use %<struct%> keyword to refer to the type" , |
1796 | name); |
1797 | } |
1798 | else if (tag_exists_p (UNION_TYPE, name)) |
1799 | { |
1800 | richloc.add_fixit_insert_before ("union " ); |
1801 | error_at (&richloc, |
1802 | "unknown type name %qE;" |
1803 | " use %<union%> keyword to refer to the type" , |
1804 | name); |
1805 | } |
1806 | else if (tag_exists_p (ENUMERAL_TYPE, name)) |
1807 | { |
1808 | richloc.add_fixit_insert_before ("enum " ); |
1809 | error_at (&richloc, |
1810 | "unknown type name %qE;" |
1811 | " use %<enum%> keyword to refer to the type" , |
1812 | name); |
1813 | } |
1814 | else |
1815 | { |
1816 | name_hint hint = lookup_name_fuzzy (name, FUZZY_LOOKUP_TYPENAME, |
1817 | here); |
1818 | if (hint) |
1819 | { |
1820 | richloc.add_fixit_replace (hint.suggestion ()); |
1821 | error_at (&richloc, |
1822 | "unknown type name %qE; did you mean %qs?" , |
1823 | name, hint.suggestion ()); |
1824 | } |
1825 | else |
1826 | error_at (here, "unknown type name %qE" , name); |
1827 | } |
1828 | |
1829 | /* Parse declspecs normally to get a correct pointer type, but avoid |
1830 | a further "fails to be a type name" error. Refuse nested functions |
1831 | since it is not how the user likely wants us to recover. */ |
1832 | c_parser_peek_token (parser)->type = CPP_KEYWORD; |
1833 | c_parser_peek_token (parser)->keyword = RID_VOID; |
1834 | c_parser_peek_token (parser)->value = error_mark_node; |
1835 | fndef_ok = !nested; |
1836 | } |
1837 | |
1838 | c_parser_declspecs (parser, specs, true, true, start_attr_ok, |
1839 | true, true, cla_nonabstract_decl); |
1840 | if (parser->error) |
1841 | { |
1842 | c_parser_skip_to_end_of_block_or_statement (parser); |
1843 | return; |
1844 | } |
1845 | if (nested && !specs->declspecs_seen_p) |
1846 | { |
1847 | c_parser_error (parser, "expected declaration specifiers" ); |
1848 | c_parser_skip_to_end_of_block_or_statement (parser); |
1849 | return; |
1850 | } |
1851 | |
1852 | finish_declspecs (specs); |
1853 | bool auto_type_p = specs->typespec_word == cts_auto_type; |
1854 | if (c_parser_next_token_is (parser, CPP_SEMICOLON)) |
1855 | { |
1856 | if (auto_type_p) |
1857 | error_at (here, "%<__auto_type%> in empty declaration" ); |
1858 | else if (specs->typespec_kind == ctsk_none |
1859 | && attribute_fallthrough_p (specs->attrs)) |
1860 | { |
1861 | if (fallthru_attr_p != NULL) |
1862 | *fallthru_attr_p = true; |
1863 | tree fn = build_call_expr_internal_loc (here, IFN_FALLTHROUGH, |
1864 | void_type_node, 0); |
1865 | add_stmt (fn); |
1866 | } |
1867 | else if (empty_ok) |
1868 | shadow_tag (specs); |
1869 | else |
1870 | { |
1871 | shadow_tag_warned (specs, 1); |
1872 | pedwarn (here, 0, "empty declaration" ); |
1873 | } |
1874 | c_parser_consume_token (parser); |
1875 | if (oacc_routine_data) |
1876 | c_finish_oacc_routine (oacc_routine_data, NULL_TREE, false); |
1877 | return; |
1878 | } |
1879 | |
1880 | /* Provide better error recovery. Note that a type name here is usually |
1881 | better diagnosed as a redeclaration. */ |
1882 | if (empty_ok |
1883 | && specs->typespec_kind == ctsk_tagdef |
1884 | && c_parser_next_token_starts_declspecs (parser) |
1885 | && !c_parser_next_token_is (parser, CPP_NAME)) |
1886 | { |
1887 | c_parser_error (parser, "expected %<;%>, identifier or %<(%>" ); |
1888 | parser->error = false; |
1889 | shadow_tag_warned (specs, 1); |
1890 | return; |
1891 | } |
1892 | else if (c_dialect_objc () && !auto_type_p) |
1893 | { |
1894 | /* Prefix attributes are an error on method decls. */ |
1895 | switch (c_parser_peek_token (parser)->type) |
1896 | { |
1897 | case CPP_PLUS: |
1898 | case CPP_MINUS: |
1899 | if (c_parser_objc_diagnose_bad_element_prefix (parser, specs)) |
1900 | return; |
1901 | if (specs->attrs) |
1902 | { |
1903 | warning_at (c_parser_peek_token (parser)->location, |
1904 | OPT_Wattributes, |
1905 | "prefix attributes are ignored for methods" ); |
1906 | specs->attrs = NULL_TREE; |
1907 | } |
1908 | if (fndef_ok) |
1909 | c_parser_objc_method_definition (parser); |
1910 | else |
1911 | c_parser_objc_methodproto (parser); |
1912 | return; |
1913 | break; |
1914 | default: |
1915 | break; |
1916 | } |
1917 | /* This is where we parse 'attributes @interface ...', |
1918 | 'attributes @implementation ...', 'attributes @protocol ...' |
1919 | (where attributes could be, for example, __attribute__ |
1920 | ((deprecated)). |
1921 | */ |
1922 | switch (c_parser_peek_token (parser)->keyword) |
1923 | { |
1924 | case RID_AT_INTERFACE: |
1925 | { |
1926 | if (c_parser_objc_diagnose_bad_element_prefix (parser, specs)) |
1927 | return; |
1928 | c_parser_objc_class_definition (parser, specs->attrs); |
1929 | return; |
1930 | } |
1931 | break; |
1932 | case RID_AT_IMPLEMENTATION: |
1933 | { |
1934 | if (c_parser_objc_diagnose_bad_element_prefix (parser, specs)) |
1935 | return; |
1936 | if (specs->attrs) |
1937 | { |
1938 | warning_at (c_parser_peek_token (parser)->location, |
1939 | OPT_Wattributes, |
1940 | "prefix attributes are ignored for implementations" ); |
1941 | specs->attrs = NULL_TREE; |
1942 | } |
1943 | c_parser_objc_class_definition (parser, NULL_TREE); |
1944 | return; |
1945 | } |
1946 | break; |
1947 | case RID_AT_PROTOCOL: |
1948 | { |
1949 | if (c_parser_objc_diagnose_bad_element_prefix (parser, specs)) |
1950 | return; |
1951 | c_parser_objc_protocol_definition (parser, specs->attrs); |
1952 | return; |
1953 | } |
1954 | break; |
1955 | case RID_AT_ALIAS: |
1956 | case RID_AT_CLASS: |
1957 | case RID_AT_END: |
1958 | case RID_AT_PROPERTY: |
1959 | if (specs->attrs) |
1960 | { |
1961 | c_parser_error (parser, "unexpected attribute" ); |
1962 | specs->attrs = NULL; |
1963 | } |
1964 | break; |
1965 | default: |
1966 | break; |
1967 | } |
1968 | } |
1969 | else if (attribute_fallthrough_p (specs->attrs)) |
1970 | warning_at (here, OPT_Wattributes, |
1971 | "%<fallthrough%> attribute not followed by %<;%>" ); |
1972 | |
1973 | pending_xref_error (); |
1974 | prefix_attrs = specs->attrs; |
1975 | all_prefix_attrs = prefix_attrs; |
1976 | specs->attrs = NULL_TREE; |
1977 | while (true) |
1978 | { |
1979 | struct c_declarator *declarator; |
1980 | bool dummy = false; |
1981 | timevar_id_t tv; |
1982 | tree fnbody = NULL_TREE; |
1983 | /* Declaring either one or more declarators (in which case we |
1984 | should diagnose if there were no declaration specifiers) or a |
1985 | function definition (in which case the diagnostic for |
1986 | implicit int suffices). */ |
1987 | declarator = c_parser_declarator (parser, |
1988 | specs->typespec_kind != ctsk_none, |
1989 | C_DTR_NORMAL, &dummy); |
1990 | if (declarator == NULL) |
1991 | { |
1992 | if (omp_declare_simd_clauses.exists ()) |
1993 | c_finish_omp_declare_simd (parser, NULL_TREE, NULL_TREE, |
1994 | omp_declare_simd_clauses); |
1995 | if (oacc_routine_data) |
1996 | c_finish_oacc_routine (oacc_routine_data, NULL_TREE, false); |
1997 | c_parser_skip_to_end_of_block_or_statement (parser); |
1998 | return; |
1999 | } |
2000 | if (auto_type_p && declarator->kind != cdk_id) |
2001 | { |
2002 | error_at (here, |
2003 | "%<__auto_type%> requires a plain identifier" |
2004 | " as declarator" ); |
2005 | c_parser_skip_to_end_of_block_or_statement (parser); |
2006 | return; |
2007 | } |
2008 | if (c_parser_next_token_is (parser, CPP_EQ) |
2009 | || c_parser_next_token_is (parser, CPP_COMMA) |
2010 | || c_parser_next_token_is (parser, CPP_SEMICOLON) |
2011 | || c_parser_next_token_is_keyword (parser, RID_ASM) |
2012 | || c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE) |
2013 | || c_parser_next_token_is_keyword (parser, RID_IN)) |
2014 | { |
2015 | tree asm_name = NULL_TREE; |
2016 | tree postfix_attrs = NULL_TREE; |
2017 | if (!diagnosed_no_specs && !specs->declspecs_seen_p) |
2018 | { |
2019 | diagnosed_no_specs = true; |
2020 | pedwarn (here, 0, "data definition has no type or storage class" ); |
2021 | } |
2022 | /* Having seen a data definition, there cannot now be a |
2023 | function definition. */ |
2024 | fndef_ok = false; |
2025 | if (c_parser_next_token_is_keyword (parser, RID_ASM)) |
2026 | asm_name = c_parser_simple_asm_expr (parser); |
2027 | if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE)) |
2028 | { |
2029 | postfix_attrs = c_parser_attributes (parser); |
2030 | if (c_parser_next_token_is (parser, CPP_OPEN_BRACE)) |
2031 | { |
2032 | /* This means there is an attribute specifier after |
2033 | the declarator in a function definition. Provide |
2034 | some more information for the user. */ |
2035 | error_at (here, "attributes should be specified before the " |
2036 | "declarator in a function definition" ); |
2037 | c_parser_skip_to_end_of_block_or_statement (parser); |
2038 | return; |
2039 | } |
2040 | } |
2041 | if (c_parser_next_token_is (parser, CPP_EQ)) |
2042 | { |
2043 | tree d; |
2044 | struct c_expr init; |
2045 | location_t init_loc; |
2046 | c_parser_consume_token (parser); |
2047 | if (auto_type_p) |
2048 | { |
2049 | init_loc = c_parser_peek_token (parser)->location; |
2050 | rich_location richloc (line_table, init_loc); |
2051 | start_init (NULL_TREE, asm_name, global_bindings_p (), &richloc); |
2052 | /* A parameter is initialized, which is invalid. Don't |
2053 | attempt to instrument the initializer. */ |
2054 | int flag_sanitize_save = flag_sanitize; |
2055 | if (nested && !empty_ok) |
2056 | flag_sanitize = 0; |
2057 | init = c_parser_expr_no_commas (parser, NULL); |
2058 | flag_sanitize = flag_sanitize_save; |
2059 | if (TREE_CODE (init.value) == COMPONENT_REF |
2060 | && DECL_C_BIT_FIELD (TREE_OPERAND (init.value, 1))) |
2061 | error_at (here, |
2062 | "%<__auto_type%> used with a bit-field" |
2063 | " initializer" ); |
2064 | init = convert_lvalue_to_rvalue (init_loc, init, true, true); |
2065 | tree init_type = TREE_TYPE (init.value); |
2066 | /* As with typeof, remove all qualifiers from atomic types. */ |
2067 | if (init_type != error_mark_node && TYPE_ATOMIC (init_type)) |
2068 | init_type |
2069 | = c_build_qualified_type (init_type, TYPE_UNQUALIFIED); |
2070 | bool vm_type = variably_modified_type_p (init_type, |
2071 | NULL_TREE); |
2072 | if (vm_type) |
2073 | init.value = save_expr (init.value); |
2074 | finish_init (); |
2075 | specs->typespec_kind = ctsk_typeof; |
2076 | specs->locations[cdw_typedef] = init_loc; |
2077 | specs->typedef_p = true; |
2078 | specs->type = init_type; |
2079 | if (vm_type) |
2080 | { |
2081 | bool maybe_const = true; |
2082 | tree type_expr = c_fully_fold (init.value, false, |
2083 | &maybe_const); |
2084 | specs->expr_const_operands &= maybe_const; |
2085 | if (specs->expr) |
2086 | specs->expr = build2 (COMPOUND_EXPR, |
2087 | TREE_TYPE (type_expr), |
2088 | specs->expr, type_expr); |
2089 | else |
2090 | specs->expr = type_expr; |
2091 | } |
2092 | d = start_decl (declarator, specs, true, |
2093 | chainon (postfix_attrs, all_prefix_attrs)); |
2094 | if (!d) |
2095 | d = error_mark_node; |
2096 | if (omp_declare_simd_clauses.exists ()) |
2097 | c_finish_omp_declare_simd (parser, d, NULL_TREE, |
2098 | omp_declare_simd_clauses); |
2099 | } |
2100 | else |
2101 | { |
2102 | /* The declaration of the variable is in effect while |
2103 | its initializer is parsed. */ |
2104 | d = start_decl (declarator, specs, true, |
2105 | chainon (postfix_attrs, all_prefix_attrs)); |
2106 | if (!d) |
2107 | d = error_mark_node; |
2108 | if (omp_declare_simd_clauses.exists ()) |
2109 | c_finish_omp_declare_simd (parser, d, NULL_TREE, |
2110 | omp_declare_simd_clauses); |
2111 | init_loc = c_parser_peek_token (parser)->location; |
2112 | rich_location richloc (line_table, init_loc); |
2113 | start_init (d, asm_name, global_bindings_p (), &richloc); |
2114 | /* A parameter is initialized, which is invalid. Don't |
2115 | attempt to instrument the initializer. */ |
2116 | int flag_sanitize_save = flag_sanitize; |
2117 | if (TREE_CODE (d) == PARM_DECL) |
2118 | flag_sanitize = 0; |
2119 | init = c_parser_initializer (parser); |
2120 | flag_sanitize = flag_sanitize_save; |
2121 | finish_init (); |
2122 | } |
2123 | if (oacc_routine_data) |
2124 | c_finish_oacc_routine (oacc_routine_data, d, false); |
2125 | if (d != error_mark_node) |
2126 | { |
2127 | maybe_warn_string_init (init_loc, TREE_TYPE (d), init); |
2128 | finish_decl (d, init_loc, init.value, |
2129 | init.original_type, asm_name); |
2130 | } |
2131 | } |
2132 | else |
2133 | { |
2134 | if (auto_type_p) |
2135 | { |
2136 | error_at (here, |
2137 | "%<__auto_type%> requires an initialized " |
2138 | "data declaration" ); |
2139 | c_parser_skip_to_end_of_block_or_statement (parser); |
2140 | return; |
2141 | } |
2142 | tree d = start_decl (declarator, specs, false, |
2143 | chainon (postfix_attrs, |
2144 | all_prefix_attrs)); |
2145 | if (d && TREE_CODE (d) == FUNCTION_DECL) |
2146 | if (declarator->kind == cdk_function) |
2147 | if (DECL_ARGUMENTS (d) == NULL_TREE) |
2148 | DECL_ARGUMENTS (d) = declarator->u.arg_info->parms; |
2149 | if (omp_declare_simd_clauses.exists ()) |
2150 | { |
2151 | tree parms = NULL_TREE; |
2152 | if (d && TREE_CODE (d) == FUNCTION_DECL) |
2153 | { |
2154 | struct c_declarator *ce = declarator; |
2155 | while (ce != NULL) |
2156 | if (ce->kind == cdk_function) |
2157 | { |
2158 | parms = ce->u.arg_info->parms; |
2159 | break; |
2160 | } |
2161 | else |
2162 | ce = ce->declarator; |
2163 | } |
2164 | if (parms) |
2165 | temp_store_parm_decls (d, parms); |
2166 | c_finish_omp_declare_simd (parser, d, parms, |
2167 | omp_declare_simd_clauses); |
2168 | if (parms) |
2169 | temp_pop_parm_decls (); |
2170 | } |
2171 | if (oacc_routine_data) |
2172 | c_finish_oacc_routine (oacc_routine_data, d, false); |
2173 | if (d) |
2174 | finish_decl (d, UNKNOWN_LOCATION, NULL_TREE, |
2175 | NULL_TREE, asm_name); |
2176 | |
2177 | if (c_parser_next_token_is_keyword (parser, RID_IN)) |
2178 | { |
2179 | if (d) |
2180 | *objc_foreach_object_declaration = d; |
2181 | else |
2182 | *objc_foreach_object_declaration = error_mark_node; |
2183 | } |
2184 | } |
2185 | if (c_parser_next_token_is (parser, CPP_COMMA)) |
2186 | { |
2187 | if (auto_type_p) |
2188 | { |
2189 | error_at (here, |
2190 | "%<__auto_type%> may only be used with" |
2191 | " a single declarator" ); |
2192 | c_parser_skip_to_end_of_block_or_statement (parser); |
2193 | return; |
2194 | } |
2195 | c_parser_consume_token (parser); |
2196 | if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE)) |
2197 | all_prefix_attrs = chainon (c_parser_attributes (parser), |
2198 | prefix_attrs); |
2199 | else |
2200 | all_prefix_attrs = prefix_attrs; |
2201 | continue; |
2202 | } |
2203 | else if (c_parser_next_token_is (parser, CPP_SEMICOLON)) |
2204 | { |
2205 | c_parser_consume_token (parser); |
2206 | return; |
2207 | } |
2208 | else if (c_parser_next_token_is_keyword (parser, RID_IN)) |
2209 | { |
2210 | /* This can only happen in Objective-C: we found the |
2211 | 'in' that terminates the declaration inside an |
2212 | Objective-C foreach statement. Do not consume the |
2213 | token, so that the caller can use it to determine |
2214 | that this indeed is a foreach context. */ |
2215 | return; |
2216 | } |
2217 | else |
2218 | { |
2219 | c_parser_error (parser, "expected %<,%> or %<;%>" ); |
2220 | c_parser_skip_to_end_of_block_or_statement (parser); |
2221 | return; |
2222 | } |
2223 | } |
2224 | else if (auto_type_p) |
2225 | { |
2226 | error_at (here, |
2227 | "%<__auto_type%> requires an initialized data declaration" ); |
2228 | c_parser_skip_to_end_of_block_or_statement (parser); |
2229 | return; |
2230 | } |
2231 | else if (!fndef_ok) |
2232 | { |
2233 | c_parser_error (parser, "expected %<=%>, %<,%>, %<;%>, " |
2234 | "%<asm%> or %<__attribute__%>" ); |
2235 | c_parser_skip_to_end_of_block_or_statement (parser); |
2236 | return; |
2237 | } |
2238 | /* Function definition (nested or otherwise). */ |
2239 | if (nested) |
2240 | { |
2241 | pedwarn (here, OPT_Wpedantic, "ISO C forbids nested functions" ); |
2242 | c_push_function_context (); |
2243 | } |
2244 | if (!start_function (specs, declarator, all_prefix_attrs)) |
2245 | { |
2246 | /* At this point we've consumed: |
2247 | declaration-specifiers declarator |
2248 | and the next token isn't CPP_EQ, CPP_COMMA, CPP_SEMICOLON, |
2249 | RID_ASM, RID_ATTRIBUTE, or RID_IN, |
2250 | but the |
2251 | declaration-specifiers declarator |
2252 | aren't grokkable as a function definition, so we have |
2253 | an error. */ |
2254 | gcc_assert (!c_parser_next_token_is (parser, CPP_SEMICOLON)); |
2255 | if (c_parser_next_token_starts_declspecs (parser)) |
2256 | { |
2257 | /* If we have |
2258 | declaration-specifiers declarator decl-specs |
2259 | then assume we have a missing semicolon, which would |
2260 | give us: |
2261 | declaration-specifiers declarator decl-specs |
2262 | ^ |
2263 | ; |
2264 | <~~~~~~~~~ declaration ~~~~~~~~~~> |
2265 | Use c_parser_require to get an error with a fix-it hint. */ |
2266 | c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>" ); |
2267 | parser->error = false; |
2268 | } |
2269 | else |
2270 | { |
2271 | /* This can appear in many cases looking nothing like a |
2272 | function definition, so we don't give a more specific |
2273 | error suggesting there was one. */ |
2274 | c_parser_error (parser, "expected %<=%>, %<,%>, %<;%>, %<asm%> " |
2275 | "or %<__attribute__%>" ); |
2276 | } |
2277 | if (nested) |
2278 | c_pop_function_context (); |
2279 | break; |
2280 | } |
2281 | |
2282 | if (DECL_DECLARED_INLINE_P (current_function_decl)) |
2283 | tv = TV_PARSE_INLINE; |
2284 | else |
2285 | tv = TV_PARSE_FUNC; |
2286 | auto_timevar at (g_timer, tv); |
2287 | |
2288 | /* Parse old-style parameter declarations. ??? Attributes are |
2289 | not allowed to start declaration specifiers here because of a |
2290 | syntax conflict between a function declaration with attribute |
2291 | suffix and a function definition with an attribute prefix on |
2292 | first old-style parameter declaration. Following the old |
2293 | parser, they are not accepted on subsequent old-style |
2294 | parameter declarations either. However, there is no |
2295 | ambiguity after the first declaration, nor indeed on the |
2296 | first as long as we don't allow postfix attributes after a |
2297 | declarator with a nonempty identifier list in a definition; |
2298 | and postfix attributes have never been accepted here in |
2299 | function definitions either. */ |
2300 | while (c_parser_next_token_is_not (parser, CPP_EOF) |
2301 | && c_parser_next_token_is_not (parser, CPP_OPEN_BRACE)) |
2302 | c_parser_declaration_or_fndef (parser, false, false, false, |
2303 | true, false, NULL, vNULL); |
2304 | store_parm_decls (); |
2305 | if (omp_declare_simd_clauses.exists ()) |
2306 | c_finish_omp_declare_simd (parser, current_function_decl, NULL_TREE, |
2307 | omp_declare_simd_clauses); |
2308 | if (oacc_routine_data) |
2309 | c_finish_oacc_routine (oacc_routine_data, current_function_decl, true); |
2310 | DECL_STRUCT_FUNCTION (current_function_decl)->function_start_locus |
2311 | = c_parser_peek_token (parser)->location; |
2312 | |
2313 | /* If the definition was marked with __GIMPLE then parse the |
2314 | function body as GIMPLE. */ |
2315 | if (specs->gimple_p) |
2316 | { |
2317 | cfun->pass_startwith = specs->gimple_or_rtl_pass; |
2318 | bool saved = in_late_binary_op; |
2319 | in_late_binary_op = true; |
2320 | c_parser_parse_gimple_body (parser); |
2321 | in_late_binary_op = saved; |
2322 | } |
2323 | /* Similarly, if it was marked with __RTL, use the RTL parser now, |
2324 | consuming the function body. */ |
2325 | else if (specs->rtl_p) |
2326 | { |
2327 | c_parser_parse_rtl_body (parser, specs->gimple_or_rtl_pass); |
2328 | |
2329 | /* Normally, store_parm_decls sets next_is_function_body, |
2330 | anticipating a function body. We need a push_scope/pop_scope |
2331 | pair to flush out this state, or subsequent function parsing |
2332 | will go wrong. */ |
2333 | push_scope (); |
2334 | pop_scope (); |
2335 | |
2336 | finish_function (); |
2337 | return; |
2338 | } |
2339 | else |
2340 | fnbody = c_parser_compound_statement (parser); |
2341 | tree fndecl = current_function_decl; |
2342 | if (nested) |
2343 | { |
2344 | tree decl = current_function_decl; |
2345 | /* Mark nested functions as needing static-chain initially. |
2346 | lower_nested_functions will recompute it but the |
2347 | DECL_STATIC_CHAIN flag is also used before that happens, |
2348 | by initializer_constant_valid_p. See gcc.dg/nested-fn-2.c. */ |
2349 | DECL_STATIC_CHAIN (decl) = 1; |
2350 | add_stmt (fnbody); |
2351 | finish_function (); |
2352 | c_pop_function_context (); |
2353 | add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl), DECL_EXPR, decl)); |
2354 | } |
2355 | else |
2356 | { |
2357 | if (fnbody) |
2358 | add_stmt (fnbody); |
2359 | finish_function (); |
2360 | } |
2361 | /* Get rid of the empty stmt list for GIMPLE. */ |
2362 | if (specs->gimple_p) |
2363 | DECL_SAVED_TREE (fndecl) = NULL_TREE; |
2364 | |
2365 | break; |
2366 | } |
2367 | } |
2368 | |
2369 | /* Parse an asm-definition (asm() outside a function body). This is a |
2370 | GNU extension. |
2371 | |
2372 | asm-definition: |
2373 | simple-asm-expr ; |
2374 | */ |
2375 | |
2376 | static void |
2377 | c_parser_asm_definition (c_parser *parser) |
2378 | { |
2379 | tree asm_str = c_parser_simple_asm_expr (parser); |
2380 | if (asm_str) |
2381 | symtab->finalize_toplevel_asm (asm_str); |
2382 | c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>" ); |
2383 | } |
2384 | |
2385 | /* Parse a static assertion (C11 6.7.10). |
2386 | |
2387 | static_assert-declaration: |
2388 | static_assert-declaration-no-semi ; |
2389 | */ |
2390 | |
2391 | static void |
2392 | c_parser_static_assert_declaration (c_parser *parser) |
2393 | { |
2394 | c_parser_static_assert_declaration_no_semi (parser); |
2395 | if (parser->error |
2396 | || !c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>" )) |
2397 | c_parser_skip_to_end_of_block_or_statement (parser); |
2398 | } |
2399 | |
2400 | /* Parse a static assertion (C11 6.7.10), without the trailing |
2401 | semicolon. |
2402 | |
2403 | static_assert-declaration-no-semi: |
2404 | _Static_assert ( constant-expression , string-literal ) |
2405 | */ |
2406 | |
2407 | static void |
2408 | c_parser_static_assert_declaration_no_semi (c_parser *parser) |
2409 | { |
2410 | location_t assert_loc, value_loc; |
2411 | tree value; |
2412 | tree string; |
2413 | |
2414 | gcc_assert (c_parser_next_token_is_keyword (parser, RID_STATIC_ASSERT)); |
2415 | assert_loc = c_parser_peek_token (parser)->location; |
2416 | if (flag_isoc99) |
2417 | pedwarn_c99 (assert_loc, OPT_Wpedantic, |
2418 | "ISO C99 does not support %<_Static_assert%>" ); |
2419 | else |
2420 | pedwarn_c99 (assert_loc, OPT_Wpedantic, |
2421 | "ISO C90 does not support %<_Static_assert%>" ); |
2422 | c_parser_consume_token (parser); |
2423 | matching_parens parens; |
2424 | if (!parens.require_open (parser)) |
2425 | return; |
2426 | location_t value_tok_loc = c_parser_peek_token (parser)->location; |
2427 | value = c_parser_expr_no_commas (parser, NULL).value; |
2428 | value_loc = EXPR_LOC_OR_LOC (value, value_tok_loc); |
2429 | parser->lex_untranslated_string = true; |
2430 | if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>" )) |
2431 | { |
2432 | parser->lex_untranslated_string = false; |
2433 | return; |
2434 | } |
2435 | switch (c_parser_peek_token (parser)->type) |
2436 | { |
2437 | case CPP_STRING: |
2438 | case CPP_STRING16: |
2439 | case CPP_STRING32: |
2440 | case CPP_WSTRING: |
2441 | case CPP_UTF8STRING: |
2442 | string = c_parser_peek_token (parser)->value; |
2443 | c_parser_consume_token (parser); |
2444 | parser->lex_untranslated_string = false; |
2445 | break; |
2446 | default: |
2447 | c_parser_error (parser, "expected string literal" ); |
2448 | parser->lex_untranslated_string = false; |
2449 | return; |
2450 | } |
2451 | parens.require_close (parser); |
2452 | |
2453 | if (!INTEGRAL_TYPE_P (TREE_TYPE (value))) |
2454 | { |
2455 | error_at (value_loc, "expression in static assertion is not an integer" ); |
2456 | return; |
2457 | } |
2458 | if (TREE_CODE (value) != INTEGER_CST) |
2459 | { |
2460 | value = c_fully_fold (value, false, NULL); |
2461 | /* Strip no-op conversions. */ |
2462 | STRIP_TYPE_NOPS (value); |
2463 | if (TREE_CODE (value) == INTEGER_CST) |
2464 | pedwarn (value_loc, OPT_Wpedantic, "expression in static assertion " |
2465 | "is not an integer constant expression" ); |
2466 | } |
2467 | if (TREE_CODE (value) != INTEGER_CST) |
2468 | { |
2469 | error_at (value_loc, "expression in static assertion is not constant" ); |
2470 | return; |
2471 | } |
2472 | constant_expression_warning (value); |
2473 | if (integer_zerop (value)) |
2474 | error_at (assert_loc, "static assertion failed: %E" , string); |
2475 | } |
2476 | |
2477 | /* Parse some declaration specifiers (possibly none) (C90 6.5, C99 |
2478 | 6.7, C11 6.7), adding them to SPECS (which may already include some). |
2479 | Storage class specifiers are accepted iff SCSPEC_OK; type |
2480 | specifiers are accepted iff TYPESPEC_OK; alignment specifiers are |
2481 | accepted iff ALIGNSPEC_OK; attributes are accepted at the start |
2482 | iff START_ATTR_OK; __auto_type is accepted iff AUTO_TYPE_OK. |
2483 | |
2484 | declaration-specifiers: |
2485 | storage-class-specifier declaration-specifiers[opt] |
2486 | type-specifier declaration-specifiers[opt] |
2487 | type-qualifier declaration-specifiers[opt] |
2488 | function-specifier declaration-specifiers[opt] |
2489 | alignment-specifier declaration-specifiers[opt] |
2490 | |
2491 | Function specifiers (inline) are from C99, and are currently |
2492 | handled as storage class specifiers, as is __thread. Alignment |
2493 | specifiers are from C11. |
2494 | |
2495 | C90 6.5.1, C99 6.7.1, C11 6.7.1: |
2496 | storage-class-specifier: |
2497 | typedef |
2498 | extern |
2499 | static |
2500 | auto |
2501 | register |
2502 | _Thread_local |
2503 | |
2504 | (_Thread_local is new in C11.) |
2505 | |
2506 | C99 6.7.4, C11 6.7.4: |
2507 | function-specifier: |
2508 | inline |
2509 | _Noreturn |
2510 | |
2511 | (_Noreturn is new in C11.) |
2512 | |
2513 | C90 6.5.2, C99 6.7.2, C11 6.7.2: |
2514 | type-specifier: |
2515 | void |
2516 | char |
2517 | short |
2518 | int |
2519 | long |
2520 | float |
2521 | double |
2522 | signed |
2523 | unsigned |
2524 | _Bool |
2525 | _Complex |
2526 | [_Imaginary removed in C99 TC2] |
2527 | struct-or-union-specifier |
2528 | enum-specifier |
2529 | typedef-name |
2530 | atomic-type-specifier |
2531 | |
2532 | (_Bool and _Complex are new in C99.) |
2533 | (atomic-type-specifier is new in C11.) |
2534 | |
2535 | C90 6.5.3, C99 6.7.3, C11 6.7.3: |
2536 | |
2537 | type-qualifier: |
2538 | const |
2539 | restrict |
2540 | volatile |
2541 | address-space-qualifier |
2542 | _Atomic |
2543 | |
2544 | (restrict is new in C99.) |
2545 | (_Atomic is new in C11.) |
2546 | |
2547 | GNU extensions: |
2548 | |
2549 | declaration-specifiers: |
2550 | attributes declaration-specifiers[opt] |
2551 | |
2552 | type-qualifier: |
2553 | address-space |
2554 | |
2555 | address-space: |
2556 | identifier recognized by the target |
2557 | |
2558 | storage-class-specifier: |
2559 | __thread |
2560 | |
2561 | type-specifier: |
2562 | typeof-specifier |
2563 | __auto_type |
2564 | __intN |
2565 | _Decimal32 |
2566 | _Decimal64 |
2567 | _Decimal128 |
2568 | _Fract |
2569 | _Accum |
2570 | _Sat |
2571 | |
2572 | (_Fract, _Accum, and _Sat are new from ISO/IEC DTR 18037: |
2573 | http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1169.pdf) |
2574 | |
2575 | atomic-type-specifier |
2576 | _Atomic ( type-name ) |
2577 | |
2578 | Objective-C: |
2579 | |
2580 | type-specifier: |
2581 | class-name objc-protocol-refs[opt] |
2582 | typedef-name objc-protocol-refs |
2583 | objc-protocol-refs |
2584 | */ |
2585 | |
2586 | void |
2587 | c_parser_declspecs (c_parser *parser, struct c_declspecs *specs, |
2588 | bool scspec_ok, bool typespec_ok, bool start_attr_ok, |
2589 | bool alignspec_ok, bool auto_type_ok, |
2590 | enum c_lookahead_kind la) |
2591 | { |
2592 | bool attrs_ok = start_attr_ok; |
2593 | bool seen_type = specs->typespec_kind != ctsk_none; |
2594 | |
2595 | if (!typespec_ok) |
2596 | gcc_assert (la == cla_prefer_id); |
2597 | |
2598 | while (c_parser_next_token_is (parser, CPP_NAME) |
2599 | || c_parser_next_token_is (parser, CPP_KEYWORD) |
2600 | || (c_dialect_objc () && c_parser_next_token_is (parser, CPP_LESS))) |
2601 | { |
2602 | struct c_typespec t; |
2603 | tree attrs; |
2604 | tree align; |
2605 | location_t loc = c_parser_peek_token (parser)->location; |
2606 | |
2607 | /* If we cannot accept a type, exit if the next token must start |
2608 | one. Also, if we already have seen a tagged definition, |
2609 | a typename would be an error anyway and likely the user |
2610 | has simply forgotten a semicolon, so we exit. */ |
2611 | if ((!typespec_ok || specs->typespec_kind == ctsk_tagdef) |
2612 | && c_parser_next_tokens_start_typename (parser, la) |
2613 | && !c_parser_next_token_is_qualifier (parser) |
2614 | && !c_parser_next_token_is_keyword (parser, RID_ALIGNAS)) |
2615 | break; |
2616 | |
2617 | if (c_parser_next_token_is (parser, CPP_NAME)) |
2618 | { |
2619 | c_token *name_token = c_parser_peek_token (parser); |
2620 | tree value = name_token->value; |
2621 | c_id_kind kind = name_token->id_kind; |
2622 | |
2623 | if (kind == C_ID_ADDRSPACE) |
2624 | { |
2625 | addr_space_t as |
2626 | = name_token->keyword - RID_FIRST_ADDR_SPACE; |
2627 | declspecs_add_addrspace (name_token->location, specs, as); |
2628 | c_parser_consume_token (parser); |
2629 | attrs_ok = true; |
2630 | continue; |
2631 | } |
2632 | |
2633 | gcc_assert (!c_parser_next_token_is_qualifier (parser)); |
2634 | |
2635 | /* If we cannot accept a type, and the next token must start one, |
2636 | exit. Do the same if we already have seen a tagged definition, |
2637 | since it would be an error anyway and likely the user has simply |
2638 | forgotten a semicolon. */ |
2639 | if (seen_type || !c_parser_next_tokens_start_typename (parser, la)) |
2640 | break; |
2641 | |
2642 | /* Now at an unknown typename (C_ID_ID), a C_ID_TYPENAME or |
2643 | a C_ID_CLASSNAME. */ |
2644 | c_parser_consume_token (parser); |
2645 | seen_type = true; |
2646 | attrs_ok = true; |
2647 | if (kind == C_ID_ID) |
2648 | { |
2649 | error_at (loc, "unknown type name %qE" , value); |
2650 | t.kind = ctsk_typedef; |
2651 | t.spec = error_mark_node; |
2652 | } |
2653 | else if (kind == C_ID_TYPENAME |
2654 | && (!c_dialect_objc () |
2655 | || c_parser_next_token_is_not (parser, CPP_LESS))) |
2656 | { |
2657 | t.kind = ctsk_typedef; |
2658 | /* For a typedef name, record the meaning, not the name. |
2659 | In case of 'foo foo, bar;'. */ |
2660 | t.spec = lookup_name (value); |
2661 | } |
2662 | else |
2663 | { |
2664 | tree proto = NULL_TREE; |
2665 | gcc_assert (c_dialect_objc ()); |
2666 | t.kind = ctsk_objc; |
2667 | if (c_parser_next_token_is (parser, CPP_LESS)) |
2668 | proto = c_parser_objc_protocol_refs (parser); |
2669 | t.spec = objc_get_protocol_qualified_type (value, proto); |
2670 | } |
2671 | t.expr = NULL_TREE; |
2672 | t.expr_const_operands = true; |
2673 | declspecs_add_type (name_token->location, specs, t); |
2674 | continue; |
2675 | } |
2676 | if (c_parser_next_token_is (parser, CPP_LESS)) |
2677 | { |
2678 | /* Make "<SomeProtocol>" equivalent to "id <SomeProtocol>" - |
2679 | nisse@lysator.liu.se. */ |
2680 | tree proto; |
2681 | gcc_assert (c_dialect_objc ()); |
2682 | if (!typespec_ok || seen_type) |
2683 | break; |
2684 | proto = c_parser_objc_protocol_refs (parser); |
2685 | t.kind = ctsk_objc; |
2686 | t.spec = objc_get_protocol_qualified_type (NULL_TREE, proto); |
2687 | t.expr = NULL_TREE; |
2688 | t.expr_const_operands = true; |
2689 | declspecs_add_type (loc, specs, t); |
2690 | continue; |
2691 | } |
2692 | gcc_assert (c_parser_next_token_is (parser, CPP_KEYWORD)); |
2693 | switch (c_parser_peek_token (parser)->keyword) |
2694 | { |
2695 | case RID_STATIC: |
2696 | case RID_EXTERN: |
2697 | case RID_REGISTER: |
2698 | case RID_TYPEDEF: |
2699 | case RID_INLINE: |
2700 | case RID_NORETURN: |
2701 | case RID_AUTO: |
2702 | case RID_THREAD: |
2703 | if (!scspec_ok) |
2704 | goto out; |
2705 | attrs_ok = true; |
2706 | /* TODO: Distinguish between function specifiers (inline, noreturn) |
2707 | and storage class specifiers, either here or in |
2708 | declspecs_add_scspec. */ |
2709 | declspecs_add_scspec (loc, specs, |
2710 | c_parser_peek_token (parser)->value); |
2711 | c_parser_consume_token (parser); |
2712 | break; |
2713 | case RID_AUTO_TYPE: |
2714 | if (!auto_type_ok) |
2715 | goto out; |
2716 | /* Fall through. */ |
2717 | case RID_UNSIGNED: |
2718 | case RID_LONG: |
2719 | case RID_SHORT: |
2720 | case RID_SIGNED: |
2721 | case RID_COMPLEX: |
2722 | case RID_INT: |
2723 | case RID_CHAR: |
2724 | case RID_FLOAT: |
2725 | case RID_DOUBLE: |
2726 | case RID_VOID: |
2727 | case RID_DFLOAT32: |
2728 | case RID_DFLOAT64: |
2729 | case RID_DFLOAT128: |
2730 | CASE_RID_FLOATN_NX: |
2731 | case RID_BOOL: |
2732 | case RID_FRACT: |
2733 | case RID_ACCUM: |
2734 | case RID_SAT: |
2735 | case RID_INT_N_0: |
2736 | case RID_INT_N_1: |
2737 | case RID_INT_N_2: |
2738 | case RID_INT_N_3: |
2739 | if (!typespec_ok) |
2740 | goto out; |
2741 | attrs_ok = true; |
2742 | seen_type = true; |
2743 | if (c_dialect_objc ()) |
2744 | parser->objc_need_raw_identifier = true; |
2745 | t.kind = ctsk_resword; |
2746 | t.spec = c_parser_peek_token (parser)->value; |
2747 | t.expr = NULL_TREE; |
2748 | t.expr_const_operands = true; |
2749 | declspecs_add_type (loc, specs, t); |
2750 | c_parser_consume_token (parser); |
2751 | break; |
2752 | case RID_ENUM: |
2753 | if (!typespec_ok) |
2754 | goto out; |
2755 | attrs_ok = true; |
2756 | seen_type = true; |
2757 | t = c_parser_enum_specifier (parser); |
2758 | invoke_plugin_callbacks (PLUGIN_FINISH_TYPE, t.spec); |
2759 | declspecs_add_type (loc, specs, t); |
2760 | break; |
2761 | case RID_STRUCT: |
2762 | case RID_UNION: |
2763 | if (!typespec_ok) |
2764 | goto out; |
2765 | attrs_ok = true; |
2766 | seen_type = true; |
2767 | t = c_parser_struct_or_union_specifier (parser); |
2768 | invoke_plugin_callbacks (PLUGIN_FINISH_TYPE, t.spec); |
2769 | declspecs_add_type (loc, specs, t); |
2770 | break; |
2771 | case RID_TYPEOF: |
2772 | /* ??? The old parser rejected typeof after other type |
2773 | specifiers, but is a syntax error the best way of |
2774 | handling this? */ |
2775 | if (!typespec_ok || seen_type) |
2776 | goto out; |
2777 | attrs_ok = true; |
2778 | seen_type = true; |
2779 | t = c_parser_typeof_specifier (parser); |
2780 | declspecs_add_type (loc, specs, t); |
2781 | break; |
2782 | case RID_ATOMIC: |
2783 | /* C parser handling of Objective-C constructs needs |
2784 | checking for correct lvalue-to-rvalue conversions, and |
2785 | the code in build_modify_expr handling various |
2786 | Objective-C cases, and that in build_unary_op handling |
2787 | Objective-C cases for increment / decrement, also needs |
2788 | updating; uses of TYPE_MAIN_VARIANT in objc_compare_types |
2789 | and objc_types_are_equivalent may also need updates. */ |
2790 | if (c_dialect_objc ()) |
2791 | sorry ("%<_Atomic%> in Objective-C" ); |
2792 | if (flag_isoc99) |
2793 | pedwarn_c99 (loc, OPT_Wpedantic, |
2794 | "ISO C99 does not support the %<_Atomic%> qualifier" ); |
2795 | else |
2796 | pedwarn_c99 (loc, OPT_Wpedantic, |
2797 | "ISO C90 does not support the %<_Atomic%> qualifier" ); |
2798 | attrs_ok = true; |
2799 | tree value; |
2800 | value = c_parser_peek_token (parser)->value; |
2801 | c_parser_consume_token (parser); |
2802 | if (typespec_ok && c_parser_next_token_is (parser, CPP_OPEN_PAREN)) |
2803 | { |
2804 | /* _Atomic ( type-name ). */ |
2805 | seen_type = true; |
2806 | c_parser_consume_token (parser); |
2807 | struct c_type_name *type = c_parser_type_name (parser); |
2808 | t.kind = ctsk_typeof; |
2809 | t.spec = error_mark_node; |
2810 | t.expr = NULL_TREE; |
2811 | t.expr_const_operands = true; |
2812 | if (type != NULL) |
2813 | t.spec = groktypename (type, &t.expr, |
2814 | &t.expr_const_operands); |
2815 | c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, |
2816 | "expected %<)%>" ); |
2817 | if (t.spec != error_mark_node) |
2818 | { |
2819 | if (TREE_CODE (t.spec) == ARRAY_TYPE) |
2820 | error_at (loc, "%<_Atomic%>-qualified array type" ); |
2821 | else if (TREE_CODE (t.spec) == FUNCTION_TYPE) |
2822 | error_at (loc, "%<_Atomic%>-qualified function type" ); |
2823 | else if (TYPE_QUALS (t.spec) != TYPE_UNQUALIFIED) |
2824 | error_at (loc, "%<_Atomic%> applied to a qualified type" ); |
2825 | else |
2826 | t.spec = c_build_qualified_type (t.spec, TYPE_QUAL_ATOMIC); |
2827 | } |
2828 | declspecs_add_type (loc, specs, t); |
2829 | } |
2830 | else |
2831 | declspecs_add_qual (loc, specs, value); |
2832 | break; |
2833 | case RID_CONST: |
2834 | case RID_VOLATILE: |
2835 | case RID_RESTRICT: |
2836 | attrs_ok = true; |
2837 | declspecs_add_qual (loc, specs, c_parser_peek_token (parser)->value); |
2838 | c_parser_consume_token (parser); |
2839 | break; |
2840 | case RID_ATTRIBUTE: |
2841 | if (!attrs_ok) |
2842 | goto out; |
2843 | attrs = c_parser_attributes (parser); |
2844 | declspecs_add_attrs (loc, specs, attrs); |
2845 | break; |
2846 | case RID_ALIGNAS: |
2847 | if (!alignspec_ok) |
2848 | goto out; |
2849 | align = c_parser_alignas_specifier (parser); |
2850 | declspecs_add_alignas (loc, specs, align); |
2851 | break; |
2852 | case RID_GIMPLE: |
2853 | if (! flag_gimple) |
2854 | error_at (loc, "%<__GIMPLE%> only valid with -fgimple" ); |
2855 | c_parser_consume_token (parser); |
2856 | specs->gimple_p = true; |
2857 | specs->locations[cdw_gimple] = loc; |
2858 | specs->gimple_or_rtl_pass = c_parser_gimple_or_rtl_pass_list (parser); |
2859 | break; |
2860 | case RID_RTL: |
2861 | c_parser_consume_token (parser); |
2862 | specs->rtl_p = true; |
2863 | specs->locations[cdw_rtl] = loc; |
2864 | specs->gimple_or_rtl_pass = c_parser_gimple_or_rtl_pass_list (parser); |
2865 | break; |
2866 | default: |
2867 | goto out; |
2868 | } |
2869 | } |
2870 | out: ; |
2871 | } |
2872 | |
2873 | /* Parse an enum specifier (C90 6.5.2.2, C99 6.7.2.2, C11 6.7.2.2). |
2874 | |
2875 | enum-specifier: |
2876 | enum attributes[opt] identifier[opt] { enumerator-list } attributes[opt] |
2877 | enum attributes[opt] identifier[opt] { enumerator-list , } attributes[opt] |
2878 | enum attributes[opt] identifier |
2879 | |
2880 | The form with trailing comma is new in C99. The forms with |
2881 | attributes are GNU extensions. In GNU C, we accept any expression |
2882 | without commas in the syntax (assignment expressions, not just |
2883 | conditional expressions); assignment expressions will be diagnosed |
2884 | as non-constant. |
2885 | |
2886 | enumerator-list: |
2887 | enumerator |
2888 | enumerator-list , enumerator |
2889 | |
2890 | enumerator: |
2891 | enumeration-constant |
2892 | enumeration-constant = constant-expression |
2893 | |
2894 | GNU Extensions: |
2895 | |
2896 | enumerator: |
2897 | enumeration-constant attributes[opt] |
2898 | enumeration-constant attributes[opt] = constant-expression |
2899 | |
2900 | */ |
2901 | |
2902 | static struct c_typespec |
2903 | c_parser_enum_specifier (c_parser *parser) |
2904 | { |
2905 | struct c_typespec ret; |
2906 | tree attrs; |
2907 | tree ident = NULL_TREE; |
2908 | location_t enum_loc; |
2909 | location_t ident_loc = UNKNOWN_LOCATION; /* Quiet warning. */ |
2910 | gcc_assert (c_parser_next_token_is_keyword (parser, RID_ENUM)); |
2911 | c_parser_consume_token (parser); |
2912 | attrs = c_parser_attributes (parser); |
2913 | enum_loc = c_parser_peek_token (parser)->location; |
2914 | /* Set the location in case we create a decl now. */ |
2915 | c_parser_set_source_position_from_token (c_parser_peek_token (parser)); |
2916 | if (c_parser_next_token_is (parser, CPP_NAME)) |
2917 | { |
2918 | ident = c_parser_peek_token (parser)->value; |
2919 | ident_loc = c_parser_peek_token (parser)->location; |
2920 | enum_loc = ident_loc; |
2921 | c_parser_consume_token (parser); |
2922 | } |
2923 | if (c_parser_next_token_is (parser, CPP_OPEN_BRACE)) |
2924 | { |
2925 | /* Parse an enum definition. */ |
2926 | struct c_enum_contents the_enum; |
2927 | tree type; |
2928 | tree postfix_attrs; |
2929 | /* We chain the enumerators in reverse order, then put them in |
2930 | forward order at the end. */ |
2931 | tree values; |
2932 | timevar_push (TV_PARSE_ENUM); |
2933 | type = start_enum (enum_loc, &the_enum, ident); |
2934 | values = NULL_TREE; |
2935 | c_parser_consume_token (parser); |
2936 | while (true) |
2937 | { |
2938 | tree enum_id; |
2939 | tree enum_value; |
2940 | tree enum_decl; |
2941 | bool seen_comma; |
2942 | c_token *token; |
2943 | location_t comma_loc = UNKNOWN_LOCATION; /* Quiet warning. */ |
2944 | location_t decl_loc, value_loc; |
2945 | if (c_parser_next_token_is_not (parser, CPP_NAME)) |
2946 | { |
2947 | /* Give a nicer error for "enum {}". */ |
2948 | if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE) |
2949 | && !parser->error) |
2950 | { |
2951 | error_at (c_parser_peek_token (parser)->location, |
2952 | "empty enum is invalid" ); |
2953 | parser->error = true; |
2954 | } |
2955 | else |
2956 | c_parser_error (parser, "expected identifier" ); |
2957 | c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL); |
2958 | values = error_mark_node; |
2959 | break; |
2960 | } |
2961 | token = c_parser_peek_token (parser); |
2962 | enum_id = token->value; |
2963 | /* Set the location in case we create a decl now. */ |
2964 | c_parser_set_source_position_from_token (token); |
2965 | decl_loc = value_loc = token->location; |
2966 | c_parser_consume_token (parser); |
2967 | /* Parse any specified attributes. */ |
2968 | tree enum_attrs = c_parser_attributes (parser); |
2969 | if (c_parser_next_token_is (parser, CPP_EQ)) |
2970 | { |
2971 | c_parser_consume_token (parser); |
2972 | value_loc = c_parser_peek_token (parser)->location; |
2973 | enum_value = c_parser_expr_no_commas (parser, NULL).value; |
2974 | } |
2975 | else |
2976 | enum_value = NULL_TREE; |
2977 | enum_decl = build_enumerator (decl_loc, value_loc, |
2978 | &the_enum, enum_id, enum_value); |
2979 | if (enum_attrs) |
2980 | decl_attributes (&TREE_PURPOSE (enum_decl), enum_attrs, 0); |
2981 | TREE_CHAIN (enum_decl) = values; |
2982 | values = enum_decl; |
2983 | seen_comma = false; |
2984 | if (c_parser_next_token_is (parser, CPP_COMMA)) |
2985 | { |
2986 | comma_loc = c_parser_peek_token (parser)->location; |
2987 | seen_comma = true; |
2988 | c_parser_consume_token (parser); |
2989 | } |
2990 | if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE)) |
2991 | { |
2992 | if (seen_comma) |
2993 | pedwarn_c90 (comma_loc, OPT_Wpedantic, |
2994 | "comma at end of enumerator list" ); |
2995 | c_parser_consume_token (parser); |
2996 | break; |
2997 | } |
2998 | if (!seen_comma) |
2999 | { |
3000 | c_parser_error (parser, "expected %<,%> or %<}%>" ); |
3001 | c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL); |
3002 | values = error_mark_node; |
3003 | break; |
3004 | } |
3005 | } |
3006 | postfix_attrs = c_parser_attributes (parser); |
3007 | ret.spec = finish_enum (type, nreverse (values), |
3008 | chainon (attrs, postfix_attrs)); |
3009 | ret.kind = ctsk_tagdef; |
3010 | ret.expr = NULL_TREE; |
3011 | ret.expr_const_operands = true; |
3012 | timevar_pop (TV_PARSE_ENUM); |
3013 | return ret; |
3014 | } |
3015 | else if (!ident) |
3016 | { |
3017 | c_parser_error (parser, "expected %<{%>" ); |
3018 | ret.spec = error_mark_node; |
3019 | ret.kind = ctsk_tagref; |
3020 | ret.expr = NULL_TREE; |
3021 | ret.expr_const_operands = true; |
3022 | return ret; |
3023 | } |
3024 | ret = parser_xref_tag (ident_loc, ENUMERAL_TYPE, ident); |
3025 | /* In ISO C, enumerated types can be referred to only if already |
3026 | defined. */ |
3027 | if (pedantic && !COMPLETE_TYPE_P (ret.spec)) |
3028 | { |
3029 | gcc_assert (ident); |
3030 | pedwarn (enum_loc, OPT_Wpedantic, |
3031 | "ISO C forbids forward references to %<enum%> types" ); |
3032 | } |
3033 | return ret; |
3034 | } |
3035 | |
3036 | /* Parse a struct or union specifier (C90 6.5.2.1, C99 6.7.2.1, C11 6.7.2.1). |
3037 | |
3038 | struct-or-union-specifier: |
3039 | struct-or-union attributes[opt] identifier[opt] |
3040 | { struct-contents } attributes[opt] |
3041 | struct-or-union attributes[opt] identifier |
3042 | |
3043 | struct-contents: |
3044 | struct-declaration-list |
3045 | |
3046 | struct-declaration-list: |
3047 | struct-declaration ; |
3048 | struct-declaration-list struct-declaration ; |
3049 | |
3050 | GNU extensions: |
3051 | |
3052 | struct-contents: |
3053 | empty |
3054 | struct-declaration |
3055 | struct-declaration-list struct-declaration |
3056 | |
3057 | struct-declaration-list: |
3058 | struct-declaration-list ; |
3059 | ; |
3060 | |
3061 | (Note that in the syntax here, unlike that in ISO C, the semicolons |
3062 | are included here rather than in struct-declaration, in order to |
3063 | describe the syntax with extra semicolons and missing semicolon at |
3064 | end.) |
3065 | |
3066 | Objective-C: |
3067 | |
3068 | struct-declaration-list: |
3069 | @defs ( class-name ) |
3070 | |
3071 | (Note this does not include a trailing semicolon, but can be |
3072 | followed by further declarations, and gets a pedwarn-if-pedantic |
3073 | when followed by a semicolon.) */ |
3074 | |
3075 | static struct c_typespec |
3076 | c_parser_struct_or_union_specifier (c_parser *parser) |
3077 | { |
3078 | struct c_typespec ret; |
3079 | tree attrs; |
3080 | tree ident = NULL_TREE; |
3081 | location_t struct_loc; |
3082 | location_t ident_loc = UNKNOWN_LOCATION; |
3083 | enum tree_code code; |
3084 | switch (c_parser_peek_token (parser)->keyword) |
3085 | { |
3086 | case RID_STRUCT: |
3087 | code = RECORD_TYPE; |
3088 | break; |
3089 | case RID_UNION: |
3090 | code = UNION_TYPE; |
3091 | break; |
3092 | default: |
3093 | gcc_unreachable (); |
3094 | } |
3095 | struct_loc = c_parser_peek_token (parser)->location; |
3096 | c_parser_consume_token (parser); |
3097 | attrs = c_parser_attributes (parser); |
3098 | |
3099 | /* Set the location in case we create a decl now. */ |
3100 | c_parser_set_source_position_from_token (c_parser_peek_token (parser)); |
3101 | |
3102 | if (c_parser_next_token_is (parser, CPP_NAME)) |
3103 | { |
3104 | ident = c_parser_peek_token (parser)->value; |
3105 | ident_loc = c_parser_peek_token (parser)->location; |
3106 | struct_loc = ident_loc; |
3107 | c_parser_consume_token (parser); |
3108 | } |
3109 | if (c_parser_next_token_is (parser, CPP_OPEN_BRACE)) |
3110 | { |
3111 | /* Parse a struct or union definition. Start the scope of the |
3112 | tag before parsing components. */ |
3113 | struct c_struct_parse_info *struct_info; |
3114 | tree type = start_struct (struct_loc, code, ident, &struct_info); |
3115 | tree postfix_attrs; |
3116 | /* We chain the components in reverse order, then put them in |
3117 | forward order at the end. Each struct-declaration may |
3118 | declare multiple components (comma-separated), so we must use |
3119 | chainon to join them, although when parsing each |
3120 | struct-declaration we can use TREE_CHAIN directly. |
3121 | |
3122 | The theory behind all this is that there will be more |
3123 | semicolon separated fields than comma separated fields, and |
3124 | so we'll be minimizing the number of node traversals required |
3125 | by chainon. */ |
3126 | tree contents; |
3127 | timevar_push (TV_PARSE_STRUCT); |
3128 | contents = NULL_TREE; |
3129 | c_parser_consume_token (parser); |
3130 | /* Handle the Objective-C @defs construct, |
3131 | e.g. foo(sizeof(struct{ @defs(ClassName) }));. */ |
3132 | if (c_parser_next_token_is_keyword (parser, RID_AT_DEFS)) |
3133 | { |
3134 | tree name; |
3135 | gcc_assert (c_dialect_objc ()); |
3136 | c_parser_consume_token (parser); |
3137 | matching_parens parens; |
3138 | if (!parens.require_open (parser)) |
3139 | goto end_at_defs; |
3140 | if (c_parser_next_token_is (parser, CPP_NAME) |
3141 | && c_parser_peek_token (parser)->id_kind == C_ID_CLASSNAME) |
3142 | { |
3143 | name = c_parser_peek_token (parser)->value; |
3144 | c_parser_consume_token (parser); |
3145 | } |
3146 | else |
3147 | { |
3148 | c_parser_error (parser, "expected class name" ); |
3149 | c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); |
3150 | goto end_at_defs; |
3151 | } |
3152 | parens.skip_until_found_close (parser); |
3153 | contents = nreverse (objc_get_class_ivars (name)); |
3154 | } |
3155 | end_at_defs: |
3156 | /* Parse the struct-declarations and semicolons. Problems with |
3157 | semicolons are diagnosed here; empty structures are diagnosed |
3158 | elsewhere. */ |
3159 | while (true) |
3160 | { |
3161 | tree decls; |
3162 | /* Parse any stray semicolon. */ |
3163 | if (c_parser_next_token_is (parser, CPP_SEMICOLON)) |
3164 | { |
3165 | location_t semicolon_loc |
3166 | = c_parser_peek_token (parser)->location; |
3167 | gcc_rich_location richloc (semicolon_loc); |
3168 | richloc.add_fixit_remove (); |
3169 | pedwarn (&richloc, OPT_Wpedantic, |
3170 | "extra semicolon in struct or union specified" ); |
3171 | c_parser_consume_token (parser); |
3172 | continue; |
3173 | } |
3174 | /* Stop if at the end of the struct or union contents. */ |
3175 | if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE)) |
3176 | { |
3177 | c_parser_consume_token (parser); |
3178 | break; |
3179 | } |
3180 | /* Accept #pragmas at struct scope. */ |
3181 | if (c_parser_next_token_is (parser, CPP_PRAGMA)) |
3182 | { |
3183 | c_parser_pragma (parser, pragma_struct, NULL); |
3184 | continue; |
3185 | } |
3186 | /* Parse some comma-separated declarations, but not the |
3187 | trailing semicolon if any. */ |
3188 | decls = c_parser_struct_declaration (parser); |
3189 | contents = chainon (decls, contents); |
3190 | /* If no semicolon follows, either we have a parse error or |
3191 | are at the end of the struct or union and should |
3192 | pedwarn. */ |
3193 | if (c_parser_next_token_is (parser, CPP_SEMICOLON)) |
3194 | c_parser_consume_token (parser); |
3195 | else |
3196 | { |
3197 | if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE)) |
3198 | pedwarn (c_parser_peek_token (parser)->location, 0, |
3199 | "no semicolon at end of struct or union" ); |
3200 | else if (parser->error |
3201 | || !c_parser_next_token_starts_declspecs (parser)) |
3202 | { |
3203 | c_parser_error (parser, "expected %<;%>" ); |
3204 | c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL); |
3205 | break; |
3206 | } |
3207 | |
3208 | /* If we come here, we have already emitted an error |
3209 | for an expected `;', identifier or `(', and we also |
3210 | recovered already. Go on with the next field. */ |
3211 | } |
3212 | } |
3213 | postfix_attrs = c_parser_attributes (parser); |
3214 | ret.spec = finish_struct (struct_loc, type, nreverse (contents), |
3215 | chainon (attrs, postfix_attrs), struct_info); |
3216 | ret.kind = ctsk_tagdef; |
3217 | ret.expr = NULL_TREE; |
3218 | ret.expr_const_operands = true; |
3219 | timevar_pop (TV_PARSE_STRUCT); |
3220 | return ret; |
3221 | } |
3222 | else if (!ident) |
3223 | { |
3224 | c_parser_error (parser, "expected %<{%>" ); |
3225 | ret.spec = error_mark_node; |
3226 | ret.kind = ctsk_tagref; |
3227 | ret.expr = NULL_TREE; |
3228 | ret.expr_const_operands = true; |
3229 | return ret; |
3230 | } |
3231 | ret = parser_xref_tag (ident_loc, code, ident); |
3232 | return ret; |
3233 | } |
3234 | |
3235 | /* Parse a struct-declaration (C90 6.5.2.1, C99 6.7.2.1, C11 6.7.2.1), |
3236 | *without* the trailing semicolon. |
3237 | |
3238 | struct-declaration: |
3239 | specifier-qualifier-list struct-declarator-list |
3240 | static_assert-declaration-no-semi |
3241 | |
3242 | specifier-qualifier-list: |
3243 | type-specifier specifier-qualifier-list[opt] |
3244 | type-qualifier specifier-qualifier-list[opt] |
3245 | alignment-specifier specifier-qualifier-list[opt] |
3246 | attributes specifier-qualifier-list[opt] |
3247 | |
3248 | struct-declarator-list: |
3249 | struct-declarator |
3250 | struct-declarator-list , attributes[opt] struct-declarator |
3251 | |
3252 | struct-declarator: |
3253 | declarator attributes[opt] |
3254 | declarator[opt] : constant-expression attributes[opt] |
3255 | |
3256 | GNU extensions: |
3257 | |
3258 | struct-declaration: |
3259 | __extension__ struct-declaration |
3260 | specifier-qualifier-list |
3261 | |
3262 | Unlike the ISO C syntax, semicolons are handled elsewhere. The use |
3263 | of attributes where shown is a GNU extension. In GNU C, we accept |
3264 | any expression without commas in the syntax (assignment |
3265 | expressions, not just conditional expressions); assignment |
3266 | expressions will be diagnosed as non-constant. */ |
3267 | |
3268 | static tree |
3269 | c_parser_struct_declaration (c_parser *parser) |
3270 | { |
3271 | struct c_declspecs *specs; |
3272 | tree prefix_attrs; |
3273 | tree all_prefix_attrs; |
3274 | tree decls; |
3275 | location_t decl_loc; |
3276 | if (c_parser_next_token_is_keyword (parser, RID_EXTENSION)) |
3277 | { |
3278 | int ext; |
3279 | tree decl; |
3280 | ext = disable_extension_diagnostics (); |
3281 | c_parser_consume_token (parser); |
3282 | decl = c_parser_struct_declaration (parser); |
3283 | restore_extension_diagnostics (ext); |
3284 | return decl; |
3285 | } |
3286 | if (c_parser_next_token_is_keyword (parser, RID_STATIC_ASSERT)) |
3287 | { |
3288 | c_parser_static_assert_declaration_no_semi (parser); |
3289 | return NULL_TREE; |
3290 | } |
3291 | specs = build_null_declspecs (); |
3292 | decl_loc = c_parser_peek_token (parser)->location; |
3293 | /* Strictly by the standard, we shouldn't allow _Alignas here, |
3294 | but it appears to have been intended to allow it there, so |
3295 | we're keeping it as it is until WG14 reaches a conclusion |
3296 | of N1731. |
3297 | <http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1731.pdf> */ |
3298 | c_parser_declspecs (parser, specs, false, true, true, |
3299 | true, false, cla_nonabstract_decl); |
3300 | if (parser->error) |
3301 | return NULL_TREE; |
3302 | if (!specs->declspecs_seen_p) |
3303 | { |
3304 | c_parser_error (parser, "expected specifier-qualifier-list" ); |
3305 | return NULL_TREE; |
3306 | } |
3307 | finish_declspecs (specs); |
3308 | if (c_parser_next_token_is (parser, CPP_SEMICOLON) |
3309 | || c_parser_next_token_is (parser, CPP_CLOSE_BRACE)) |
3310 | { |
3311 | tree ret; |
3312 | if (specs->typespec_kind == ctsk_none) |
3313 | { |
3314 | pedwarn (decl_loc, OPT_Wpedantic, |
3315 | "ISO C forbids member declarations with no members" ); |
3316 | shadow_tag_warned (specs, pedantic); |
3317 | ret = NULL_TREE; |
3318 | } |
3319 | else |
3320 | { |
3321 | /* Support for unnamed structs or unions as members of |
3322 | structs or unions (which is [a] useful and [b] supports |
3323 | MS P-SDK). */ |
3324 | tree attrs = NULL; |
3325 | |
3326 | ret = grokfield (c_parser_peek_token (parser)->location, |
3327 | build_id_declarator (NULL_TREE), specs, |
3328 | NULL_TREE, &attrs); |
3329 | if (ret) |
3330 | decl_attributes (&ret, attrs, 0); |
3331 | } |
3332 | return ret; |
3333 | } |
3334 | |
3335 | /* Provide better error recovery. Note that a type name here is valid, |
3336 | and will be treated as a field name. */ |
3337 | if (specs->typespec_kind == ctsk_tagdef |
3338 | && TREE_CODE (specs->type) != ENUMERAL_TYPE |
3339 | && c_parser_next_token_starts_declspecs (parser) |
3340 | && !c_parser_next_token_is (parser, CPP_NAME)) |
3341 | { |
3342 | c_parser_error (parser, "expected %<;%>, identifier or %<(%>" ); |
3343 | parser->error = false; |
3344 | return NULL_TREE; |
3345 | } |
3346 | |
3347 | pending_xref_error (); |
3348 | prefix_attrs = specs->attrs; |
3349 | all_prefix_attrs = prefix_attrs; |
3350 | specs->attrs = NULL_TREE; |
3351 | decls = NULL_TREE; |
3352 | while (true) |
3353 | { |
3354 | /* Declaring one or more declarators or un-named bit-fields. */ |
3355 | struct c_declarator *declarator; |
3356 | bool dummy = false; |
3357 | if (c_parser_next_token_is (parser, CPP_COLON)) |
3358 | declarator = build_id_declarator (NULL_TREE); |
3359 | else |
3360 | declarator = c_parser_declarator (parser, |
3361 | specs->typespec_kind != ctsk_none, |
3362 | C_DTR_NORMAL, &dummy); |
3363 | if (declarator == NULL) |
3364 | { |
3365 | c_parser_skip_to_end_of_block_or_statement (parser); |
3366 | break; |
3367 | } |
3368 | if (c_parser_next_token_is (parser, CPP_COLON) |
3369 | || c_parser_next_token_is (parser, CPP_COMMA) |
3370 | || c_parser_next_token_is (parser, CPP_SEMICOLON) |
3371 | || c_parser_next_token_is (parser, CPP_CLOSE_BRACE) |
3372 | || c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE)) |
3373 | { |
3374 | tree postfix_attrs = NULL_TREE; |
3375 | tree width = NULL_TREE; |
3376 | tree d; |
3377 | if (c_parser_next_token_is (parser, CPP_COLON)) |
3378 | { |
3379 | c_parser_consume_token (parser); |
3380 | width = c_parser_expr_no_commas (parser, NULL).value; |
3381 | } |
3382 | if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE)) |
3383 | postfix_attrs = c_parser_attributes (parser); |
3384 | d = grokfield (c_parser_peek_token (parser)->location, |
3385 | declarator, specs, width, &all_prefix_attrs); |
3386 | decl_attributes (&d, chainon (postfix_attrs, |
3387 | all_prefix_attrs), 0); |
3388 | DECL_CHAIN (d) = decls; |
3389 | decls = d; |
3390 | if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE)) |
3391 | all_prefix_attrs = chainon (c_parser_attributes (parser), |
3392 | prefix_attrs); |
3393 | else |
3394 | all_prefix_attrs = prefix_attrs; |
3395 | if (c_parser_next_token_is (parser, CPP_COMMA)) |
3396 | c_parser_consume_token (parser); |
3397 | else if (c_parser_next_token_is (parser, CPP_SEMICOLON) |
3398 | || c_parser_next_token_is (parser, CPP_CLOSE_BRACE)) |
3399 | { |
3400 | /* Semicolon consumed in caller. */ |
3401 | break; |
3402 | } |
3403 | else |
3404 | { |
3405 | c_parser_error (parser, "expected %<,%>, %<;%> or %<}%>" ); |
3406 | break; |
3407 | } |
3408 | } |
3409 | else |
3410 | { |
3411 | c_parser_error (parser, |
3412 | "expected %<:%>, %<,%>, %<;%>, %<}%> or " |
3413 | "%<__attribute__%>" ); |
3414 | break; |
3415 | } |
3416 | } |
3417 | return decls; |
3418 | } |
3419 | |
3420 | /* Parse a typeof specifier (a GNU extension). |
3421 | |
3422 | typeof-specifier: |
3423 | typeof ( expression ) |
3424 | typeof ( type-name ) |
3425 | */ |
3426 | |
3427 | static struct c_typespec |
3428 | c_parser_typeof_specifier (c_parser *parser) |
3429 | { |
3430 | struct c_typespec ret; |
3431 | ret.kind = ctsk_typeof; |
3432 | ret.spec = error_mark_node; |
3433 | ret.expr = NULL_TREE; |
3434 | ret.expr_const_operands = true; |
3435 | gcc_assert (c_parser_next_token_is_keyword (parser, RID_TYPEOF)); |
3436 | c_parser_consume_token (parser); |
3437 | c_inhibit_evaluation_warnings++; |
3438 | in_typeof++; |
3439 | matching_parens parens; |
3440 | if (!parens.require_open (parser)) |
3441 | { |
3442 | c_inhibit_evaluation_warnings--; |
3443 | in_typeof--; |
3444 | return ret; |
3445 | } |
3446 | if (c_parser_next_tokens_start_typename (parser, cla_prefer_id)) |
3447 | { |
3448 | struct c_type_name *type = c_parser_type_name (parser); |
3449 | c_inhibit_evaluation_warnings--; |
3450 | in_typeof--; |
3451 | if (type != NULL) |
3452 | { |
3453 | ret.spec = groktypename (type, &ret.expr, &ret.expr_const_operands); |
3454 | pop_maybe_used (variably_modified_type_p (ret.spec, NULL_TREE)); |
3455 | } |
3456 | } |
3457 | else |
3458 | { |
3459 | bool was_vm; |
3460 | location_t here = c_parser_peek_token (parser)->location; |
3461 | struct c_expr expr = c_parser_expression (parser); |
3462 | c_inhibit_evaluation_warnings--; |
3463 | in_typeof--; |
3464 | if (TREE_CODE (expr.value) == COMPONENT_REF |
3465 | && DECL_C_BIT_FIELD (TREE_OPERAND (expr.value, 1))) |
3466 | error_at (here, "%<typeof%> applied to a bit-field" ); |
3467 | mark_exp_read (expr.value); |
3468 | ret.spec = TREE_TYPE (expr.value); |
3469 | was_vm = variably_modified_type_p (ret.spec, NULL_TREE); |
3470 | /* This is returned with the type so that when the type is |
3471 | evaluated, this can be evaluated. */ |
3472 | if (was_vm) |
3473 | ret.expr = c_fully_fold (expr.value, false, &ret.expr_const_operands); |
3474 | pop_maybe_used (was_vm); |
3475 | /* For use in macros such as those in <stdatomic.h>, remove all |
3476 | qualifiers from atomic types. (const can be an issue for more macros |
3477 | using typeof than just the <stdatomic.h> ones.) */ |
3478 | if (ret.spec != error_mark_node && TYPE_ATOMIC (ret.spec)) |
3479 | ret.spec = c_build_qualified_type (ret.spec, TYPE_UNQUALIFIED); |
3480 | } |
3481 | parens.skip_until_found_close (parser); |
3482 | return ret; |
3483 | } |
3484 | |
3485 | /* Parse an alignment-specifier. |
3486 | |
3487 | C11 6.7.5: |
3488 | |
3489 | alignment-specifier: |
3490 | _Alignas ( type-name ) |
3491 | _Alignas ( constant-expression ) |
3492 | */ |
3493 | |
3494 | static tree |
3495 | c_parser_alignas_specifier (c_parser * parser) |
3496 | { |
3497 | tree ret = error_mark_node; |
3498 | location_t loc = c_parser_peek_token (parser)->location; |
3499 | gcc_assert (c_parser_next_token_is_keyword (parser, RID_ALIGNAS)); |
3500 | c_parser_consume_token (parser); |
3501 | if (flag_isoc99) |
3502 | pedwarn_c99 (loc, OPT_Wpedantic, |
3503 | "ISO C99 does not support %<_Alignas%>" ); |
3504 | else |
3505 | pedwarn_c99 (loc, OPT_Wpedantic, |
3506 | "ISO C90 does not support %<_Alignas%>" ); |
3507 | matching_parens parens; |
3508 | if (!parens.require_open (parser)) |
3509 | return ret; |
3510 | if (c_parser_next_tokens_start_typename (parser, cla_prefer_id)) |
3511 | { |
3512 | struct c_type_name *type = c_parser_type_name (parser); |
3513 | if (type != NULL) |
3514 | ret = c_sizeof_or_alignof_type (loc, groktypename (type, NULL, NULL), |
3515 | false, true, 1); |
3516 | } |
3517 | else |
3518 | ret = c_parser_expr_no_commas (parser, NULL).value; |
3519 | parens.skip_until_found_close (parser); |
3520 | return ret; |
3521 | } |
3522 | |
3523 | /* Parse a declarator, possibly an abstract declarator (C90 6.5.4, |
3524 | 6.5.5, C99 6.7.5, 6.7.6, C11 6.7.6, 6.7.7). If TYPE_SEEN_P then |
3525 | a typedef name may be redeclared; otherwise it may not. KIND |
3526 | indicates which kind of declarator is wanted. Returns a valid |
3527 | declarator except in the case of a syntax error in which case NULL is |
3528 | returned. *SEEN_ID is set to true if an identifier being declared is |
3529 | seen; this is used to diagnose bad forms of abstract array declarators |
3530 | and to determine whether an identifier list is syntactically permitted. |
3531 | |
3532 | declarator: |
3533 | pointer[opt] direct-declarator |
3534 | |
3535 | direct-declarator: |
3536 | identifier |
3537 | ( attributes[opt] declarator ) |
3538 | direct-declarator array-declarator |
3539 | direct-declarator ( parameter-type-list ) |
3540 | direct-declarator ( identifier-list[opt] ) |
3541 | |
3542 | pointer: |
3543 | * type-qualifier-list[opt] |
3544 | * type-qualifier-list[opt] pointer |
3545 | |
3546 | type-qualifier-list: |
3547 | type-qualifier |
3548 | attributes |
3549 | type-qualifier-list type-qualifier |
3550 | type-qualifier-list attributes |
3551 | |
3552 | array-declarator: |
3553 | [ type-qualifier-list[opt] assignment-expression[opt] ] |
3554 | [ static type-qualifier-list[opt] assignment-expression ] |
3555 | [ type-qualifier-list static assignment-expression ] |
3556 | [ type-qualifier-list[opt] * ] |
3557 | |
3558 | parameter-type-list: |
3559 | parameter-list |
3560 | parameter-list , ... |
3561 | |
3562 | parameter-list: |
3563 | parameter-declaration |
3564 | parameter-list , parameter-declaration |
3565 | |
3566 | parameter-declaration: |
3567 | declaration-specifiers declarator attributes[opt] |
3568 | declaration-specifiers abstract-declarator[opt] attributes[opt] |
3569 | |
3570 | identifier-list: |
3571 | identifier |
3572 | identifier-list , identifier |
3573 | |
3574 | abstract-declarator: |
3575 | pointer |
3576 | pointer[opt] direct-abstract-declarator |
3577 | |
3578 | direct-abstract-declarator: |
3579 | ( attributes[opt] abstract-declarator ) |
3580 | direct-abstract-declarator[opt] array-declarator |
3581 | direct-abstract-declarator[opt] ( parameter-type-list[opt] ) |
3582 | |
3583 | GNU extensions: |
3584 | |
3585 | direct-declarator: |
3586 | direct-declarator ( parameter-forward-declarations |
3587 | parameter-type-list[opt] ) |
3588 | |
3589 | direct-abstract-declarator: |
3590 | direct-abstract-declarator[opt] ( parameter-forward-declarations |
3591 | parameter-type-list[opt] ) |
3592 | |
3593 | parameter-forward-declarations: |
3594 | parameter-list ; |
3595 | parameter-forward-declarations parameter-list ; |
3596 | |
3597 | The uses of attributes shown above are GNU extensions. |
3598 | |
3599 | Some forms of array declarator are not included in C99 in the |
3600 | syntax for abstract declarators; these are disallowed elsewhere. |
3601 | This may be a defect (DR#289). |
3602 | |
3603 | This function also accepts an omitted abstract declarator as being |
3604 | an abstract declarator, although not part of the formal syntax. */ |
3605 | |
3606 | struct c_declarator * |
3607 | c_parser_declarator (c_parser *parser, bool type_seen_p, c_dtr_syn kind, |
3608 | bool *seen_id) |
3609 | { |
3610 | /* Parse any initial pointer part. */ |
3611 | if (c_parser_next_token_is (parser, CPP_MULT)) |
3612 | { |
3613 | struct c_declspecs *quals_attrs = build_null_declspecs (); |
3614 | struct c_declarator *inner; |
3615 | c_parser_consume_token (parser); |
3616 | c_parser_declspecs (parser, quals_attrs, false, false, true, |
3617 | false, false, cla_prefer_id); |
3618 | inner = c_parser_declarator (parser, type_seen_p, kind, seen_id); |
3619 | if (inner == NULL) |
3620 | return NULL; |
3621 | else |
3622 | return make_pointer_declarator (quals_attrs, inner); |
3623 | } |
3624 | /* Now we have a direct declarator, direct abstract declarator or |
3625 | nothing (which counts as a direct abstract declarator here). */ |
3626 | return c_parser_direct_declarator (parser, type_seen_p, kind, seen_id); |
3627 | } |
3628 | |
3629 | /* Parse a direct declarator or direct abstract declarator; arguments |
3630 | as c_parser_declarator. */ |
3631 | |
3632 | static struct c_declarator * |
3633 | c_parser_direct_declarator (c_parser *parser, bool type_seen_p, c_dtr_syn kind, |
3634 | bool *seen_id) |
3635 | { |
3636 | /* The direct declarator must start with an identifier (possibly |
3637 | omitted) or a parenthesized declarator (possibly abstract). In |
3638 | an ordinary declarator, initial parentheses must start a |
3639 | parenthesized declarator. In an abstract declarator or parameter |
3640 | declarator, they could start a parenthesized declarator or a |
3641 | parameter list. To tell which, the open parenthesis and any |
3642 | following attributes must be read. If a declaration specifier |
3643 | follows, then it is a parameter list; if the specifier is a |
3644 | typedef name, there might be an ambiguity about redeclaring it, |
3645 | which is resolved in the direction of treating it as a typedef |
3646 | name. If a close parenthesis follows, it is also an empty |
3647 | parameter list, as the syntax does not permit empty abstract |
3648 | declarators. Otherwise, it is a parenthesized declarator (in |
3649 | which case the analysis may be repeated inside it, recursively). |
3650 | |
3651 | ??? There is an ambiguity in a parameter declaration "int |
3652 | (__attribute__((foo)) x)", where x is not a typedef name: it |
3653 | could be an abstract declarator for a function, or declare x with |
3654 | parentheses. The proper resolution of this ambiguity needs |
3655 | documenting. At present we follow an accident of the old |
3656 | parser's implementation, whereby the first parameter must have |
3657 | some declaration specifiers other than just attributes. Thus as |
3658 | a parameter declaration it is treated as a parenthesized |
3659 | parameter named x, and as an abstract declarator it is |
3660 | rejected. |
3661 | |
3662 | ??? Also following the old parser, attributes inside an empty |
3663 | parameter list are ignored, making it a list not yielding a |
3664 | prototype, rather than giving an error or making it have one |
3665 | parameter with implicit type int. |
3666 | |
3667 | ??? Also following the old parser, typedef names may be |
3668 | redeclared in declarators, but not Objective-C class names. */ |
3669 | |
3670 | if (kind != C_DTR_ABSTRACT |
3671 | && c_parser_next_token_is (parser, CPP_NAME) |
3672 | && ((type_seen_p |
3673 | && (c_parser_peek_token (parser)->id_kind == C_ID_TYPENAME |
3674 | || c_parser_peek_token (parser)->id_kind == C_ID_CLASSNAME)) |
3675 | || c_parser_peek_token (parser)->id_kind == C_ID_ID)) |
3676 | { |
3677 | struct c_declarator *inner |
3678 | = build_id_declarator (c_parser_peek_token (parser)->value); |
3679 | *seen_id = true; |
3680 | inner->id_loc = c_parser_peek_token (parser)->location; |
3681 | c_parser_consume_token (parser); |
3682 | return c_parser_direct_declarator_inner (parser, *seen_id, inner); |
3683 | } |
3684 | |
3685 | if (kind != C_DTR_NORMAL |
3686 | && c_parser_next_token_is (parser, CPP_OPEN_SQUARE)) |
3687 | { |
3688 | struct c_declarator *inner = build_id_declarator (NULL_TREE); |
3689 | inner->id_loc = c_parser_peek_token (parser)->location; |
3690 | return c_parser_direct_declarator_inner (parser, *seen_id, inner); |
3691 | } |
3692 | |
3693 | /* Either we are at the end of an abstract declarator, or we have |
3694 | parentheses. */ |
3695 | |
3696 | if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)) |
3697 | { |
3698 | tree attrs; |
3699 | struct c_declarator *inner; |
3700 | c_parser_consume_token (parser); |
3701 | attrs = c_parser_attributes (parser); |
3702 | if (kind != C_DTR_NORMAL |
3703 | && (c_parser_next_token_starts_declspecs (parser) |
3704 | || c_parser_next_token_is (parser, CPP_CLOSE_PAREN))) |
3705 | { |
3706 | struct c_arg_info *args |
3707 | = c_parser_parms_declarator (parser, kind == C_DTR_NORMAL, |
3708 | attrs); |
3709 | if (args == NULL) |
3710 | return NULL; |
3711 | else |
3712 | { |
3713 | inner |
3714 | = build_function_declarator (args, |
3715 | build_id_declarator (NULL_TREE)); |
3716 | return c_parser_direct_declarator_inner (parser, *seen_id, |
3717 | inner); |
3718 | } |
3719 | } |
3720 | /* A parenthesized declarator. */ |
3721 | inner = c_parser_declarator (parser, type_seen_p, kind, seen_id); |
3722 | if (inner != NULL && attrs != NULL) |
3723 | inner = build_attrs_declarator (attrs, inner); |
3724 | if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) |
3725 | { |
3726 | c_parser_consume_token (parser); |
3727 | if (inner == NULL) |
3728 | return NULL; |
3729 | else |
3730 | return c_parser_direct_declarator_inner (parser, *seen_id, inner); |
3731 | } |
3732 | else |
3733 | { |
3734 | c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, |
3735 | "expected %<)%>" ); |
3736 | return NULL; |
3737 | } |
3738 | } |
3739 | else |
3740 | { |
3741 | if (kind == C_DTR_NORMAL) |
3742 | { |
3743 | c_parser_error (parser, "expected identifier or %<(%>" ); |
3744 | return NULL; |
3745 | } |
3746 | else |
3747 | return build_id_declarator (NULL_TREE); |
3748 | } |
3749 | } |
3750 | |
3751 | /* Parse part of a direct declarator or direct abstract declarator, |
3752 | given that some (in INNER) has already been parsed; ID_PRESENT is |
3753 | true if an identifier is present, false for an abstract |
3754 | declarator. */ |
3755 | |
3756 | static struct c_declarator * |
3757 | c_parser_direct_declarator_inner (c_parser *parser, bool id_present, |
3758 | struct c_declarator *inner) |
3759 | { |
3760 | /* Parse a sequence of array declarators and parameter lists. */ |
3761 | if (c_parser_next_token_is (parser, CPP_OPEN_SQUARE)) |
3762 | { |
3763 | location_t brace_loc = c_parser_peek_token (parser)->location; |
3764 | struct c_declarator *declarator; |
3765 | struct c_declspecs *quals_attrs = build_null_declspecs (); |
3766 | bool static_seen; |
3767 | bool star_seen; |
3768 | struct c_expr dimen; |
3769 | dimen.value = NULL_TREE; |
3770 | dimen.original_code = ERROR_MARK; |
3771 | dimen.original_type = NULL_TREE; |
3772 | c_parser_consume_token (parser); |
3773 | c_parser_declspecs (parser, quals_attrs, false, false, true, |
3774 | false, false, cla_prefer_id); |
3775 | static_seen = c_parser_next_token_is_keyword (parser, RID_STATIC); |
3776 | if (static_seen) |
3777 | c_parser_consume_token (parser); |
3778 | if (static_seen && !quals_attrs->declspecs_seen_p) |
3779 | c_parser_declspecs (parser, quals_attrs, false, false, true, |
3780 | false, false, cla_prefer_id); |
3781 | if (!quals_attrs->declspecs_seen_p) |
3782 | quals_attrs = NULL; |
3783 | /* If "static" is present, there must be an array dimension. |
3784 | Otherwise, there may be a dimension, "*", or no |
3785 | dimension. */ |
3786 | if (static_seen) |
3787 | { |
3788 | star_seen = false; |
3789 | dimen = c_parser_expr_no_commas (parser, NULL); |
3790 | } |
3791 | else |
3792 | { |
3793 | if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE)) |
3794 | { |
3795 | dimen.value = NULL_TREE; |
3796 | star_seen = false; |
3797 | } |
3798 | else if (c_parser_next_token_is (parser, CPP_MULT)) |
3799 | { |
3800 | if (c_parser_peek_2nd_token (parser)->type == CPP_CLOSE_SQUARE) |
3801 | { |
3802 | dimen.value = NULL_TREE; |
3803 | star_seen = true; |
3804 | c_parser_consume_token (parser); |
3805 | } |
3806 | else |
3807 | { |
3808 | star_seen = false; |
3809 | dimen = c_parser_expr_no_commas (parser, NULL); |
3810 | } |
3811 | } |
3812 | else |
3813 | { |
3814 | star_seen = false; |
3815 | dimen = c_parser_expr_no_commas (parser, NULL); |
3816 | } |
3817 | } |
3818 | if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE)) |
3819 | c_parser_consume_token (parser); |
3820 | else |
3821 | { |
3822 | c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, |
3823 | "expected %<]%>" ); |
3824 | return NULL; |
3825 | } |
3826 | if (dimen.value) |
3827 | dimen = convert_lvalue_to_rvalue (brace_loc, dimen, true, true); |
3828 | declarator = build_array_declarator (brace_loc, dimen.value, quals_attrs, |
3829 | static_seen, star_seen); |
3830 | if (declarator == NULL) |
3831 | return NULL; |
3832 | inner = set_array_declarator_inner (declarator, inner); |
3833 | return c_parser_direct_declarator_inner (parser, id_present, inner); |
3834 | } |
3835 | else if (c_parser_next_token_is (parser, CPP_OPEN_PAREN)) |
3836 | { |
3837 | tree attrs; |
3838 | struct c_arg_info *args; |
3839 | c_parser_consume_token (parser); |
3840 | attrs = c_parser_attributes (parser); |
3841 | args = c_parser_parms_declarator (parser, id_present, attrs); |
3842 | if (args == NULL) |
3843 | return NULL; |
3844 | else |
3845 | { |
3846 | inner = build_function_declarator (args, inner); |
3847 | return c_parser_direct_declarator_inner (parser, id_present, inner); |
3848 | } |
3849 | } |
3850 | return inner; |
3851 | } |
3852 | |
3853 | /* Parse a parameter list or identifier list, including the closing |
3854 | parenthesis but not the opening one. ATTRS are the attributes at |
3855 | the start of the list. ID_LIST_OK is true if an identifier list is |
3856 | acceptable; such a list must not have attributes at the start. */ |
3857 | |
3858 | static struct c_arg_info * |
3859 | c_parser_parms_declarator (c_parser *parser, bool id_list_ok, tree attrs) |
3860 | { |
3861 | push_scope (); |
3862 | declare_parm_level (); |
3863 | /* If the list starts with an identifier, it is an identifier list. |
3864 | Otherwise, it is either a prototype list or an empty list. */ |
3865 | if (id_list_ok |
3866 | && !attrs |
3867 | && c_parser_next_token_is (parser, CPP_NAME) |
3868 | && c_parser_peek_token (parser)->id_kind == C_ID_ID |
3869 | |
3870 | /* Look ahead to detect typos in type names. */ |
3871 | && c_parser_peek_2nd_token (parser)->type != CPP_NAME |
3872 | && c_parser_peek_2nd_token (parser)->type != CPP_MULT |
3873 | && c_parser_peek_2nd_token (parser)->type != CPP_OPEN_PAREN |
3874 | && c_parser_peek_2nd_token (parser)->type != CPP_OPEN_SQUARE |
3875 | && c_parser_peek_2nd_token (parser)->type != CPP_KEYWORD) |
3876 | { |
3877 | tree list = NULL_TREE, *nextp = &list; |
3878 | while (c_parser_next_token_is (parser, CPP_NAME) |
3879 | && c_parser_peek_token (parser)->id_kind == C_ID_ID) |
3880 | { |
3881 | *nextp = build_tree_list (NULL_TREE, |
3882 | c_parser_peek_token (parser)->value); |
3883 | nextp = & TREE_CHAIN (*nextp); |
3884 | c_parser_consume_token (parser); |
3885 | if (c_parser_next_token_is_not (parser, CPP_COMMA)) |
3886 | break; |
3887 | c_parser_consume_token (parser); |
3888 | if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) |
3889 | { |
3890 | c_parser_error (parser, "expected identifier" ); |
3891 | break; |
3892 | } |
3893 | } |
3894 | if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) |
3895 | { |
3896 | struct c_arg_info *ret = build_arg_info (); |
3897 | ret->types = list; |
3898 | c_parser_consume_token (parser); |
3899 | pop_scope (); |
3900 | return ret; |
3901 | } |
3902 | else |
3903 | { |
3904 | c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, |
3905 | "expected %<)%>" ); |
3906 | pop_scope (); |
3907 | return NULL; |
3908 | } |
3909 | } |
3910 | else |
3911 | { |
3912 | struct c_arg_info *ret = c_parser_parms_list_declarator (parser, attrs, |
3913 | NULL); |
3914 | pop_scope (); |
3915 | return ret; |
3916 | } |
3917 | } |
3918 | |
3919 | /* Parse a parameter list (possibly empty), including the closing |
3920 | parenthesis but not the opening one. ATTRS are the attributes at |
3921 | the start of the list. EXPR is NULL or an expression that needs to |
3922 | be evaluated for the side effects of array size expressions in the |
3923 | parameters. */ |
3924 | |
3925 | static struct c_arg_info * |
3926 | c_parser_parms_list_declarator (c_parser *parser, tree attrs, tree expr) |
3927 | { |
3928 | bool bad_parm = false; |
3929 | |
3930 | /* ??? Following the old parser, forward parameter declarations may |
3931 | use abstract declarators, and if no real parameter declarations |
3932 | follow the forward declarations then this is not diagnosed. Also |
3933 | note as above that attributes are ignored as the only contents of |
3934 | the parentheses, or as the only contents after forward |
3935 | declarations. */ |
3936 | if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) |
3937 | { |
3938 | struct c_arg_info *ret = build_arg_info (); |
3939 | c_parser_consume_token (parser); |
3940 | return ret; |
3941 | } |
3942 | if (c_parser_next_token_is (parser, CPP_ELLIPSIS)) |
3943 | { |
3944 | struct c_arg_info *ret = build_arg_info (); |
3945 | |
3946 | if (flag_allow_parameterless_variadic_functions) |
3947 | { |
3948 | /* F (...) is allowed. */ |
3949 | ret->types = NULL_TREE; |
3950 | } |
3951 | else |
3952 | { |
3953 | /* Suppress -Wold-style-definition for this case. */ |
3954 | ret->types = error_mark_node; |
3955 | error_at (c_parser_peek_token (parser)->location, |
3956 | "ISO C requires a named argument before %<...%>" ); |
3957 | } |
3958 | c_parser_consume_token (parser); |
3959 | if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) |
3960 | { |
3961 | c_parser_consume_token (parser); |
3962 | return ret; |
3963 | } |
3964 | else |
3965 | { |
3966 | c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, |
3967 | "expected %<)%>" ); |
3968 | return NULL; |
3969 | } |
3970 | } |
3971 | /* Nonempty list of parameters, either terminated with semicolon |
3972 | (forward declarations; recurse) or with close parenthesis (normal |
3973 | function) or with ", ... )" (variadic function). */ |
3974 | while (true) |
3975 | { |
3976 | /* Parse a parameter. */ |
3977 | struct c_parm *parm = c_parser_parameter_declaration (parser, attrs); |
3978 | attrs = NULL_TREE; |
3979 | if (parm == NULL) |
3980 | bad_parm = true; |
3981 | else |
3982 | push_parm_decl (parm, &expr); |
3983 | if (c_parser_next_token_is (parser, CPP_SEMICOLON)) |
3984 | { |
3985 | tree new_attrs; |
3986 | c_parser_consume_token (parser); |
3987 | mark_forward_parm_decls (); |
3988 | new_attrs = c_parser_attributes (parser); |
3989 | return c_parser_parms_list_declarator (parser, new_attrs, expr); |
3990 | } |
3991 | if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) |
3992 | { |
3993 | c_parser_consume_token (parser); |
3994 | if (bad_parm) |
3995 | return NULL; |
3996 | else |
3997 | return get_parm_info (false, expr); |
3998 | } |
3999 | if (!c_parser_require (parser, CPP_COMMA, |
4000 | "expected %<;%>, %<,%> or %<)%>" , |
4001 | UNKNOWN_LOCATION, false)) |
4002 | { |
4003 | c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); |
4004 | return NULL; |
4005 | } |
4006 | if (c_parser_next_token_is (parser, CPP_ELLIPSIS)) |
4007 | { |
4008 | c_parser_consume_token (parser); |
4009 | if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) |
4010 | { |
4011 | c_parser_consume_token (parser); |
4012 | if (bad_parm) |
4013 | return NULL; |
4014 | else |
4015 | return get_parm_info (true, expr); |
4016 | } |
4017 | else |
4018 | { |
4019 | c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, |
4020 | "expected %<)%>" ); |
4021 | return NULL; |
4022 | } |
4023 | } |
4024 | } |
4025 | } |
4026 | |
4027 | /* Parse a parameter declaration. ATTRS are the attributes at the |
4028 | start of the declaration if it is the first parameter. */ |
4029 | |
4030 | static struct c_parm * |
4031 | c_parser_parameter_declaration (c_parser *parser, tree attrs) |
4032 | { |
4033 | struct c_declspecs *specs; |
4034 | struct c_declarator *declarator; |
4035 | tree prefix_attrs; |
4036 | tree postfix_attrs = NULL_TREE; |
4037 | bool dummy = false; |
4038 | |
4039 | /* Accept #pragmas between parameter declarations. */ |
4040 | while (c_parser_next_token_is (parser, CPP_PRAGMA)) |
4041 | c_parser_pragma (parser, pragma_param, NULL); |
4042 | |
4043 | if (!c_parser_next_token_starts_declspecs (parser)) |
4044 | { |
4045 | c_token *token = c_parser_peek_token (parser); |
4046 | if (parser->error) |
4047 | return NULL; |
4048 | c_parser_set_source_position_from_token (token); |
4049 | if (c_parser_next_tokens_start_typename (parser, cla_prefer_type)) |
4050 | { |
4051 | name_hint hint = lookup_name_fuzzy (token->value, |
4052 | FUZZY_LOOKUP_TYPENAME, |
4053 | token->location); |
4054 | if (hint) |
4055 | { |
4056 | gcc_rich_location richloc (token->location); |
4057 | richloc.add_fixit_replace (hint.suggestion ()); |
4058 | error_at (&richloc, |
4059 | "unknown type name %qE; did you mean %qs?" , |
4060 | token->value, hint.suggestion ()); |
4061 | } |
4062 | else |
4063 | error_at (token->location, "unknown type name %qE" , token->value); |
4064 | parser->error = true; |
4065 | } |
4066 | /* ??? In some Objective-C cases '...' isn't applicable so there |
4067 | should be a different message. */ |
4068 | else |
4069 | c_parser_error (parser, |
4070 | "expected declaration specifiers or %<...%>" ); |
4071 | c_parser_skip_to_end_of_parameter (parser); |
4072 | return NULL; |
4073 | } |
4074 | |
4075 | location_t start_loc = c_parser_peek_token (parser)->location; |
4076 | |
4077 | specs = build_null_declspecs (); |
4078 | if (attrs) |
4079 | { |
4080 | declspecs_add_attrs (input_location, specs, attrs); |
4081 | attrs = NULL_TREE; |
4082 | } |
4083 | c_parser_declspecs (parser, specs, true, true, true, true, false, |
4084 | cla_nonabstract_decl); |
4085 | finish_declspecs (specs); |
4086 | pending_xref_error (); |
4087 | prefix_attrs = specs->attrs; |
4088 | specs->attrs = NULL_TREE; |
4089 | declarator = c_parser_declarator (parser, |
4090 | specs->typespec_kind != ctsk_none, |
4091 | C_DTR_PARM, &dummy); |
4092 | if (declarator == NULL) |
4093 | { |
4094 | c_parser_skip_until_found (parser, CPP_COMMA, NULL); |
4095 | return NULL; |
4096 | } |
4097 | if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE)) |
4098 | postfix_attrs = c_parser_attributes (parser); |
4099 | |
4100 | /* Generate a location for the parameter, ranging from the start of the |
4101 | initial token to the end of the final token. |
4102 | |
4103 | If we have a identifier, then use it for the caret location, e.g. |
4104 | |
4105 | extern int callee (int one, int (*two)(int, int), float three); |
4106 | ~~~~~~^~~~~~~~~~~~~~ |
4107 | |
4108 | otherwise, reuse the start location for the caret location e.g.: |
4109 | |
4110 | extern int callee (int one, int (*)(int, int), float three); |
4111 | ^~~~~~~~~~~~~~~~~ |
4112 | */ |
4113 | location_t end_loc = parser->last_token_location; |
4114 | |
4115 | /* Find any cdk_id declarator; determine if we have an identifier. */ |
4116 | c_declarator *id_declarator = declarator; |
4117 | while (id_declarator && id_declarator->kind != cdk_id) |
4118 | id_declarator = id_declarator->declarator; |
4119 | location_t caret_loc = (id_declarator->u.id |
4120 | ? id_declarator->id_loc |
4121 | : start_loc); |
4122 | location_t param_loc = make_location (caret_loc, start_loc, end_loc); |
4123 | |
4124 | return build_c_parm (specs, chainon (postfix_attrs, prefix_attrs), |
4125 | declarator, param_loc); |
4126 | } |
4127 | |
4128 | /* Parse a string literal in an asm expression. It should not be |
4129 | translated, and wide string literals are an error although |
4130 | permitted by the syntax. This is a GNU extension. |
4131 | |
4132 | asm-string-literal: |
4133 | string-literal |
4134 | |
4135 | ??? At present, following the old parser, the caller needs to have |
4136 | set lex_untranslated_string to 1. It would be better to follow the |
4137 | C++ parser rather than using this kludge. */ |
4138 | |
4139 | static tree |
4140 | c_parser_asm_string_literal (c_parser *parser) |
4141 | { |
4142 | tree str; |
4143 | int save_flag = warn_overlength_strings; |
4144 | warn_overlength_strings = 0; |
4145 | if (c_parser_next_token_is (parser, CPP_STRING)) |
4146 | { |
4147 | str = c_parser_peek_token (parser)->value; |
4148 | c_parser_consume_token (parser); |
4149 | } |
4150 | else if (c_parser_next_token_is (parser, CPP_WSTRING)) |
4151 | { |
4152 | error_at (c_parser_peek_token (parser)->location, |
4153 | "wide string literal in %<asm%>" ); |
4154 | str = build_string (1, "" ); |
4155 | c_parser_consume_token (parser); |
4156 | } |
4157 | else |
4158 | { |
4159 | c_parser_error (parser, "expected string literal" ); |
4160 | str = NULL_TREE; |
4161 | } |
4162 | warn_overlength_strings = save_flag; |
4163 | return str; |
4164 | } |
4165 | |
4166 | /* Parse a simple asm expression. This is used in restricted |
4167 | contexts, where a full expression with inputs and outputs does not |
4168 | make sense. This is a GNU extension. |
4169 | |
4170 | simple-asm-expr: |
4171 | asm ( asm-string-literal ) |
4172 | */ |
4173 | |
4174 | static tree |
4175 | c_parser_simple_asm_expr (c_parser *parser) |
4176 | { |
4177 | tree str; |
4178 | gcc_assert (c_parser_next_token_is_keyword (parser, RID_ASM)); |
4179 | /* ??? Follow the C++ parser rather than using the |
4180 | lex_untranslated_string kludge. */ |
4181 | parser->lex_untranslated_string = true; |
4182 | c_parser_consume_token (parser); |
4183 | matching_parens parens; |
4184 | if (!parens.require_open (parser)) |
4185 | { |
4186 | parser->lex_untranslated_string = false; |
4187 | return NULL_TREE; |
4188 | } |
4189 | str = c_parser_asm_string_literal (parser); |
4190 | parser->lex_untranslated_string = false; |
4191 | if (!parens.require_close (parser)) |
4192 | { |
4193 | c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); |
4194 | return NULL_TREE; |
4195 | } |
4196 | return str; |
4197 | } |
4198 | |
4199 | static tree |
4200 | c_parser_attribute_any_word (c_parser *parser) |
4201 | { |
4202 | tree attr_name = NULL_TREE; |
4203 | |
4204 | if (c_parser_next_token_is (parser, CPP_KEYWORD)) |
4205 | { |
4206 | /* ??? See comment above about what keywords are accepted here. */ |
4207 | bool ok; |
4208 | switch (c_parser_peek_token (parser)->keyword) |
4209 | { |
4210 | case RID_STATIC: |
4211 | case RID_UNSIGNED: |
4212 | case RID_LONG: |
4213 | case RID_CONST: |
4214 | case RID_EXTERN: |
4215 | case RID_REGISTER: |
4216 | case RID_TYPEDEF: |
4217 | case RID_SHORT: |
4218 | case RID_INLINE: |
4219 | case RID_NORETURN: |
4220 | case RID_VOLATILE: |
4221 | case RID_SIGNED: |
4222 | case RID_AUTO: |
4223 | case RID_RESTRICT: |
4224 | case RID_COMPLEX: |
4225 | case RID_THREAD: |
4226 | case RID_INT: |
4227 | case RID_CHAR: |
4228 | case RID_FLOAT: |
4229 | case RID_DOUBLE: |
4230 | case RID_VOID: |
4231 | case RID_DFLOAT32: |
4232 | case RID_DFLOAT64: |
4233 | case RID_DFLOAT128: |
4234 | CASE_RID_FLOATN_NX: |
4235 | case RID_BOOL: |
4236 | case RID_FRACT: |
4237 | case RID_ACCUM: |
4238 | case RID_SAT: |
4239 | case RID_TRANSACTION_ATOMIC: |
4240 | case RID_TRANSACTION_CANCEL: |
4241 | case RID_ATOMIC: |
4242 | case RID_AUTO_TYPE: |
4243 | case RID_INT_N_0: |
4244 | case RID_INT_N_1: |
4245 | case RID_INT_N_2: |
4246 | case RID_INT_N_3: |
4247 | ok = true; |
4248 | break; |
4249 | default: |
4250 | ok = false; |
4251 | break; |
4252 | } |
4253 | if (!ok) |
4254 | return NULL_TREE; |
4255 | |
4256 | /* Accept __attribute__((__const)) as __attribute__((const)) etc. */ |
4257 | attr_name = ridpointers[(int) c_parser_peek_token (parser)->keyword]; |
4258 | } |
4259 | else if (c_parser_next_token_is (parser, CPP_NAME)) |
4260 | attr_name = c_parser_peek_token (parser)->value; |
4261 | |
4262 | return attr_name; |
4263 | } |
4264 | |
4265 | /* Parse (possibly empty) attributes. This is a GNU extension. |
4266 | |
4267 | attributes: |
4268 | empty |
4269 | attributes attribute |
4270 | |
4271 | attribute: |
4272 | __attribute__ ( ( attribute-list ) ) |
4273 | |
4274 | attribute-list: |
4275 | attrib |
4276 | attribute_list , attrib |
4277 | |
4278 | attrib: |
4279 | empty |
4280 | any-word |
4281 | any-word ( identifier ) |
4282 | any-word ( identifier , nonempty-expr-list ) |
4283 | any-word ( expr-list ) |
4284 | |
4285 | where the "identifier" must not be declared as a type, and |
4286 | "any-word" may be any identifier (including one declared as a |
4287 | type), a reserved word storage class specifier, type specifier or |
4288 | type qualifier. ??? This still leaves out most reserved keywords |
4289 | (following the old parser), shouldn't we include them, and why not |
4290 | allow identifiers declared as types to start the arguments? */ |
4291 | |
4292 | static tree |
4293 | c_parser_attributes (c_parser *parser) |
4294 | { |
4295 | tree attrs = NULL_TREE; |
4296 | while (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE)) |
4297 | { |
4298 | /* ??? Follow the C++ parser rather than using the |
4299 | lex_untranslated_string kludge. */ |
4300 | parser->lex_untranslated_string = true; |
4301 | /* Consume the `__attribute__' keyword. */ |
4302 | c_parser_consume_token (parser); |
4303 | /* Look for the two `(' tokens. */ |
4304 | if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>" )) |
4305 | { |
4306 | parser->lex_untranslated_string = false; |
4307 | return attrs; |
4308 | } |
4309 | if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>" )) |
4310 | { |
4311 | parser->lex_untranslated_string = false; |
4312 | c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); |
4313 | return attrs; |
4314 | } |
4315 | /* Parse the attribute list. */ |
4316 | while (c_parser_next_token_is (parser, CPP_COMMA) |
4317 | || c_parser_next_token_is (parser, CPP_NAME) |
4318 | || c_parser_next_token_is (parser, CPP_KEYWORD)) |
4319 | { |
4320 | tree attr, attr_name, attr_args; |
4321 | vec<tree, va_gc> *expr_list; |
4322 | if (c_parser_next_token_is (parser, CPP_COMMA)) |
4323 | { |
4324 | c_parser_consume_token (parser); |
4325 | continue; |
4326 | } |
4327 | |
4328 | attr_name = c_parser_attribute_any_word (parser); |
4329 | if (attr_name == NULL) |
4330 | break; |
4331 | attr_name = canonicalize_attr_name (attr_name); |
4332 | c_parser_consume_token (parser); |
4333 | if (c_parser_next_token_is_not (parser, CPP_OPEN_PAREN)) |
4334 | { |
4335 | attr = build_tree_list (attr_name, NULL_TREE); |
4336 | /* Add this attribute to the list. */ |
4337 | attrs = chainon (attrs, attr); |
4338 | /* If the next token isn't a comma, we're done. */ |
4339 | if (!c_parser_next_token_is (parser, CPP_COMMA)) |
4340 | break; |
4341 | continue; |
4342 | } |
4343 | c_parser_consume_token (parser); |
4344 | /* Parse the attribute contents. If they start with an |
4345 | identifier which is followed by a comma or close |
4346 | parenthesis, then the arguments start with that |
4347 | identifier; otherwise they are an expression list. |
4348 | In objective-c the identifier may be a classname. */ |
4349 | if (c_parser_next_token_is (parser, CPP_NAME) |
4350 | && (c_parser_peek_token (parser)->id_kind == C_ID_ID |
4351 | || (c_dialect_objc () |
4352 | && c_parser_peek_token (parser)->id_kind |
4353 | == C_ID_CLASSNAME)) |
4354 | && ((c_parser_peek_2nd_token (parser)->type == CPP_COMMA) |
4355 | || (c_parser_peek_2nd_token (parser)->type |
4356 | == CPP_CLOSE_PAREN)) |
4357 | && (attribute_takes_identifier_p (attr_name) |
4358 | || (c_dialect_objc () |
4359 | && c_parser_peek_token (parser)->id_kind |
4360 | == C_ID_CLASSNAME))) |
4361 | { |
4362 | tree arg1 = c_parser_peek_token (parser)->value; |
4363 | c_parser_consume_token (parser); |
4364 | if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) |
4365 | attr_args = build_tree_list (NULL_TREE, arg1); |
4366 | else |
4367 | { |
4368 | tree tree_list; |
4369 | c_parser_consume_token (parser); |
4370 | expr_list = c_parser_expr_list (parser, false, true, |
4371 | NULL, NULL, NULL, NULL); |
4372 | tree_list = build_tree_list_vec (expr_list); |
4373 | attr_args = tree_cons (NULL_TREE, arg1, tree_list); |
4374 | release_tree_vector (expr_list); |
4375 | } |
4376 | } |
4377 | else |
4378 | { |
4379 | if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) |
4380 | attr_args = NULL_TREE; |
4381 | else |
4382 | { |
4383 | expr_list = c_parser_expr_list (parser, false, true, |
4384 | NULL, NULL, NULL, NULL); |
4385 | attr_args = build_tree_list_vec (expr_list); |
4386 | release_tree_vector (expr_list); |
4387 | } |
4388 | } |
4389 | |
4390 | attr = build_tree_list (attr_name, attr_args); |
4391 | if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) |
4392 | c_parser_consume_token (parser); |
4393 | else |
4394 | { |
4395 | parser->lex_untranslated_string = false; |
4396 | c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, |
4397 | "expected %<)%>" ); |
4398 | return attrs; |
4399 | } |
4400 | /* Add this attribute to the list. */ |
4401 | attrs = chainon (attrs, attr); |
4402 | /* If the next token isn't a comma, we're done. */ |
4403 | if (!c_parser_next_token_is (parser, CPP_COMMA)) |
4404 | break; |
4405 | } |
4406 | /* Look for the two `)' tokens. */ |
4407 | if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) |
4408 | c_parser_consume_token (parser); |
4409 | else |
4410 | { |
4411 | parser->lex_untranslated_string = false; |
4412 | c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, |
4413 | "expected %<)%>" ); |
4414 | return attrs; |
4415 | } |
4416 | if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN)) |
4417 | c_parser_consume_token (parser); |
4418 | else |
4419 | { |
4420 | parser->lex_untranslated_string = false; |
4421 | c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, |
4422 | "expected %<)%>" ); |
4423 | return attrs; |
4424 | } |
4425 | parser->lex_untranslated_string = false; |
4426 | } |
4427 | |
4428 | return attrs; |
4429 | } |
4430 | |
4431 | /* Parse a type name (C90 6.5.5, C99 6.7.6, C11 6.7.7). ALIGNAS_OK |
4432 | says whether alignment specifiers are OK (only in cases that might |
4433 | be the type name of a compound literal). |
4434 | |
4435 | type-name: |
4436 | specifier-qualifier-list abstract-declarator[opt] |
4437 | */ |
4438 | |
4439 | struct c_type_name * |
4440 | c_parser_type_name (c_parser *parser, bool alignas_ok) |
4441 | { |
4442 | struct c_declspecs *specs = build_null_declspecs (); |
4443 | struct c_declarator *declarator; |
4444 | struct c_type_name *ret; |
4445 | bool dummy = false; |
4446 | c_parser_declspecs (parser, specs, false, true, true, alignas_ok, false, |
4447 | cla_prefer_type); |
4448 | if (!specs->declspecs_seen_p) |
4449 | { |
4450 | c_parser_error (parser, "expected specifier-qualifier-list" ); |
4451 | return NULL; |
4452 | } |
4453 | if (specs->type != error_mark_node) |
4454 | { |
4455 | pending_xref_error (); |
4456 | finish_declspecs (specs); |
4457 | } |
4458 | declarator = c_parser_declarator (parser, |
4459 | specs->typespec_kind != ctsk_none, |
4460 | C_DTR_ABSTRACT, &dummy); |
4461 | if (declarator == NULL) |
4462 | return NULL; |
4463 | ret = XOBNEW (&parser_obstack, struct c_type_name); |
4464 | ret->specs = specs; |
4465 | ret->declarator = declarator; |
4466 | return ret; |
4467 | } |
4468 | |
4469 | /* Parse an initializer (C90 6.5.7, C99 6.7.8, C11 6.7.9). |
4470 | |
4471 | initializer: |
4472 | assignment-expression |
4473 | { initializer-list } |
4474 | { initializer-list , } |
4475 | |
4476 | initializer-list: |
4477 | designation[opt] initializer |
4478 | initializer-list , designation[opt] initializer |
4479 | |
4480 | designation: |
4481 | designator-list = |
4482 | |
4483 | designator-list: |
4484 | designator |
4485 | designator-list designator |
4486 | |
4487 | designator: |
4488 | array-designator |
4489 | . identifier |
4490 | |
4491 | array-designator: |
4492 | [ constant-expression ] |
4493 | |
4494 | GNU extensions: |
4495 | |
4496 | initializer: |
4497 | { } |
4498 | |
4499 | designation: |
4500 | array-designator |
4501 | identifier : |
4502 | |
4503 | array-designator: |
4504 | [ constant-expression ... constant-expression ] |
4505 | |
4506 | Any expression without commas is accepted in the syntax for the |
4507 | constant-expressions, with non-constant expressions rejected later. |
4508 | |
4509 | This function is only used for top-level initializers; for nested |
4510 | ones, see c_parser_initval. */ |
4511 | |
4512 | static struct c_expr |
4513 | c_parser_initializer (c_parser *parser) |
4514 | { |
4515 | if (c_parser_next_token_is (parser, CPP_OPEN_BRACE)) |
4516 | return c_parser_braced_init (parser, NULL_TREE, false, NULL); |
4517 | else |
4518 | { |
4519 | struct c_expr ret; |
4520 | location_t loc = c_parser_peek_token (parser)->location; |
4521 | ret = c_parser_expr_no_commas (parser, NULL); |
4522 | if (TREE_CODE (ret.value) != STRING_CST |
4523 | && TREE_CODE (ret.value) != COMPOUND_LITERAL_EXPR) |
4524 | ret = convert_lvalue_to_rvalue (loc, ret, true, true); |
4525 | return ret; |
4526 | } |
4527 | } |
4528 | |
4529 | /* The location of the last comma within the current initializer list, |
4530 | or UNKNOWN_LOCATION if not within one. */ |
4531 | |
4532 | location_t last_init_list_comma; |
4533 | |
4534 | /* Parse a braced initializer list. TYPE is the type specified for a |
4535 | compound literal, and NULL_TREE for other initializers and for |
4536 | nested braced lists. NESTED_P is true for nested braced lists, |
4537 | false for the list of a compound literal or the list that is the |
4538 | top-level initializer in a declaration. */ |
4539 | |
4540 | static struct c_expr |
4541 | c_parser_braced_init (c_parser *parser, tree type, bool nested_p, |
4542 | struct obstack *outer_obstack) |
4543 | { |
4544 | struct c_expr ret; |
4545 | struct obstack braced_init_obstack; |
4546 | location_t brace_loc = c_parser_peek_token (parser)->location; |
4547 | gcc_obstack_init (&braced_init_obstack); |
4548 | gcc_assert (c_parser_next_token_is (parser, CPP_OPEN_BRACE)); |
4549 | matching_braces braces; |
4550 | braces.consume_open (parser); |
4551 | if (nested_p) |
4552 | { |
4553 | finish_implicit_inits (brace_loc, outer_obstack); |
4554 | push_init_level (brace_loc, 0, &braced_init_obstack); |
4555 | } |
4556 | else |
4557 | really_start_incremental_init (type); |
4558 | if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE)) |
4559 | { |
4560 | pedwarn (brace_loc, OPT_Wpedantic, "ISO C forbids empty initializer braces" ); |
4561 | } |
4562 | else |
4563 | { |
4564 | /* Parse a non-empty initializer list, possibly with a trailing |
4565 | comma. */ |
4566 | while (true) |
4567 | { |
4568 | c_parser_initelt (parser, &braced_init_obstack); |
4569 | if (parser->error) |
4570 | break; |
4571 | if (c_parser_next_token_is (parser, CPP_COMMA)) |
4572 | { |
4573 | last_init_list_comma = c_parser_peek_token (parser)->location; |
4574 | c_parser_consume_token (parser); |
4575 | } |
4576 | else |
4577 | break; |
4578 | if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE)) |
4579 | break; |
4580 | } |
4581 | } |
4582 | c_token *next_tok = c_parser_peek_token (parser); |
4583 | if (next_tok->type != CPP_CLOSE_BRACE) |
4584 | { |
4585 | ret.value = error_mark_node; |
4586 | ret.original_code = ERROR_MARK; |
4587 | ret.original_type = NULL; |
4588 | braces.skip_until_found_close (parser); |
4589 | pop_init_level (brace_loc, 0, &braced_init_obstack, last_init_list_comma); |
4590 | obstack_free (&braced_init_obstack, NULL); |
4591 | return ret; |
4592 | } |
4593 | location_t close_loc = next_tok->location; |
4594 | c_parser_consume_token (parser); |
4595 | ret = pop_init_level (brace_loc, 0, &braced_init_obstack, close_loc); |
4596 | obstack_free (&braced_init_obstack, NULL); |
4597 | set_c_expr_source_range (&ret, brace_loc, close_loc); |
4598 | return ret; |
4599 | } |
4600 | |
4601 | /* Parse a nested initializer, including designators. */ |
4602 | |
4603 | static void |
4604 | c_parser_initelt (c_parser *parser, struct obstack * braced_init_obstack) |
4605 | { |
4606 | /* Parse any designator or designator list. A single array |
4607 | designator may have the subsequent "=" omitted in GNU C, but a |
4608 | longer list or a structure member designator may not. */ |
4609 | if (c_parser_next_token_is (parser, CPP_NAME) |
4610 | && c_parser_peek_2nd_token (parser)->type == CPP_COLON) |
4611 | { |
4612 | /* Old-style structure member designator. */ |
4613 | set_init_label (c_parser_peek_token (parser)->location, |
4614 | c_parser_peek_token (parser)->value, |
4615 | c_parser_peek_token (parser)->location, |
4616 | braced_init_obstack); |
4617 | /* Use the colon as the error location. */ |
4618 | pedwarn (c_parser_peek_2nd_token (parser)->location, OPT_Wpedantic, |
4619 | "obsolete use of designated initializer with %<:%>" ); |
4620 | c_parser_consume_token (parser); |
4621 | c_parser_consume_token (parser); |
4622 | } |
4623 | else |
4624 | { |
4625 | /* des_seen is 0 if there have been no designators, 1 if there |
4626 | has been a single array designator and 2 otherwise. */ |
4627 | int des_seen = 0; |
4628 | /* Location of a designator. */ |
4629 | location_t des_loc = UNKNOWN_LOCATION; /* Quiet warning. */ |
4630 | while (c_parser_next_token_is (parser, CPP_OPEN_SQUARE) |
4631 | || c_parser_next_token_is (parser, CPP_DOT)) |
4632 | { |
4633 | int des_prev = des_seen; |
4634 | if (!des_seen) |
4635 | des_loc = c_parser_peek_token (parser)->location; |
4636 | if (des_seen < 2) |
4637 | des_seen++; |
4638 | if (c_parser_next_token_is (parser, CPP_DOT)) |
4639 | { |
4640 | des_seen = 2; |
4641 | c_parser_consume_token (parser); |
4642 | if (c_parser_next_token_is (parser, CPP_NAME)) |
4643 | { |
4644 | set_init_label (des_loc, c_parser_peek_token (parser)->value, |
4645 | c_parser_peek_token (parser)->location, |
4646 | braced_init_obstack); |
4647 | c_parser_consume_token (parser); |
4648 | } |
4649 | else |
4650 | { |
4651 | struct c_expr init; |
4652 | init.value = error_mark_node; |
4653 | init.original_code = ERROR_MARK; |
4654 | init.original_type = NULL; |
4655 | c_parser_error (parser, "expected identifier" ); |
4656 | c_parser_skip_until_found (parser, CPP_COMMA, NULL); |
4657 | process_init_element (input_location, init, false, |
4658 | braced_init_obstack); |
4659 | return; |
4660 | |
---|