1/* Process source files and output type information.
2 Copyright (C) 2006-2017 Free Software Foundation, Inc.
3
4 This file is part of GCC.
5
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
9 version.
10
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
19
20#ifdef HOST_GENERATOR_FILE
21#include "config.h"
22#define GENERATOR_FILE 1
23#else
24#include "bconfig.h"
25#endif
26#include "system.h"
27#include "gengtype.h"
28
29/* This is a simple recursive-descent parser which understands a subset of
30 the C type grammar.
31
32 Rule functions are suffixed _seq if they scan a sequence of items;
33 _opt if they may consume zero tokens; _seqopt if both are true. The
34 "consume_" prefix indicates that a sequence of tokens is parsed for
35 syntactic correctness and then thrown away. */
36
37/* Simple one-token lookahead mechanism. */
38
39struct token
40{
41 const char *value;
42 int code;
43 bool valid;
44};
45static struct token T;
46
47/* Retrieve the code of the current token; if there is no current token,
48 get the next one from the lexer. */
49static inline int
50token (void)
51{
52 if (!T.valid)
53 {
54 T.code = yylex (&T.value);
55 T.valid = true;
56 }
57 return T.code;
58}
59
60/* Retrieve the value of the current token (if any) and mark it consumed.
61 The next call to token() will get another token from the lexer. */
62static inline const char *
63advance (void)
64{
65 T.valid = false;
66 return T.value;
67}
68
69/* Diagnostics. */
70
71/* This array is indexed by the token code minus CHAR_TOKEN_OFFSET. */
72static const char *const token_names[] = {
73 "GTY",
74 "typedef",
75 "extern",
76 "static",
77 "union",
78 "struct",
79 "enum",
80 "...",
81 "ptr_alias",
82 "nested_ptr",
83 "a param<N>_is option",
84 "a number",
85 "a scalar type",
86 "an identifier",
87 "a string constant",
88 "a character constant",
89 "an array declarator",
90 "a C++ keyword to ignore"
91};
92
93/* This array is indexed by token code minus FIRST_TOKEN_WITH_VALUE. */
94static const char *const token_value_format[] = {
95 "%s",
96 "'%s'",
97 "'%s'",
98 "'%s'",
99 "'\"%s\"'",
100 "\"'%s'\"",
101 "'[%s]'",
102 "'%s'",
103};
104
105/* Produce a printable representation for a token defined by CODE and
106 VALUE. This sometimes returns pointers into malloc memory and
107 sometimes not, therefore it is unsafe to free the pointer it
108 returns, so that memory is leaked. This does not matter, as this
109 function is only used for diagnostics, and in a successful run of
110 the program there will be none. */
111static const char *
112print_token (int code, const char *value)
113{
114 if (code < CHAR_TOKEN_OFFSET)
115 return xasprintf ("'%c'", code);
116 else if (code < FIRST_TOKEN_WITH_VALUE)
117 return xasprintf ("'%s'", token_names[code - CHAR_TOKEN_OFFSET]);
118 else if (!value)
119 return token_names[code - CHAR_TOKEN_OFFSET]; /* don't quote these */
120 else
121 return xasprintf (token_value_format[code - FIRST_TOKEN_WITH_VALUE],
122 value);
123}
124
125/* Convenience wrapper around print_token which produces the printable
126 representation of the current token. */
127static inline const char *
128print_cur_token (void)
129{
130 return print_token (T.code, T.value);
131}
132
133/* Report a parse error on the current line, with diagnostic MSG.
134 Behaves as standard printf with respect to additional arguments and
135 format escapes. */
136static void ATTRIBUTE_PRINTF_1
137parse_error (const char *msg, ...)
138{
139 va_list ap;
140
141 fprintf (stderr, "%s:%d: parse error: ",
142 get_input_file_name (lexer_line.file), lexer_line.line);
143
144 va_start (ap, msg);
145 vfprintf (stderr, msg, ap);
146 va_end (ap);
147
148 fputc ('\n', stderr);
149
150 hit_error = true;
151}
152
153/* If the next token does not have code T, report a parse error; otherwise
154 return the token's value. */
155static const char *
156require (int t)
157{
158 int u = token ();
159 const char *v = advance ();
160 if (u != t)
161 {
162 parse_error ("expected %s, have %s",
163 print_token (t, 0), print_token (u, v));
164 return 0;
165 }
166 return v;
167}
168
169/* As per require, but do not advance. */
170static const char *
171require_without_advance (int t)
172{
173 int u = token ();
174 const char *v = T.value;
175 if (u != t)
176 {
177 parse_error ("expected %s, have %s",
178 print_token (t, 0), print_token (u, v));
179 return 0;
180 }
181 return v;
182}
183
184/* If the next token does not have one of the codes T1 or T2, report a
185 parse error; otherwise return the token's value. */
186static const char *
187require2 (int t1, int t2)
188{
189 int u = token ();
190 const char *v = advance ();
191 if (u != t1 && u != t2)
192 {
193 parse_error ("expected %s or %s, have %s",
194 print_token (t1, 0), print_token (t2, 0),
195 print_token (u, v));
196 return 0;
197 }
198 return v;
199}
200
201/* If the next token does not have one of the codes T1, T2, T3 or T4, report a
202 parse error; otherwise return the token's value. */
203static const char *
204require4 (int t1, int t2, int t3, int t4)
205{
206 int u = token ();
207 const char *v = advance ();
208 if (u != t1 && u != t2 && u != t3 && u != t4)
209 {
210 parse_error ("expected %s, %s, %s or %s, have %s",
211 print_token (t1, 0), print_token (t2, 0),
212 print_token (t3, 0), print_token (t4, 0),
213 print_token (u, v));
214 return 0;
215 }
216 return v;
217}
218
219/* Near-terminals. */
220
221/* C-style string constant concatenation: STRING+
222 Bare STRING should appear nowhere else in this file. */
223static const char *
224string_seq (void)
225{
226 const char *s1, *s2;
227 size_t l1, l2;
228 char *buf;
229
230 s1 = require (STRING);
231 if (s1 == 0)
232 return "";
233 while (token () == STRING)
234 {
235 s2 = advance ();
236
237 l1 = strlen (s1);
238 l2 = strlen (s2);
239 buf = XRESIZEVEC (char, CONST_CAST (char *, s1), l1 + l2 + 1);
240 memcpy (buf + l1, s2, l2 + 1);
241 XDELETE (CONST_CAST (char *, s2));
242 s1 = buf;
243 }
244 return s1;
245}
246
247
248/* The caller has detected a template declaration that starts
249 with TMPL_NAME. Parse up to the closing '>'. This recognizes
250 simple template declarations of the form ID<ID1,ID2,...,IDn>,
251 potentially with a single level of indirection e.g.
252 ID<ID1 *, ID2, ID3 *, ..., IDn>.
253 It does not try to parse anything more sophisticated than that.
254
255 Returns the template declaration string "ID<ID1,ID2,...,IDn>". */
256
257static const char *
258require_template_declaration (const char *tmpl_name)
259{
260 char *str;
261 int num_indirections = 0;
262
263 /* Recognize the opening '<'. */
264 require ('<');
265 str = concat (tmpl_name, "<", (char *) 0);
266
267 /* Read the comma-separated list of identifiers. */
268 int depth = 1;
269 while (depth > 0)
270 {
271 if (token () == ENUM)
272 {
273 advance ();
274 str = concat (str, "enum ", (char *) 0);
275 continue;
276 }
277 if (token () == NUM
278 || token () == ':'
279 || token () == '+')
280 {
281 str = concat (str, advance (), (char *) 0);
282 continue;
283 }
284 if (token () == '<')
285 {
286 advance ();
287 str = concat (str, "<", (char *) 0);
288 depth += 1;
289 continue;
290 }
291 if (token () == '>')
292 {
293 advance ();
294 str = concat (str, ">", (char *) 0);
295 depth -= 1;
296 continue;
297 }
298 const char *id = require4 (SCALAR, ID, '*', ',');
299 if (id == NULL)
300 {
301 if (T.code == '*')
302 {
303 id = "*";
304 if (num_indirections++)
305 parse_error ("only one level of indirection is supported"
306 " in template arguments");
307 }
308 else
309 id = ",";
310 }
311 else
312 num_indirections = 0;
313 str = concat (str, id, (char *) 0);
314 }
315 return str;
316}
317
318
319/* typedef_name: either an ID, or a template type
320 specification of the form ID<t1,t2,...,tn>. */
321
322static const char *
323typedef_name (void)
324{
325 const char *id = require (ID);
326 if (token () == '<')
327 return require_template_declaration (id);
328 else
329 return id;
330}
331
332/* Absorb a sequence of tokens delimited by balanced ()[]{}. */
333static void
334consume_balanced (int opener, int closer)
335{
336 require (opener);
337 for (;;)
338 switch (token ())
339 {
340 default:
341 advance ();
342 break;
343 case '(':
344 consume_balanced ('(', ')');
345 break;
346 case '[':
347 consume_balanced ('[', ']');
348 break;
349 case '{':
350 consume_balanced ('{', '}');
351 break;
352
353 case '}':
354 case ']':
355 case ')':
356 if (token () != closer)
357 parse_error ("unbalanced delimiters - expected '%c', have '%c'",
358 closer, token ());
359 advance ();
360 return;
361
362 case EOF_TOKEN:
363 parse_error ("unexpected end of file within %c%c-delimited construct",
364 opener, closer);
365 return;
366 }
367}
368
369/* Absorb a sequence of tokens, possibly including ()[]{}-delimited
370 expressions, until we encounter an end-of-statement marker (a ';' or
371 a '}') outside any such delimiters; absorb that too. */
372
373static void
374consume_until_eos (void)
375{
376 for (;;)
377 switch (token ())
378 {
379 case ';':
380 advance ();
381 return;
382
383 case '{':
384 consume_balanced ('{', '}');
385 return;
386
387 case '(':
388 consume_balanced ('(', ')');
389 break;
390
391 case '[':
392 consume_balanced ('[', ']');
393 break;
394
395 case '}':
396 case ']':
397 case ')':
398 parse_error ("unmatched '%c' while scanning for ';'", token ());
399 return;
400
401 case EOF_TOKEN:
402 parse_error ("unexpected end of file while scanning for ';'");
403 return;
404
405 default:
406 advance ();
407 break;
408 }
409}
410
411/* Absorb a sequence of tokens, possibly including ()[]{}-delimited
412 expressions, until we encounter a comma or semicolon outside any
413 such delimiters; absorb that too. Returns true if the loop ended
414 with a comma. */
415
416static bool
417consume_until_comma_or_eos ()
418{
419 for (;;)
420 switch (token ())
421 {
422 case ',':
423 advance ();
424 return true;
425
426 case ';':
427 advance ();
428 return false;
429
430 case '{':
431 consume_balanced ('{', '}');
432 return false;
433
434 case '(':
435 consume_balanced ('(', ')');
436 break;
437
438 case '[':
439 consume_balanced ('[', ']');
440 break;
441
442 case '}':
443 case ']':
444 case ')':
445 parse_error ("unmatched '%s' while scanning for ',' or ';'",
446 print_cur_token ());
447 return false;
448
449 case EOF_TOKEN:
450 parse_error ("unexpected end of file while scanning for ',' or ';'");
451 return false;
452
453 default:
454 advance ();
455 break;
456 }
457}
458
459
460/* GTY(()) option handling. */
461static type_p type (options_p *optsp, bool nested);
462
463/* Optional parenthesized string: ('(' string_seq ')')? */
464static options_p
465str_optvalue_opt (options_p prev)
466{
467 const char *name = advance ();
468 const char *value = "";
469 if (token () == '(')
470 {
471 advance ();
472 value = string_seq ();
473 require (')');
474 }
475 return create_string_option (prev, name, value);
476}
477
478/* absdecl: type '*'*
479 -- a vague approximation to what the C standard calls an abstract
480 declarator. The only kinds that are actually used are those that
481 are just a bare type and those that have trailing pointer-stars.
482 Further kinds should be implemented if and when they become
483 necessary. Used only within GTY(()) option values, therefore
484 further GTY(()) tags within the type are invalid. Note that the
485 return value has already been run through adjust_field_type. */
486static type_p
487absdecl (void)
488{
489 type_p ty;
490 options_p opts;
491
492 ty = type (&opts, true);
493 while (token () == '*')
494 {
495 ty = create_pointer (ty);
496 advance ();
497 }
498
499 if (opts)
500 parse_error ("nested GTY(()) options are invalid");
501
502 return adjust_field_type (ty, 0);
503}
504
505/* Type-option: '(' absdecl ')' */
506static options_p
507type_optvalue (options_p prev, const char *name)
508{
509 type_p ty;
510 require ('(');
511 ty = absdecl ();
512 require (')');
513 return create_type_option (prev, name, ty);
514}
515
516/* Nested pointer data: '(' type '*'* ',' string_seq ',' string_seq ')' */
517static options_p
518nestedptr_optvalue (options_p prev)
519{
520 type_p ty;
521 const char *from, *to;
522
523 require ('(');
524 ty = absdecl ();
525 require (',');
526 to = string_seq ();
527 require (',');
528 from = string_seq ();
529 require (')');
530
531 return create_nested_ptr_option (prev, ty, to, from);
532}
533
534/* One GTY(()) option:
535 ID str_optvalue_opt
536 | PTR_ALIAS type_optvalue
537 | NESTED_PTR nestedptr_optvalue
538*/
539static options_p
540option (options_p prev)
541{
542 switch (token ())
543 {
544 case ID:
545 return str_optvalue_opt (prev);
546
547 case PTR_ALIAS:
548 advance ();
549 return type_optvalue (prev, "ptr_alias");
550
551 case NESTED_PTR:
552 advance ();
553 return nestedptr_optvalue (prev);
554
555 case USER_GTY:
556 advance ();
557 return create_string_option (prev, "user", "");
558
559 default:
560 parse_error ("expected an option keyword, have %s", print_cur_token ());
561 advance ();
562 return create_string_option (prev, "", "");
563 }
564}
565
566/* One comma-separated list of options. */
567static options_p
568option_seq (void)
569{
570 options_p o;
571
572 o = option (0);
573 while (token () == ',')
574 {
575 advance ();
576 o = option (o);
577 }
578 return o;
579}
580
581/* GTY marker: 'GTY' '(' '(' option_seq? ')' ')' */
582static options_p
583gtymarker (void)
584{
585 options_p result = 0;
586 require (GTY_TOKEN);
587 require ('(');
588 require ('(');
589 if (token () != ')')
590 result = option_seq ();
591 require (')');
592 require (')');
593 return result;
594}
595
596/* Optional GTY marker. */
597static options_p
598gtymarker_opt (void)
599{
600 if (token () != GTY_TOKEN)
601 return 0;
602 return gtymarker ();
603}
604
605
606
607/* Declarators. The logic here is largely lifted from c-parser.c.
608 Note that we do not have to process abstract declarators, which can
609 appear only in parameter type lists or casts (but see absdecl,
610 above). Also, type qualifiers are thrown out in gengtype-lex.l so
611 we don't have to do it. */
612
613/* array_and_function_declarators_opt:
614 \epsilon
615 array_and_function_declarators_opt ARRAY
616 array_and_function_declarators_opt '(' ... ')'
617
618 where '...' indicates stuff we ignore except insofar as grouping
619 symbols ()[]{} must balance.
620
621 Subroutine of direct_declarator - do not use elsewhere. */
622
623static type_p
624array_and_function_declarators_opt (type_p ty)
625{
626 if (token () == ARRAY)
627 {
628 const char *array = advance ();
629 return create_array (array_and_function_declarators_opt (ty), array);
630 }
631 else if (token () == '(')
632 {
633 /* We don't need exact types for functions. */
634 consume_balanced ('(', ')');
635 array_and_function_declarators_opt (ty);
636 return create_scalar_type ("function type");
637 }
638 else
639 return ty;
640}
641
642static type_p inner_declarator (type_p, const char **, options_p *, bool);
643
644/* direct_declarator:
645 '(' inner_declarator ')'
646 '(' \epsilon ')' <-- C++ ctors/dtors
647 gtymarker_opt ID array_and_function_declarators_opt
648
649 Subroutine of declarator, mutually recursive with inner_declarator;
650 do not use elsewhere.
651
652 IN_STRUCT is true if we are called while parsing structures or classes. */
653
654static type_p
655direct_declarator (type_p ty, const char **namep, options_p *optsp,
656 bool in_struct)
657{
658 /* The first token in a direct-declarator must be an ID, a
659 GTY marker, or an open parenthesis. */
660 switch (token ())
661 {
662 case GTY_TOKEN:
663 *optsp = gtymarker ();
664 /* fall through */
665
666 case ID:
667 *namep = require (ID);
668 /* If the next token is '(', we are parsing a function declaration.
669 Functions are ignored by gengtype, so we return NULL. */
670 if (token () == '(')
671 return NULL;
672 break;
673
674 case '(':
675 /* If the declarator starts with a '(', we have three options. We
676 are either parsing 'TYPE (*ID)' (i.e., a function pointer)
677 or 'TYPE(...)'.
678
679 The latter will be a constructor iff we are inside a
680 structure or class. Otherwise, it could be a typedef, but
681 since we explicitly reject typedefs inside structures, we can
682 assume that we found a ctor and return NULL. */
683 advance ();
684 if (in_struct && token () != '*')
685 {
686 /* Found a constructor. Find and consume the closing ')'. */
687 while (token () != ')')
688 advance ();
689 advance ();
690 /* Tell the caller to ignore this. */
691 return NULL;
692 }
693 ty = inner_declarator (ty, namep, optsp, in_struct);
694 require (')');
695 break;
696
697 case IGNORABLE_CXX_KEYWORD:
698 /* Any C++ keyword like 'operator' means that we are not looking
699 at a regular data declarator. */
700 return NULL;
701
702 default:
703 parse_error ("expected '(', ')', 'GTY', or an identifier, have %s",
704 print_cur_token ());
705 /* Do _not_ advance if what we have is a close squiggle brace, as
706 we will get much better error recovery that way. */
707 if (token () != '}')
708 advance ();
709 return 0;
710 }
711 return array_and_function_declarators_opt (ty);
712}
713
714/* The difference between inner_declarator and declarator is in the
715 handling of stars. Consider this declaration:
716
717 char * (*pfc) (void)
718
719 It declares a pointer to a function that takes no arguments and
720 returns a char*. To construct the correct type for this
721 declaration, the star outside the parentheses must be processed
722 _before_ the function type, the star inside the parentheses must
723 be processed _after_ the function type. To accomplish this,
724 declarator() creates pointers before recursing (it is actually
725 coded as a while loop), whereas inner_declarator() recurses before
726 creating pointers. */
727
728/* inner_declarator:
729 '*' inner_declarator
730 direct_declarator
731
732 Mutually recursive subroutine of direct_declarator; do not use
733 elsewhere.
734
735 IN_STRUCT is true if we are called while parsing structures or classes. */
736
737static type_p
738inner_declarator (type_p ty, const char **namep, options_p *optsp,
739 bool in_struct)
740{
741 if (token () == '*')
742 {
743 type_p inner;
744 advance ();
745 inner = inner_declarator (ty, namep, optsp, in_struct);
746 if (inner == 0)
747 return 0;
748 else
749 return create_pointer (ty);
750 }
751 else
752 return direct_declarator (ty, namep, optsp, in_struct);
753}
754
755/* declarator: '*'+ direct_declarator
756
757 This is the sole public interface to this part of the grammar.
758 Arguments are the type known so far, a pointer to where the name
759 may be stored, and a pointer to where GTY options may be stored.
760
761 IN_STRUCT is true when we are called to parse declarators inside
762 a structure or class.
763
764 Returns the final type. */
765
766static type_p
767declarator (type_p ty, const char **namep, options_p *optsp,
768 bool in_struct = false)
769{
770 *namep = 0;
771 *optsp = 0;
772 while (token () == '*')
773 {
774 advance ();
775 ty = create_pointer (ty);
776 }
777 return direct_declarator (ty, namep, optsp, in_struct);
778}
779
780/* Types and declarations. */
781
782/* Structure field(s) declaration:
783 (
784 type bitfield ';'
785 | type declarator bitfield? ( ',' declarator bitfield? )+ ';'
786 )*
787
788 Knows that such declarations must end with a close brace (or,
789 erroneously, at EOF).
790*/
791static pair_p
792struct_field_seq (void)
793{
794 pair_p f = 0;
795 type_p ty, dty;
796 options_p opts, dopts;
797 const char *name;
798 bool another;
799
800 while (token () != '}' && token () != EOF_TOKEN)
801 {
802 ty = type (&opts, true);
803
804 /* Ignore access-control keywords ("public:" etc). */
805 while (!ty && token () == IGNORABLE_CXX_KEYWORD)
806 {
807 const char *keyword = advance ();
808 if (strcmp (keyword, "public:") != 0
809 && strcmp (keyword, "private:") != 0
810 && strcmp (keyword, "protected:") != 0)
811 break;
812 ty = type (&opts, true);
813 }
814
815 if (!ty || token () == ':')
816 {
817 consume_until_eos ();
818 continue;
819 }
820
821 do
822 {
823 dty = declarator (ty, &name, &dopts, true);
824
825 /* There could be any number of weird things after the declarator,
826 notably bitfield declarations and __attribute__s. If this
827 function returns true, the last thing was a comma, so we have
828 more than one declarator paired with the current type. */
829 another = consume_until_comma_or_eos ();
830
831 if (!dty)
832 continue;
833
834 if (opts && dopts)
835 parse_error ("two GTY(()) options for field %s", name);
836 if (opts && !dopts)
837 dopts = opts;
838
839 f = create_field_at (f, dty, name, dopts, &lexer_line);
840 }
841 while (another);
842 }
843 return nreverse_pairs (f);
844}
845
846/* Return true if OPTS contain the option named STR. */
847
848bool
849opts_have (options_p opts, const char *str)
850{
851 for (options_p opt = opts; opt; opt = opt->next)
852 if (strcmp (opt->name, str) == 0)
853 return true;
854 return false;
855}
856
857
858/* This is called type(), but what it parses (sort of) is what C calls
859 declaration-specifiers and specifier-qualifier-list:
860
861 SCALAR
862 | ID // typedef
863 | (STRUCT|UNION) ID? gtymarker? ( '{' gtymarker? struct_field_seq '}' )?
864 | ENUM ID ( '{' ... '}' )?
865
866 Returns a partial type; under some conditions (notably
867 "struct foo GTY((...)) thing;") it may write an options
868 structure to *OPTSP.
869
870 NESTED is true when parsing a declaration already known to have a
871 GTY marker. In these cases, typedef and enum declarations are not
872 allowed because gengtype only understands types at the global
873 scope. */
874
875static type_p
876type (options_p *optsp, bool nested)
877{
878 const char *s;
879 *optsp = 0;
880 switch (token ())
881 {
882 case SCALAR:
883 s = advance ();
884 return create_scalar_type (s);
885
886 case ID:
887 s = typedef_name ();
888 return resolve_typedef (s, &lexer_line);
889
890 case IGNORABLE_CXX_KEYWORD:
891 /* By returning NULL here, we indicate to the caller that they
892 should ignore everything following this keyword up to the
893 next ';' or '}'. */
894 return NULL;
895
896 case STRUCT:
897 case UNION:
898 {
899 type_p base_class = NULL;
900 options_p opts = 0;
901 /* GTY annotations follow attribute syntax
902 GTY_BEFORE_ID is for union/struct declarations
903 GTY_AFTER_ID is for variable declarations. */
904 enum
905 {
906 NO_GTY,
907 GTY_BEFORE_ID,
908 GTY_AFTER_ID
909 } is_gty = NO_GTY;
910 enum typekind kind = (token () == UNION) ? TYPE_UNION : TYPE_STRUCT;
911 advance ();
912
913 /* Top-level structures that are not explicitly tagged GTY(())
914 are treated as mere forward declarations. This is because
915 there are a lot of structures that we don't need to know
916 about, and some of those have C++ and macro constructs that
917 we cannot handle. */
918 if (nested || token () == GTY_TOKEN)
919 {
920 is_gty = GTY_BEFORE_ID;
921 opts = gtymarker_opt ();
922 }
923
924 if (token () == ID)
925 s = advance ();
926 else
927 s = xasprintf ("anonymous:%s:%d",
928 get_input_file_name (lexer_line.file),
929 lexer_line.line);
930
931 /* Unfortunately above GTY_TOKEN check does not capture the
932 typedef struct_type GTY case. */
933 if (token () == GTY_TOKEN)
934 {
935 is_gty = GTY_AFTER_ID;
936 opts = gtymarker_opt ();
937 }
938
939 bool is_user_gty = opts_have (opts, "user");
940
941 if (token () == ':')
942 {
943 if (is_gty && !is_user_gty)
944 {
945 /* For GTY-marked types that are not "user", parse some C++
946 inheritance specifications.
947 We require single-inheritance from a non-template type. */
948 advance ();
949 const char *basename = require (ID);
950 /* This may be either an access specifier, or the base name. */
951 if (0 == strcmp (basename, "public")
952 || 0 == strcmp (basename, "protected")
953 || 0 == strcmp (basename, "private"))
954 basename = require (ID);
955 base_class = find_structure (basename, TYPE_STRUCT);
956 if (!base_class)
957 parse_error ("unrecognized base class: %s", basename);
958 require_without_advance ('{');
959 }
960 else
961 {
962 /* For types lacking GTY-markings, skip over C++ inheritance
963 specification (and thus avoid having to parse e.g. template
964 types). */
965 while (token () != '{')
966 advance ();
967 }
968 }
969
970 if (is_gty)
971 {
972 if (token () == '{')
973 {
974 pair_p fields;
975
976 if (is_gty == GTY_AFTER_ID)
977 parse_error ("GTY must be specified before identifier");
978
979 if (!is_user_gty)
980 {
981 advance ();
982 fields = struct_field_seq ();
983 require ('}');
984 }
985 else
986 {
987 /* Do not look inside user defined structures. */
988 fields = NULL;
989 kind = TYPE_USER_STRUCT;
990 consume_balanced ('{', '}');
991 return create_user_defined_type (s, &lexer_line);
992 }
993
994 return new_structure (s, kind, &lexer_line, fields, opts,
995 base_class);
996 }
997 }
998 else if (token () == '{')
999 consume_balanced ('{', '}');
1000 if (opts)
1001 *optsp = opts;
1002 return find_structure (s, kind);
1003 }
1004
1005 case TYPEDEF:
1006 /* In C++, a typedef inside a struct/class/union defines a new
1007 type for that inner scope. We cannot support this in
1008 gengtype because we have no concept of scoping.
1009
1010 We handle typedefs in the global scope separately (see
1011 parse_file), so if we find a 'typedef', we must be inside
1012 a struct. */
1013 gcc_assert (nested);
1014 parse_error ("typedefs not supported in structures marked with "
1015 "automatic GTY markers. Use GTY((user)) to mark "
1016 "this structure.");
1017 advance ();
1018 return NULL;
1019
1020 case ENUM:
1021 advance ();
1022 if (token () == ID)
1023 s = advance ();
1024 else
1025 s = xasprintf ("anonymous:%s:%d",
1026 get_input_file_name (lexer_line.file),
1027 lexer_line.line);
1028
1029 if (token () == '{')
1030 consume_balanced ('{', '}');
1031
1032 /* If after parsing the enum we are at the end of the statement,
1033 and we are currently inside a structure, then this was an
1034 enum declaration inside this scope.
1035
1036 We cannot support this for the same reason we cannot support
1037 'typedef' inside structures (see the TYPEDEF handler above).
1038 If this happens, emit an error and return NULL. */
1039 if (nested && token () == ';')
1040 {
1041 parse_error ("enum definitions not supported in structures marked "
1042 "with automatic GTY markers. Use GTY((user)) to mark "
1043 "this structure.");
1044 advance ();
1045 return NULL;
1046 }
1047
1048 return create_scalar_type (s);
1049
1050 default:
1051 parse_error ("expected a type specifier, have %s", print_cur_token ());
1052 advance ();
1053 return create_scalar_type ("erroneous type");
1054 }
1055}
1056
1057/* Top level constructs. */
1058
1059/* Dispatch declarations beginning with 'typedef'. */
1060
1061static void
1062typedef_decl (void)
1063{
1064 type_p ty, dty;
1065 const char *name;
1066 options_p opts;
1067 bool another;
1068
1069 gcc_assert (token () == TYPEDEF);
1070 advance ();
1071
1072 ty = type (&opts, false);
1073 if (!ty)
1074 return;
1075 if (opts)
1076 parse_error ("GTY((...)) cannot be applied to a typedef");
1077 do
1078 {
1079 dty = declarator (ty, &name, &opts);
1080 if (opts)
1081 parse_error ("GTY((...)) cannot be applied to a typedef");
1082
1083 /* Yet another place where we could have junk (notably attributes)
1084 after the declarator. */
1085 another = consume_until_comma_or_eos ();
1086 if (dty)
1087 do_typedef (name, dty, &lexer_line);
1088 }
1089 while (another);
1090}
1091
1092/* Structure definition: type() does all the work. */
1093
1094static void
1095struct_or_union (void)
1096{
1097 options_p dummy;
1098 type (&dummy, false);
1099 /* There may be junk after the type: notably, we cannot currently
1100 distinguish 'struct foo *function(prototype);' from 'struct foo;'
1101 ... we could call declarator(), but it's a waste of time at
1102 present. Instead, just eat whatever token is currently lookahead
1103 and go back to lexical skipping mode. */
1104 advance ();
1105}
1106
1107/* GC root declaration:
1108 (extern|static) gtymarker? type ID array_declarators_opt (';'|'=')
1109 If the gtymarker is not present, we ignore the rest of the declaration. */
1110static void
1111extern_or_static (void)
1112{
1113 options_p opts, opts2, dopts;
1114 type_p ty, dty;
1115 const char *name;
1116 require2 (EXTERN, STATIC);
1117
1118 if (token () != GTY_TOKEN)
1119 {
1120 advance ();
1121 return;
1122 }
1123
1124 opts = gtymarker ();
1125 ty = type (&opts2, true); /* if we get here, it's got a GTY(()) */
1126 dty = declarator (ty, &name, &dopts);
1127
1128 if ((opts && dopts) || (opts && opts2) || (opts2 && dopts))
1129 parse_error ("GTY((...)) specified more than once for %s", name);
1130 else if (opts2)
1131 opts = opts2;
1132 else if (dopts)
1133 opts = dopts;
1134
1135 if (dty)
1136 {
1137 note_variable (name, adjust_field_type (dty, opts), opts, &lexer_line);
1138 require2 (';', '=');
1139 }
1140}
1141
1142/* Parse the file FNAME for GC-relevant declarations and definitions.
1143 This is the only entry point to this file. */
1144void
1145parse_file (const char *fname)
1146{
1147 yybegin (fname);
1148 for (;;)
1149 {
1150 switch (token ())
1151 {
1152 case EXTERN:
1153 case STATIC:
1154 extern_or_static ();
1155 break;
1156
1157 case STRUCT:
1158 case UNION:
1159 struct_or_union ();
1160 break;
1161
1162 case TYPEDEF:
1163 typedef_decl ();
1164 break;
1165
1166 case EOF_TOKEN:
1167 goto eof;
1168
1169 default:
1170 parse_error ("unexpected top level token, %s", print_cur_token ());
1171 goto eof;
1172 }
1173 lexer_toplevel_done = 1;
1174 }
1175
1176 eof:
1177 advance ();
1178 yyend ();
1179}
1180