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
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	{
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
326static const char *
327typedef_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 ()[]{}.  */
337static void
338consume_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
377static void
378consume_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
420static bool
421consume_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
463
464/* GTY(()) option handling.  */
465static type_p type (options_p *optsp, bool nested);
466
467/* Optional parenthesized string: ('(' string_seq ')')? */
468static options_p
469str_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.  */
490static type_p
491absdecl (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 ')' */
510static options_p
511type_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 ')' */
521static options_p
522nestedptr_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*/
543static options_p
544option (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.  */
571static options_p
572option_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? ')' ')' */
586static options_p
587gtymarker (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.  */
601static options_p
602gtymarker_opt (void)
603{
604  if (token () != GTY_TOKEN)
605    return 0;
606  return gtymarker ();
607}
608
609
610
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
627static type_p
628array_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
646static 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
658static type_p
659direct_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
741static type_p
742inner_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
770static type_p
771declarator (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
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*/
795static pair_p
796struct_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
852bool
853opts_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
879static type_p
880type (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
1061/* Top level constructs.  */
1062
1063/* Dispatch declarations beginning with 'typedef'.  */
1064
1065static void
1066typedef_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
1098static void
1099struct_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.  */
1114static void
1115extern_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.  */
1148void
1149parse_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}
1184