Merge branch 'vendor/GCC50' - gcc 5.0 snapshot 1 FEB 2015
[dragonfly.git] / contrib / gcc-5.0 / gcc / gengtype-parse.c
1 /* Process source files and output type information.
2    Copyright (C) 2006-2015 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
39 struct token
40 {
41   const char *value;
42   int code;
43   bool valid;
44 };
45 static 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.  */
49 static inline int
50 token (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.  */
62 static inline const char *
63 advance (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.  */
72 static 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.  */
94 static 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.  */
111 static const char *
112 print_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.  */
127 static inline const char *
128 print_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.  */
136 static void ATTRIBUTE_PRINTF_1
137 parse_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.  */
155 static const char *
156 require (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.  */
170 static const char *
171 require_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.  */
186 static const char *
187 require2 (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.  */
203 static const char *
204 require4 (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.  */
223 static const char *
224 string_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
257 static const char *
258 require_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         {
279           str = concat (str, advance (), (char *) 0);
280           continue;
281         }
282       if (token () == ':')
283         {
284           advance ();
285           str = concat (str, ":", (char *) 0);
286           continue;
287         }
288       if (token () == '<')
289         {
290           advance ();
291           str = concat (str, "<", (char *) 0);
292           depth += 1;
293           continue;
294         }
295       if (token () == '>')
296         {
297           advance ();
298           str = concat (str, ">", (char *) 0);
299           depth -= 1;
300           continue;
301         }
302       const char *id = require4 (SCALAR, ID, '*', ',');
303       if (id == NULL)
304         {
305           if (T.code == '*')
306             {
307               id = "*";
308               if (num_indirections++)
309                 parse_error ("only one level of indirection is supported"
310                              " in template arguments");
311             }
312           else
313             id = ",";
314         }
315       else
316         num_indirections = 0;
317       str = concat (str, id, (char *) 0);
318     }
319   return str;
320 }
321
322
323 /* typedef_name: either an ID, or a template type
324    specification of the form ID<t1,t2,...,tn>.  */
325
326 static const char *
327 typedef_name (void)
328 {
329   const char *id = require (ID);
330   if (token () == '<')
331     return require_template_declaration (id);
332   else
333     return id;
334 }
335
336 /* Absorb a sequence of tokens delimited by balanced ()[]{}.  */
337 static void
338 consume_balanced (int opener, int closer)
339 {
340   require (opener);
341   for (;;)
342     switch (token ())
343       {
344       default:
345         advance ();
346         break;
347       case '(':
348         consume_balanced ('(', ')');
349         break;
350       case '[':
351         consume_balanced ('[', ']');
352         break;
353       case '{':
354         consume_balanced ('{', '}');
355         break;
356
357       case '}':
358       case ']':
359       case ')':
360         if (token () != closer)
361           parse_error ("unbalanced delimiters - expected '%c', have '%c'",
362                        closer, token ());
363       advance ();
364       return;
365
366       case EOF_TOKEN:
367         parse_error ("unexpected end of file within %c%c-delimited construct",
368                      opener, closer);
369         return;
370       }
371 }
372
373 /* Absorb a sequence of tokens, possibly including ()[]{}-delimited
374    expressions, until we encounter an end-of-statement marker (a ';' or
375    a '}') outside any such delimiters; absorb that too.  */
376
377 static void
378 consume_until_eos (void)
379 {
380   for (;;)
381     switch (token ())
382       {
383       case ';':
384         advance ();
385         return;
386
387       case '{':
388         consume_balanced ('{', '}');
389         return;
390
391       case '(':
392         consume_balanced ('(', ')');
393         break;
394
395       case '[':
396         consume_balanced ('[', ']');
397         break;
398
399       case '}':
400       case ']':
401       case ')':
402         parse_error ("unmatched '%c' while scanning for ';'", token ());
403         return;
404
405       case EOF_TOKEN:
406         parse_error ("unexpected end of file while scanning for ';'");
407         return;
408
409       default:
410         advance ();
411         break;
412       }
413 }
414
415 /* Absorb a sequence of tokens, possibly including ()[]{}-delimited
416    expressions, until we encounter a comma or semicolon outside any
417    such delimiters; absorb that too.  Returns true if the loop ended
418    with a comma.  */
419
420 static bool
421 consume_until_comma_or_eos ()
422 {
423   for (;;)
424     switch (token ())
425       {
426       case ',':
427         advance ();
428         return true;
429
430       case ';':
431         advance ();
432         return false;
433
434       case '{':
435         consume_balanced ('{', '}');
436         return false;
437
438       case '(':
439         consume_balanced ('(', ')');
440         break;
441
442       case '[':
443         consume_balanced ('[', ']');
444         break;
445
446       case '}':
447       case ']':
448       case ')':
449         parse_error ("unmatched '%s' while scanning for ',' or ';'",
450                      print_cur_token ());
451       return false;
452
453       case EOF_TOKEN:
454         parse_error ("unexpected end of file while scanning for ',' or ';'");
455         return false;
456
457       default:
458         advance ();
459         break;
460       }
461 }
462 \f
463
464 /* GTY(()) option handling.  */
465 static type_p type (options_p *optsp, bool nested);
466
467 /* Optional parenthesized string: ('(' string_seq ')')? */
468 static options_p
469 str_optvalue_opt (options_p prev)
470 {
471   const char *name = advance ();
472   const char *value = "";
473   if (token () == '(')
474     {
475       advance ();
476       value = string_seq ();
477       require (')');
478     }
479   return create_string_option (prev, name, value);
480 }
481
482 /* absdecl: type '*'*
483    -- a vague approximation to what the C standard calls an abstract
484    declarator.  The only kinds that are actually used are those that
485    are just a bare type and those that have trailing pointer-stars.
486    Further kinds should be implemented if and when they become
487    necessary.  Used only within GTY(()) option values, therefore
488    further GTY(()) tags within the type are invalid.  Note that the
489    return value has already been run through adjust_field_type.  */
490 static type_p
491 absdecl (void)
492 {
493   type_p ty;
494   options_p opts;
495
496   ty = type (&opts, true);
497   while (token () == '*')
498     {
499       ty = create_pointer (ty);
500       advance ();
501     }
502
503   if (opts)
504     parse_error ("nested GTY(()) options are invalid");
505
506   return adjust_field_type (ty, 0);
507 }
508
509 /* Type-option: '(' absdecl ')' */
510 static options_p
511 type_optvalue (options_p prev, const char *name)
512 {
513   type_p ty;
514   require ('(');
515   ty = absdecl ();
516   require (')');
517   return create_type_option (prev, name, ty);
518 }
519
520 /* Nested pointer data: '(' type '*'* ',' string_seq ',' string_seq ')' */
521 static options_p
522 nestedptr_optvalue (options_p prev)
523 {
524   type_p ty;
525   const char *from, *to;
526
527   require ('(');
528   ty = absdecl ();
529   require (',');
530   to = string_seq ();
531   require (',');
532   from = string_seq ();
533   require (')');
534
535   return create_nested_ptr_option (prev, ty, to, from);
536 }
537
538 /* One GTY(()) option:
539    ID str_optvalue_opt
540    | PTR_ALIAS type_optvalue
541    | NESTED_PTR nestedptr_optvalue
542 */
543 static options_p
544 option (options_p prev)
545 {
546   switch (token ())
547     {
548     case ID:
549       return str_optvalue_opt (prev);
550
551     case PTR_ALIAS:
552       advance ();
553       return type_optvalue (prev, "ptr_alias");
554
555     case NESTED_PTR:
556       advance ();
557       return nestedptr_optvalue (prev);
558
559     case USER_GTY:
560       advance ();
561       return create_string_option (prev, "user", "");
562
563     default:
564       parse_error ("expected an option keyword, have %s", print_cur_token ());
565       advance ();
566       return create_string_option (prev, "", "");
567     }
568 }
569
570 /* One comma-separated list of options.  */
571 static options_p
572 option_seq (void)
573 {
574   options_p o;
575
576   o = option (0);
577   while (token () == ',')
578     {
579       advance ();
580       o = option (o);
581     }
582   return o;
583 }
584
585 /* GTY marker: 'GTY' '(' '(' option_seq? ')' ')' */
586 static options_p
587 gtymarker (void)
588 {
589   options_p result = 0;
590   require (GTY_TOKEN);
591   require ('(');
592   require ('(');
593   if (token () != ')')
594     result = option_seq ();
595   require (')');
596   require (')');
597   return result;
598 }
599
600 /* Optional GTY marker.  */
601 static options_p
602 gtymarker_opt (void)
603 {
604   if (token () != GTY_TOKEN)
605     return 0;
606   return gtymarker ();
607 }
608
609
610 \f
611 /* Declarators. The logic here is largely lifted from c-parser.c.
612    Note that we do not have to process abstract declarators, which can
613    appear only in parameter type lists or casts (but see absdecl,
614    above).  Also, type qualifiers are thrown out in gengtype-lex.l so
615    we don't have to do it.  */
616
617 /* array_and_function_declarators_opt:
618    \epsilon
619    array_and_function_declarators_opt ARRAY
620    array_and_function_declarators_opt '(' ... ')'
621
622    where '...' indicates stuff we ignore except insofar as grouping
623    symbols ()[]{} must balance.
624
625    Subroutine of direct_declarator - do not use elsewhere. */
626
627 static type_p
628 array_and_function_declarators_opt (type_p ty)
629 {
630   if (token () == ARRAY)
631     {
632       const char *array = advance ();
633       return create_array (array_and_function_declarators_opt (ty), array);
634     }
635   else if (token () == '(')
636     {
637       /* We don't need exact types for functions.  */
638       consume_balanced ('(', ')');
639       array_and_function_declarators_opt (ty);
640       return create_scalar_type ("function type");
641     }
642   else
643     return ty;
644 }
645
646 static type_p inner_declarator (type_p, const char **, options_p *, bool);
647
648 /* direct_declarator:
649    '(' inner_declarator ')'
650    '(' \epsilon ')'     <-- C++ ctors/dtors
651    gtymarker_opt ID array_and_function_declarators_opt
652
653    Subroutine of declarator, mutually recursive with inner_declarator;
654    do not use elsewhere.
655
656    IN_STRUCT is true if we are called while parsing structures or classes.  */
657
658 static type_p
659 direct_declarator (type_p ty, const char **namep, options_p *optsp,
660                    bool in_struct)
661 {
662   /* The first token in a direct-declarator must be an ID, a
663      GTY marker, or an open parenthesis.  */
664   switch (token ())
665     {
666     case GTY_TOKEN:
667       *optsp = gtymarker ();
668       /* fall through */
669
670     case ID:
671       *namep = require (ID);
672       /* If the next token is '(', we are parsing a function declaration.
673          Functions are ignored by gengtype, so we return NULL.  */
674       if (token () == '(')
675         return NULL;
676       break;
677
678     case '(':
679       /* If the declarator starts with a '(', we have three options.  We
680          are either parsing 'TYPE (*ID)' (i.e., a function pointer)
681          or 'TYPE(...)'.
682
683          The latter will be a constructor iff we are inside a
684          structure or class.  Otherwise, it could be a typedef, but
685          since we explicitly reject typedefs inside structures, we can
686          assume that we found a ctor and return NULL.  */
687       advance ();
688       if (in_struct && token () != '*')
689         {
690           /* Found a constructor.  Find and consume the closing ')'.  */
691           while (token () != ')')
692             advance ();
693           advance ();
694           /* Tell the caller to ignore this.  */
695           return NULL;
696         }
697       ty = inner_declarator (ty, namep, optsp, in_struct);
698       require (')');
699       break;
700
701     case IGNORABLE_CXX_KEYWORD:
702       /* Any C++ keyword like 'operator' means that we are not looking
703          at a regular data declarator.  */
704       return NULL;
705
706     default:
707       parse_error ("expected '(', ')', 'GTY', or an identifier, have %s",
708                    print_cur_token ());
709       /* Do _not_ advance if what we have is a close squiggle brace, as
710          we will get much better error recovery that way.  */
711       if (token () != '}')
712         advance ();
713       return 0;
714     }
715   return array_and_function_declarators_opt (ty);
716 }
717
718 /* The difference between inner_declarator and declarator is in the
719    handling of stars.  Consider this declaration:
720
721    char * (*pfc) (void)
722
723    It declares a pointer to a function that takes no arguments and
724    returns a char*.  To construct the correct type for this
725    declaration, the star outside the parentheses must be processed
726    _before_ the function type, the star inside the parentheses must
727    be processed _after_ the function type.  To accomplish this,
728    declarator() creates pointers before recursing (it is actually
729    coded as a while loop), whereas inner_declarator() recurses before
730    creating pointers.  */
731
732 /* inner_declarator:
733    '*' inner_declarator
734    direct_declarator
735
736    Mutually recursive subroutine of direct_declarator; do not use
737    elsewhere.
738
739    IN_STRUCT is true if we are called while parsing structures or classes.  */
740
741 static type_p
742 inner_declarator (type_p ty, const char **namep, options_p *optsp,
743                   bool in_struct)
744 {
745   if (token () == '*')
746     {
747       type_p inner;
748       advance ();
749       inner = inner_declarator (ty, namep, optsp, in_struct);
750       if (inner == 0)
751         return 0;
752       else
753         return create_pointer (ty);
754     }
755   else
756     return direct_declarator (ty, namep, optsp, in_struct);
757 }
758
759 /* declarator: '*'+ direct_declarator
760
761    This is the sole public interface to this part of the grammar.
762    Arguments are the type known so far, a pointer to where the name
763    may be stored, and a pointer to where GTY options may be stored.
764
765    IN_STRUCT is true when we are called to parse declarators inside
766    a structure or class.
767
768    Returns the final type.  */
769
770 static type_p
771 declarator (type_p ty, const char **namep, options_p *optsp,
772             bool in_struct = false)
773 {
774   *namep = 0;
775   *optsp = 0;
776   while (token () == '*')
777     {
778       advance ();
779       ty = create_pointer (ty);
780     }
781   return direct_declarator (ty, namep, optsp, in_struct);
782 }
783 \f
784 /* Types and declarations.  */
785
786 /* Structure field(s) declaration:
787    (
788    type bitfield ';'
789    | type declarator bitfield? ( ',' declarator bitfield? )+ ';'
790    )*
791
792    Knows that such declarations must end with a close brace (or,
793    erroneously, at EOF).
794 */
795 static pair_p
796 struct_field_seq (void)
797 {
798   pair_p f = 0;
799   type_p ty, dty;
800   options_p opts, dopts;
801   const char *name;
802   bool another;
803
804   while (token () != '}' && token () != EOF_TOKEN)
805     {
806       ty = type (&opts, true);
807
808       /* Ignore access-control keywords ("public:" etc).  */
809       while (!ty && token () == IGNORABLE_CXX_KEYWORD)
810         {
811           const char *keyword = advance ();
812           if (strcmp (keyword, "public:") != 0
813               && strcmp (keyword, "private:") != 0
814               && strcmp (keyword, "protected:") != 0)
815             break;
816           ty = type (&opts, true);
817         }
818
819       if (!ty || token () == ':')
820         {
821           consume_until_eos ();
822           continue;
823         }
824
825       do
826         {
827           dty = declarator (ty, &name, &dopts, true);
828
829           /* There could be any number of weird things after the declarator,
830              notably bitfield declarations and __attribute__s.  If this
831              function returns true, the last thing was a comma, so we have
832              more than one declarator paired with the current type.  */
833           another = consume_until_comma_or_eos ();
834
835           if (!dty)
836             continue;
837
838           if (opts && dopts)
839             parse_error ("two GTY(()) options for field %s", name);
840           if (opts && !dopts)
841             dopts = opts;
842
843           f = create_field_at (f, dty, name, dopts, &lexer_line);
844         }
845       while (another);
846     }
847   return nreverse_pairs (f);
848 }
849
850 /* Return true if OPTS contain the option named STR.  */
851
852 bool
853 opts_have (options_p opts, const char *str)
854 {
855   for (options_p opt = opts; opt; opt = opt->next)
856     if (strcmp (opt->name, str) == 0)
857       return true;
858   return false;
859 }
860
861
862 /* This is called type(), but what it parses (sort of) is what C calls
863    declaration-specifiers and specifier-qualifier-list:
864
865    SCALAR
866    | ID     // typedef
867    | (STRUCT|UNION) ID? gtymarker? ( '{' gtymarker? struct_field_seq '}' )?
868    | ENUM ID ( '{' ... '}' )?
869
870    Returns a partial type; under some conditions (notably
871    "struct foo GTY((...)) thing;") it may write an options
872    structure to *OPTSP.
873
874    NESTED is true when parsing a declaration already known to have a
875    GTY marker. In these cases, typedef and enum declarations are not
876    allowed because gengtype only understands types at the global
877    scope.  */
878
879 static type_p
880 type (options_p *optsp, bool nested)
881 {
882   const char *s;
883   *optsp = 0;
884   switch (token ())
885     {
886     case SCALAR:
887       s = advance ();
888       return create_scalar_type (s);
889
890     case ID:
891       s = typedef_name ();
892       return resolve_typedef (s, &lexer_line);
893
894     case IGNORABLE_CXX_KEYWORD:
895       /* By returning NULL here, we indicate to the caller that they
896          should ignore everything following this keyword up to the
897          next ';' or '}'.  */
898       return NULL;
899
900     case STRUCT:
901     case UNION:
902       {
903         type_p base_class = NULL;
904         options_p opts = 0;
905         /* GTY annotations follow attribute syntax
906            GTY_BEFORE_ID is for union/struct declarations
907            GTY_AFTER_ID is for variable declarations.  */
908         enum
909         {
910           NO_GTY,
911           GTY_BEFORE_ID,
912           GTY_AFTER_ID
913         } is_gty = NO_GTY;
914         enum typekind kind = (token () == UNION) ? TYPE_UNION : TYPE_STRUCT;
915         advance ();
916
917         /* Top-level structures that are not explicitly tagged GTY(())
918            are treated as mere forward declarations.  This is because
919            there are a lot of structures that we don't need to know
920            about, and some of those have C++ and macro constructs that
921            we cannot handle.  */
922         if (nested || token () == GTY_TOKEN)
923           {
924             is_gty = GTY_BEFORE_ID;
925             opts = gtymarker_opt ();
926           }
927
928         if (token () == ID)
929           s = advance ();
930         else
931           s = xasprintf ("anonymous:%s:%d",
932                          get_input_file_name (lexer_line.file),
933                          lexer_line.line);
934
935         /* Unfortunately above GTY_TOKEN check does not capture the
936            typedef struct_type GTY case.  */
937         if (token () == GTY_TOKEN)
938           {
939             is_gty = GTY_AFTER_ID;
940             opts = gtymarker_opt ();
941           }
942
943         bool is_user_gty = opts_have (opts, "user");
944
945         if (token () == ':')
946           {
947             if (is_gty && !is_user_gty)
948               {
949                 /* For GTY-marked types that are not "user", parse some C++
950                    inheritance specifications.
951                    We require single-inheritance from a non-template type.  */
952                 advance ();
953                 const char *basename = require (ID);
954                 /* This may be either an access specifier, or the base name.  */
955                 if (0 == strcmp (basename, "public")
956                     || 0 == strcmp (basename, "protected")
957                     || 0 == strcmp (basename, "private"))
958                   basename = require (ID);
959                 base_class = find_structure (basename, TYPE_STRUCT);
960                 if (!base_class)
961                   parse_error ("unrecognized base class: %s", basename);
962                 require_without_advance ('{');
963               }
964             else
965               {
966                 /* For types lacking GTY-markings, skip over C++ inheritance
967                    specification (and thus avoid having to parse e.g. template
968                    types).  */
969                 while (token () != '{')
970                   advance ();
971               }
972           }
973
974         if (is_gty)
975           {
976             if (token () == '{')
977               {
978                 pair_p fields;
979
980                 if (is_gty == GTY_AFTER_ID)
981                   parse_error ("GTY must be specified before identifier");
982
983                 if (!is_user_gty)
984                   {
985                     advance ();
986                     fields = struct_field_seq ();
987                     require ('}');
988                   }
989                 else
990                   {
991                     /* Do not look inside user defined structures.  */
992                     fields = NULL;
993                     kind = TYPE_USER_STRUCT;
994                     consume_balanced ('{', '}');
995                     return create_user_defined_type (s, &lexer_line);
996                   }
997
998                 return new_structure (s, kind, &lexer_line, fields, opts,
999                                       base_class);
1000               }
1001           }
1002         else if (token () == '{')
1003           consume_balanced ('{', '}');
1004         if (opts)
1005           *optsp = opts;
1006         return find_structure (s, kind);
1007       }
1008
1009     case TYPEDEF:
1010       /* In C++, a typedef inside a struct/class/union defines a new
1011          type for that inner scope.  We cannot support this in
1012          gengtype because we have no concept of scoping.
1013
1014          We handle typedefs in the global scope separately (see
1015          parse_file), so if we find a 'typedef', we must be inside
1016          a struct.  */
1017       gcc_assert (nested);
1018       parse_error ("typedefs not supported in structures marked with "
1019                    "automatic GTY markers.  Use GTY((user)) to mark "
1020                    "this structure.");
1021       advance ();
1022       return NULL;
1023
1024     case ENUM:
1025       advance ();
1026       if (token () == ID)
1027         s = advance ();
1028       else
1029         s = xasprintf ("anonymous:%s:%d",
1030                        get_input_file_name (lexer_line.file),
1031                        lexer_line.line);
1032
1033       if (token () == '{')
1034         consume_balanced ('{', '}');
1035
1036       /* If after parsing the enum we are at the end of the statement,
1037          and we are currently inside a structure, then this was an
1038          enum declaration inside this scope.
1039
1040          We cannot support this for the same reason we cannot support
1041          'typedef' inside structures (see the TYPEDEF handler above).
1042          If this happens, emit an error and return NULL.  */
1043       if (nested && token () == ';')
1044         {
1045           parse_error ("enum definitions not supported in structures marked "
1046                        "with automatic GTY markers.  Use GTY((user)) to mark "
1047                        "this structure.");
1048           advance ();
1049           return NULL;
1050         }
1051
1052       return create_scalar_type (s);
1053
1054     default:
1055       parse_error ("expected a type specifier, have %s", print_cur_token ());
1056       advance ();
1057       return create_scalar_type ("erroneous type");
1058     }
1059 }
1060 \f
1061 /* Top level constructs.  */
1062
1063 /* Dispatch declarations beginning with 'typedef'.  */
1064
1065 static void
1066 typedef_decl (void)
1067 {
1068   type_p ty, dty;
1069   const char *name;
1070   options_p opts;
1071   bool another;
1072
1073   gcc_assert (token () == TYPEDEF);
1074   advance ();
1075
1076   ty = type (&opts, false);
1077   if (!ty)
1078     return;
1079   if (opts)
1080     parse_error ("GTY((...)) cannot be applied to a typedef");
1081   do
1082     {
1083       dty = declarator (ty, &name, &opts);
1084       if (opts)
1085         parse_error ("GTY((...)) cannot be applied to a typedef");
1086
1087       /* Yet another place where we could have junk (notably attributes)
1088          after the declarator.  */
1089       another = consume_until_comma_or_eos ();
1090       if (dty)
1091         do_typedef (name, dty, &lexer_line);
1092     }
1093   while (another);
1094 }
1095
1096 /* Structure definition: type() does all the work.  */
1097
1098 static void
1099 struct_or_union (void)
1100 {
1101   options_p dummy;
1102   type (&dummy, false);
1103   /* There may be junk after the type: notably, we cannot currently
1104      distinguish 'struct foo *function(prototype);' from 'struct foo;'
1105      ...  we could call declarator(), but it's a waste of time at
1106      present.  Instead, just eat whatever token is currently lookahead
1107      and go back to lexical skipping mode. */
1108   advance ();
1109 }
1110
1111 /* GC root declaration:
1112    (extern|static) gtymarker? type ID array_declarators_opt (';'|'=')
1113    If the gtymarker is not present, we ignore the rest of the declaration.  */
1114 static void
1115 extern_or_static (void)
1116 {
1117   options_p opts, opts2, dopts;
1118   type_p ty, dty;
1119   const char *name;
1120   require2 (EXTERN, STATIC);
1121
1122   if (token () != GTY_TOKEN)
1123     {
1124       advance ();
1125       return;
1126     }
1127
1128   opts = gtymarker ();
1129   ty = type (&opts2, true);     /* if we get here, it's got a GTY(()) */
1130   dty = declarator (ty, &name, &dopts);
1131
1132   if ((opts && dopts) || (opts && opts2) || (opts2 && dopts))
1133     parse_error ("GTY((...)) specified more than once for %s", name);
1134   else if (opts2)
1135     opts = opts2;
1136   else if (dopts)
1137     opts = dopts;
1138
1139   if (dty)
1140     {
1141       note_variable (name, adjust_field_type (dty, opts), opts, &lexer_line);
1142       require2 (';', '=');
1143     }
1144 }
1145
1146 /* Parse the file FNAME for GC-relevant declarations and definitions.
1147    This is the only entry point to this file.  */
1148 void
1149 parse_file (const char *fname)
1150 {
1151   yybegin (fname);
1152   for (;;)
1153     {
1154       switch (token ())
1155         {
1156         case EXTERN:
1157         case STATIC:
1158           extern_or_static ();
1159           break;
1160
1161         case STRUCT:
1162         case UNION:
1163           struct_or_union ();
1164           break;
1165
1166         case TYPEDEF:
1167           typedef_decl ();
1168           break;
1169
1170         case EOF_TOKEN:
1171           goto eof;
1172
1173         default:
1174           parse_error ("unexpected top level token, %s", print_cur_token ());
1175           goto eof;
1176         }
1177       lexer_toplevel_done = 1;
1178     }
1179
1180  eof:
1181   advance ();
1182   yyend ();
1183 }