gcc/gengtype-parse.c

   1 /* Process source files and output type information.
   2    Copyright (C) 2006, 2007, 2010 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 GENERATOR_FILE
  21 #include "bconfig.h"
  22 #else
  23 #include "config.h"
  24 #endif
  25 #include "system.h"
  26 #include "gengtype.h"
  27
  28 /* This is a simple recursive-descent parser which understands a subset of
  29    the C type grammar.
  30
  31    Rule functions are suffixed _seq if they scan a sequence of items;
  32    _opt if they may consume zero tokens; _seqopt if both are true.  The
  33    "consume_" prefix indicates that a sequence of tokens is parsed for
  34    syntactic correctness and then thrown away.  */
  35
  36 /* Simple one-token lookahead mechanism.  */
  37
  38 struct token
  39 {
  40   const char *value;
  41   int code;
  42   bool valid;
  43 };
  44 static struct token T;
  45
  46 /* Retrieve the code of the current token; if there is no current token,
  47    get the next one from the lexer.  */
  48 static inline int
  49 token (void)
  50 {
  51   if (!T.valid)
  52     {
  53       T.code = yylex (&T.value);
  54       T.valid = true;
  55     }
  56   return T.code;
  57 }
  58
  59 /* Retrieve the value of the current token (if any) and mark it consumed.
  60    The next call to token() will get another token from the lexer.  */
  61 static inline const char *
  62 advance (void)
  63 {
  64   T.valid = false;
  65   return T.value;
  66 }
  67
  68 /* Diagnostics.  */
  69
  70 /* This array is indexed by the token code minus CHAR_TOKEN_OFFSET.  */
  71 static const char *const token_names[] = {
  72   "GTY",
  73   "typedef",
  74   "extern",
  75   "static",
  76   "union",
  77   "struct",
  78   "enum",
  79   "VEC",
  80   "DEF_VEC_[OP]",
  81   "DEF_VEC_I",
  82   "DEF_VEC_ALLOC_[IOP]",
  83   "...",
  84   "ptr_alias",
  85   "nested_ptr",
  86   "a param<N>_is option",
  87   "a number",
  88   "a scalar type",
  89   "an identifier",
  90   "a string constant",
  91   "a character constant",
  92   "an array declarator",
  93 };
  94
  95 /* This array is indexed by token code minus FIRST_TOKEN_WITH_VALUE.  */
  96 static const char *const token_value_format[] = {
  97   "%s",
  98   "'%s'",
  99   "'%s'",
 100   "'%s'",
 101   "'\"%s\"'",
 102   "\"'%s'\"",
 103   "'[%s]'",
 104 };
 105
 106 /* Produce a printable representation for a token defined by CODE and
 107    VALUE.  This sometimes returns pointers into malloc memory and
 108    sometimes not, therefore it is unsafe to free the pointer it
 109    returns, so that memory is leaked.  This does not matter, as this
 110    function is only used for diagnostics, and in a successful run of
 111    the program there will be none.  */
 112 static const char *
 113 print_token (int code, const char *value)
 114 {
 115   if (code < CHAR_TOKEN_OFFSET)
 116     return xasprintf ("'%c'", code);
 117   else if (code < FIRST_TOKEN_WITH_VALUE)
 118     return xasprintf ("'%s'", token_names[code - CHAR_TOKEN_OFFSET]);
 119   else if (!value)
 120     return token_names[code - CHAR_TOKEN_OFFSET];       /* don't quote these */
 121   else
 122     return xasprintf (token_value_format[code - FIRST_TOKEN_WITH_VALUE],
 123                       value);
 124 }
 125
 126 /* Convenience wrapper around print_token which produces the printable
 127    representation of the current token.  */
 128 static inline const char *
 129 print_cur_token (void)
 130 {
 131   return print_token (T.code, T.value);
 132 }
 133
 134 /* Report a parse error on the current line, with diagnostic MSG.
 135    Behaves as standard printf with respect to additional arguments and
 136    format escapes.  */
 137 static void ATTRIBUTE_PRINTF_1
 138 parse_error (const char *msg, ...)
 139 {
 140   va_list ap;
 141
 142   fprintf (stderr, "%s:%d: parse error: ",
 143            get_input_file_name (lexer_line.file), lexer_line.line);
 144
 145   va_start (ap, msg);
 146   vfprintf (stderr, msg, ap);
 147   va_end (ap);
 148
 149   fputc ('\n', stderr);
 150
 151   hit_error = true;
 152 }
 153
 154 /* If the next token does not have code T, report a parse error; otherwise
 155    return the token's value.  */
 156 static const char *
 157 require (int t)
 158 {
 159   int u = token ();
 160   const char *v = advance ();
 161   if (u != t)
 162     {
 163       parse_error ("expected %s, have %s",
 164                    print_token (t, 0), print_token (u, v));
 165       return 0;
 166     }
 167   return v;
 168 }
 169
 170 /* If the next token does not have one of the codes T1 or T2, report a
 171    parse error; otherwise return the token's value.  */
 172 static const char *
 173 require2 (int t1, int t2)
 174 {
 175   int u = token ();
 176   const char *v = advance ();
 177   if (u != t1 && u != t2)
 178     {
 179       parse_error ("expected %s or %s, have %s",
 180                    print_token (t1, 0), print_token (t2, 0),
 181                    print_token (u, v));
 182       return 0;
 183     }
 184   return v;
 185 }
 186
 187 /* Near-terminals.  */
 188
 189 /* C-style string constant concatenation: STRING+
 190    Bare STRING should appear nowhere else in this file.  */
 191 static const char *
 192 string_seq (void)
 193 {
 194   const char *s1, *s2;
 195   size_t l1, l2;
 196   char *buf;
 197
 198   s1 = require (STRING);
 199   if (s1 == 0)
 200     return "";
 201   while (token () == STRING)
 202     {
 203       s2 = advance ();
 204
 205       l1 = strlen (s1);
 206       l2 = strlen (s2);
 207       buf = XRESIZEVEC (char, CONST_CAST (char *, s1), l1 + l2 + 1);
 208       memcpy (buf + l1, s2, l2 + 1);
 209       XDELETE (CONST_CAST (char *, s2));
 210       s1 = buf;
 211     }
 212   return s1;
 213 }
 214
 215 /* typedef_name: either an ID, or VEC(x,y) which is translated to VEC_x_y.
 216    Use only where VEC(x,y) is legitimate, i.e. in positions where a
 217    typedef name may appear.  */
 218 static const char *
 219 typedef_name (void)
 220 {
 221   if (token () == VEC_TOKEN)
 222     {
 223       const char *c1, *c2, *r;
 224       advance ();
 225       require ('(');
 226       c1 = require2 (ID, SCALAR);
 227       require (',');
 228       c2 = require (ID);
 229       require (')');
 230       r = concat ("VEC_", c1, "_", c2, (char *) 0);
 231       free (CONST_CAST (char *, c1));
 232       free (CONST_CAST (char *, c2));
 233       return r;
 234     }
 235   else
 236     return require (ID);
 237 }
 238
 239 /* Absorb a sequence of tokens delimited by balanced ()[]{}.  */
 240 static void
 241 consume_balanced (int opener, int closer)
 242 {
 243   require (opener);
 244   for (;;)
 245     switch (token ())
 246       {
 247       default:
 248         advance ();
 249         break;
 250       case '(':
 251         consume_balanced ('(', ')');
 252         break;
 253       case '[':
 254         consume_balanced ('[', ']');
 255         break;
 256       case '{':
 257         consume_balanced ('{', '}');
 258         break;
 259
 260       case '}':
 261       case ']':
 262       case ')':
 263         if (token () != closer)
 264           parse_error ("unbalanced delimiters - expected '%c', have '%c'",
 265                        closer, token ());
 266       advance ();
 267       return;
 268
 269       case EOF_TOKEN:
 270         parse_error ("unexpected end of file within %c%c-delimited construct",
 271                      opener, closer);
 272         return;
 273       }
 274 }
 275
 276 /* Absorb a sequence of tokens, possibly including ()[]{}-delimited
 277    expressions, until we encounter a semicolon outside any such
 278    delimiters; absorb that too.  If IMMEDIATE is true, it is an error
 279    if the semicolon is not the first token encountered.  */
 280 static void
 281 consume_until_semi (bool immediate)
 282 {
 283   if (immediate && token () != ';')
 284     require (';');
 285   for (;;)
 286     switch (token ())
 287       {
 288       case ';':
 289         advance ();
 290         return;
 291       default:
 292         advance ();
 293         break;
 294
 295       case '(':
 296         consume_balanced ('(', ')');
 297         break;
 298       case '[':
 299         consume_balanced ('[', ']');
 300         break;
 301       case '{':
 302         consume_balanced ('{', '}');
 303         break;
 304
 305       case '}':
 306       case ']':
 307       case ')':
 308         parse_error ("unmatched '%c' while scanning for ';'", token ());
 309       return;
 310
 311       case EOF_TOKEN:
 312         parse_error ("unexpected end of file while scanning for ';'");
 313         return;
 314       }
 315 }
 316
 317 /* Absorb a sequence of tokens, possibly including ()[]{}-delimited
 318    expressions, until we encounter a comma or semicolon outside any
 319    such delimiters; absorb that too.  If IMMEDIATE is true, it is an
 320    error if the comma or semicolon is not the first token encountered.
 321    Returns true if the loop ended with a comma.  */
 322 static bool
 323 consume_until_comma_or_semi (bool immediate)
 324 {
 325   if (immediate && token () != ',' && token () != ';')
 326     require2 (',', ';');
 327   for (;;)
 328     switch (token ())
 329       {
 330       case ',':
 331         advance ();
 332         return true;
 333       case ';':
 334         advance ();
 335         return false;
 336       default:
 337         advance ();
 338         break;
 339
 340       case '(':
 341         consume_balanced ('(', ')');
 342         break;
 343       case '[':
 344         consume_balanced ('[', ']');
 345         break;
 346       case '{':
 347         consume_balanced ('{', '}');
 348         break;
 349
 350       case '}':
 351       case ']':
 352       case ')':
 353         parse_error ("unmatched '%s' while scanning for ',' or ';'",
 354                      print_cur_token ());
 355       return false;
 356
 357       case EOF_TOKEN:
 358         parse_error ("unexpected end of file while scanning for ',' or ';'");
 359         return false;
 360       }
 361 }
 362 \f
 363
 364 /* GTY(()) option handling.  */
 365 static type_p type (options_p *optsp, bool nested);
 366
 367 /* Optional parenthesized string: ('(' string_seq ')')? */
 368 static options_p
 369 str_optvalue_opt (options_p prev)
 370 {
 371   const char *name = advance ();
 372   const char *value = "";
 373   if (token () == '(')
 374     {
 375       advance ();
 376       value = string_seq ();
 377       require (')');
 378     }
 379   return create_string_option (prev, name, value);
 380 }
 381
 382 /* absdecl: type '*'*
 383    -- a vague approximation to what the C standard calls an abstract
 384    declarator.  The only kinds that are actually used are those that
 385    are just a bare type and those that have trailing pointer-stars.
 386    Further kinds should be implemented if and when they become
 387    necessary.  Used only within GTY(()) option values, therefore
 388    further GTY(()) tags within the type are invalid.  Note that the
 389    return value has already been run through adjust_field_type.  */
 390 static type_p
 391 absdecl (void)
 392 {
 393   type_p ty;
 394   options_p opts;
 395
 396   ty = type (&opts, true);
 397   while (token () == '*')
 398     {
 399       ty = create_pointer (ty);
 400       advance ();
 401     }
 402
 403   if (opts)
 404     parse_error ("nested GTY(()) options are invalid");
 405
 406   return adjust_field_type (ty, 0);
 407 }
 408
 409 /* Type-option: '(' absdecl ')' */
 410 static options_p
 411 type_optvalue (options_p prev, const char *name)
 412 {
 413   type_p ty;
 414   require ('(');
 415   ty = absdecl ();
 416   require (')');
 417   return create_type_option (prev, name, ty);
 418 }
 419
 420 /* Nested pointer data: '(' type '*'* ',' string_seq ',' string_seq ')' */
 421 static options_p
 422 nestedptr_optvalue (options_p prev)
 423 {
 424   type_p ty;
 425   const char *from, *to;
 426
 427   require ('(');
 428   ty = absdecl ();
 429   require (',');
 430   to = string_seq ();
 431   require (',');
 432   from = string_seq ();
 433   require (')');
 434
 435   return create_nested_ptr_option (prev, ty, to, from);
 436 }
 437
 438 /* One GTY(()) option:
 439    ID str_optvalue_opt
 440    | PTR_ALIAS type_optvalue
 441    | PARAM_IS type_optvalue
 442    | NESTED_PTR nestedptr_optvalue
 443 */
 444 static options_p
 445 option (options_p prev)
 446 {
 447   switch (token ())
 448     {
 449     case ID:
 450       return str_optvalue_opt (prev);
 451
 452     case PTR_ALIAS:
 453       advance ();
 454       return type_optvalue (prev, "ptr_alias");
 455
 456     case PARAM_IS:
 457       return type_optvalue (prev, advance ());
 458
 459     case NESTED_PTR:
 460       advance ();
 461       return nestedptr_optvalue (prev);
 462
 463     default:
 464       parse_error ("expected an option keyword, have %s", print_cur_token ());
 465       advance ();
 466       return create_string_option (prev, "", "");
 467     }
 468 }
 469
 470 /* One comma-separated list of options.  */
 471 static options_p
 472 option_seq (void)
 473 {
 474   options_p o;
 475
 476   o = option (0);
 477   while (token () == ',')
 478     {
 479       advance ();
 480       o = option (o);
 481     }
 482   return o;
 483 }
 484
 485 /* GTY marker: 'GTY' '(' '(' option_seq? ')' ')' */
 486 static options_p
 487 gtymarker (void)
 488 {
 489   options_p result = 0;
 490   require (GTY_TOKEN);
 491   require ('(');
 492   require ('(');
 493   if (token () != ')')
 494     result = option_seq ();
 495   require (')');
 496   require (')');
 497   return result;
 498 }
 499
 500 /* Optional GTY marker.  */
 501 static options_p
 502 gtymarker_opt (void)
 503 {
 504   if (token () != GTY_TOKEN)
 505     return 0;
 506   return gtymarker ();
 507 }
 508 \f
 509 /* Declarators. The logic here is largely lifted from c-parser.c.
 510    Note that we do not have to process abstract declarators, which can
 511    appear only in parameter type lists or casts (but see absdecl,
 512    above).  Also, type qualifiers are thrown out in gengtype-lex.l so
 513    we don't have to do it.  */
 514
 515 /* array_and_function_declarators_opt:
 516    \epsilon
 517    array_and_function_declarators_opt ARRAY
 518    array_and_function_declarators_opt '(' ... ')'
 519
 520    where '...' indicates stuff we ignore except insofar as grouping
 521    symbols ()[]{} must balance.
 522
 523    Subroutine of direct_declarator - do not use elsewhere. */
 524
 525 static type_p
 526 array_and_function_declarators_opt (type_p ty)
 527 {
 528   if (token () == ARRAY)
 529     {
 530       const char *array = advance ();
 531       return create_array (array_and_function_declarators_opt (ty), array);
 532     }
 533   else if (token () == '(')
 534     {
 535       /* We don't need exact types for functions.  */
 536       consume_balanced ('(', ')');
 537       array_and_function_declarators_opt (ty);
 538       return create_scalar_type ("function type");
 539     }
 540   else
 541     return ty;
 542 }
 543
 544 static type_p inner_declarator (type_p, const char **, options_p *);
 545
 546 /* direct_declarator:
 547    '(' inner_declarator ')'
 548    gtymarker_opt ID array_and_function_declarators_opt
 549
 550    Subroutine of declarator, mutually recursive with inner_declarator;
 551    do not use elsewhere.  */
 552 static type_p
 553 direct_declarator (type_p ty, const char **namep, options_p *optsp)
 554 {
 555   /* The first token in a direct-declarator must be an ID, a
 556      GTY marker, or an open parenthesis.  */
 557   switch (token ())
 558     {
 559     case GTY_TOKEN:
 560       *optsp = gtymarker ();
 561       /* fall through */
 562     case ID:
 563       *namep = require (ID);
 564       break;
 565
 566     case '(':
 567       advance ();
 568       ty = inner_declarator (ty, namep, optsp);
 569       require (')');
 570       break;
 571
 572     default:
 573       parse_error ("expected '(', 'GTY', or an identifier, have %s",
 574                    print_cur_token ());
 575       /* Do _not_ advance if what we have is a close squiggle brace, as
 576          we will get much better error recovery that way.  */
 577       if (token () != '}')
 578         advance ();
 579       return 0;
 580     }
 581   return array_and_function_declarators_opt (ty);
 582 }
 583
 584 /* The difference between inner_declarator and declarator is in the
 585    handling of stars.  Consider this declaration:
 586
 587    char * (*pfc) (void)
 588
 589    It declares a pointer to a function that takes no arguments and
 590    returns a char*.  To construct the correct type for this
 591    declaration, the star outside the parentheses must be processed
 592    _before_ the function type, the star inside the parentheses must
 593    be processed _after_ the function type.  To accomplish this,
 594    declarator() creates pointers before recursing (it is actually
 595    coded as a while loop), whereas inner_declarator() recurses before
 596    creating pointers.  */
 597
 598 /* inner_declarator:
 599    '*' inner_declarator
 600    direct_declarator
 601
 602    Mutually recursive subroutine of direct_declarator; do not use
 603    elsewhere.  */
 604
 605 static type_p
 606 inner_declarator (type_p ty, const char **namep, options_p *optsp)
 607 {
 608   if (token () == '*')
 609     {
 610       type_p inner;
 611       advance ();
 612       inner = inner_declarator (ty, namep, optsp);
 613       if (inner == 0)
 614         return 0;
 615       else
 616         return create_pointer (ty);
 617     }
 618   else
 619     return direct_declarator (ty, namep, optsp);
 620 }
 621
 622 /* declarator: '*'+ direct_declarator
 623
 624    This is the sole public interface to this part of the grammar.
 625    Arguments are the type known so far, a pointer to where the name
 626    may be stored, and a pointer to where GTY options may be stored.
 627    Returns the final type. */
 628
 629 static type_p
 630 declarator (type_p ty, const char **namep, options_p *optsp)
 631 {
 632   *namep = 0;
 633   *optsp = 0;
 634   while (token () == '*')
 635     {
 636       advance ();
 637       ty = create_pointer (ty);
 638     }
 639   return direct_declarator (ty, namep, optsp);
 640 }
 641 \f
 642 /* Types and declarations.  */
 643
 644 /* Structure field(s) declaration:
 645    (
 646    type bitfield ';'
 647    | type declarator bitfield? ( ',' declarator bitfield? )+ ';'
 648    )+
 649
 650    Knows that such declarations must end with a close brace (or,
 651    erroneously, at EOF).
 652 */
 653 static pair_p
 654 struct_field_seq (void)
 655 {
 656   pair_p f = 0;
 657   type_p ty, dty;
 658   options_p opts, dopts;
 659   const char *name;
 660   bool another;
 661
 662   do
 663     {
 664       ty = type (&opts, true);
 665       /* Another piece of the IFCVT_EXTRA_FIELDS special case, see type().  */
 666       if (!ty && token () == '}')
 667         break;
 668
 669       if (!ty || token () == ':')
 670         {
 671           consume_until_semi (false);
 672           continue;
 673         }
 674
 675       do
 676         {
 677           dty = declarator (ty, &name, &dopts);
 678           /* There could be any number of weird things after the declarator,
 679              notably bitfield declarations and __attribute__s.  If this
 680              function returns true, the last thing was a comma, so we have
 681              more than one declarator paired with the current type.  */
 682           another = consume_until_comma_or_semi (false);
 683
 684           if (!dty)
 685             continue;
 686
 687           if (opts && dopts)
 688             parse_error ("two GTY(()) options for field %s", name);
 689           if (opts && !dopts)
 690             dopts = opts;
 691
 692           f = create_field_at (f, dty, name, dopts, &lexer_line);
 693         }
 694       while (another);
 695     }
 696   while (token () != '}' && token () != EOF_TOKEN);
 697   return nreverse_pairs (f);
 698 }
 699
 700 /* This is called type(), but what it parses (sort of) is what C calls
 701    declaration-specifiers and specifier-qualifier-list:
 702
 703    SCALAR
 704    | ID     // typedef
 705    | (STRUCT|UNION) ID? gtymarker? ( '{' gtymarker? struct_field_seq '}' )?
 706    | ENUM ID ( '{' ... '}' )?
 707
 708    Returns a partial type; under some conditions (notably
 709    "struct foo GTY((...)) thing;") it may write an options
 710    structure to *OPTSP.
 711 */
 712 static type_p
 713 type (options_p *optsp, bool nested)
 714 {
 715   const char *s;
 716   *optsp = 0;
 717   switch (token ())
 718     {
 719     case SCALAR:
 720       s = advance ();
 721       return create_scalar_type (s);
 722
 723     case ID:
 724     case VEC_TOKEN:
 725       s = typedef_name ();
 726       return resolve_typedef (s, &lexer_line);
 727
 728     case STRUCT:
 729     case UNION:
 730       {
 731         options_p opts = 0;
 732         /* GTY annotations follow attribute syntax
 733            GTY_BEFORE_ID is for union/struct declarations
 734            GTY_AFTER_ID is for variable declarations.  */
 735         enum
 736         {
 737           NO_GTY,
 738           GTY_BEFORE_ID,
 739           GTY_AFTER_ID
 740         } is_gty = NO_GTY;
 741         bool is_union = (token () == UNION);
 742         advance ();
 743
 744         /* Top-level structures that are not explicitly tagged GTY(())
 745            are treated as mere forward declarations.  This is because
 746            there are a lot of structures that we don't need to know
 747            about, and some of those have weird macro stuff in them
 748            that we can't handle.  */
 749         if (nested || token () == GTY_TOKEN)
 750           {
 751             is_gty = GTY_BEFORE_ID;
 752             opts = gtymarker_opt ();
 753           }
 754
 755         if (token () == ID)
 756           s = advance ();
 757         else
 758           s = xasprintf ("anonymous:%s:%d",
 759                          get_input_file_name (lexer_line.file),
 760                          lexer_line.line);
 761
 762         /* Unfortunately above GTY_TOKEN check does not capture the
 763            typedef struct_type GTY case.  */
 764         if (token () == GTY_TOKEN)
 765           {
 766             is_gty = GTY_AFTER_ID;
 767             opts = gtymarker_opt ();
 768           }
 769
 770         if (is_gty)
 771           {
 772             if (token () == '{')
 773               {
 774                 pair_p fields;
 775
 776                 if (is_gty == GTY_AFTER_ID)
 777                   parse_error ("GTY must be specified before identifier");
 778
 779                 advance ();
 780                 fields = struct_field_seq ();
 781                 require ('}');
 782                 return new_structure (s, is_union, &lexer_line, fields, opts);
 783               }
 784           }
 785         else if (token () == '{')
 786           consume_balanced ('{', '}');
 787         if (opts)
 788           *optsp = opts;
 789         return find_structure (s, is_union);
 790       }
 791
 792     case ENUM:
 793       advance ();
 794       if (token () == ID)
 795         s = advance ();
 796       else
 797         s = xasprintf ("anonymous:%s:%d",
 798                        get_input_file_name (lexer_line.file),
 799                        lexer_line.line);
 800
 801       if (token () == '{')
 802         consume_balanced ('{', '}');
 803       return create_scalar_type (s);
 804
 805     default:
 806       parse_error ("expected a type specifier, have %s", print_cur_token ());
 807       advance ();
 808       return create_scalar_type ("erroneous type");
 809     }
 810 }
 811 \f
 812 /* Top level constructs.  */
 813
 814 /* Dispatch declarations beginning with 'typedef'.  */
 815
 816 static void
 817 typedef_decl (void)
 818 {
 819   type_p ty, dty;
 820   const char *name;
 821   options_p opts;
 822   bool another;
 823
 824   gcc_assert (token () == TYPEDEF);
 825   advance ();
 826
 827   ty = type (&opts, false);
 828   if (!ty)
 829     return;
 830   if (opts)
 831     parse_error ("GTY((...)) cannot be applied to a typedef");
 832   do
 833     {
 834       dty = declarator (ty, &name, &opts);
 835       if (opts)
 836         parse_error ("GTY((...)) cannot be applied to a typedef");
 837
 838       /* Yet another place where we could have junk (notably attributes)
 839          after the declarator.  */
 840       another = consume_until_comma_or_semi (false);
 841       if (dty)
 842         do_typedef (name, dty, &lexer_line);
 843     }
 844   while (another);
 845 }
 846
 847 /* Structure definition: type() does all the work.  */
 848
 849 static void
 850 struct_or_union (void)
 851 {
 852   options_p dummy;
 853   type (&dummy, false);
 854   /* There may be junk after the type: notably, we cannot currently
 855      distinguish 'struct foo *function(prototype);' from 'struct foo;'
 856      ...  we could call declarator(), but it's a waste of time at
 857      present.  Instead, just eat whatever token is currently lookahead
 858      and go back to lexical skipping mode. */
 859   advance ();
 860 }
 861
 862 /* GC root declaration:
 863    (extern|static) gtymarker? type ID array_declarators_opt (';'|'=')
 864    If the gtymarker is not present, we ignore the rest of the declaration.  */
 865 static void
 866 extern_or_static (void)
 867 {
 868   options_p opts, opts2, dopts;
 869   type_p ty, dty;
 870   const char *name;
 871   require2 (EXTERN, STATIC);
 872
 873   if (token () != GTY_TOKEN)
 874     {
 875       advance ();
 876       return;
 877     }
 878
 879   opts = gtymarker ();
 880   ty = type (&opts2, true);     /* if we get here, it's got a GTY(()) */
 881   dty = declarator (ty, &name, &dopts);
 882
 883   if ((opts && dopts) || (opts && opts2) || (opts2 && dopts))
 884     parse_error ("GTY((...)) specified more than once for %s", name);
 885   else if (opts2)
 886     opts = opts2;
 887   else if (dopts)
 888     opts = dopts;
 889
 890   if (dty)
 891     {
 892       note_variable (name, adjust_field_type (dty, opts), opts, &lexer_line);
 893       require2 (';', '=');
 894     }
 895 }
 896
 897 /* Definition of a generic VEC structure:
 898
 899    'DEF_VEC_[IPO]' '(' id ')' ';'
 900
 901    Scalar VECs require slightly different treatment than otherwise -
 902    that's handled in note_def_vec, we just pass it along.*/
 903 static void
 904 def_vec (void)
 905 {
 906   bool is_scalar = (token () == DEFVEC_I);
 907   const char *type;
 908
 909   require2 (DEFVEC_OP, DEFVEC_I);
 910   require ('(');
 911   type = require2 (ID, SCALAR);
 912   require (')');
 913   require (';');
 914
 915   if (!type)
 916     return;
 917
 918   note_def_vec (type, is_scalar, &lexer_line);
 919   note_def_vec_alloc (type, "none", &lexer_line);
 920 }
 921
 922 /* Definition of an allocation strategy for a VEC structure:
 923
 924    'DEF_VEC_ALLOC_[IPO]' '(' id ',' id ')' ';'
 925
 926    For purposes of gengtype, this just declares a wrapper structure.  */
 927 static void
 928 def_vec_alloc (void)
 929 {
 930   const char *type, *astrat;
 931
 932   require (DEFVEC_ALLOC);
 933   require ('(');
 934   type = require2 (ID, SCALAR);
 935   require (',');
 936   astrat = require (ID);
 937   require (')');
 938   require (';');
 939
 940   if (!type || !astrat)
 941     return;
 942
 943   note_def_vec_alloc (type, astrat, &lexer_line);
 944 }
 945
 946 /* Parse the file FNAME for GC-relevant declarations and definitions.
 947    This is the only entry point to this file.  */
 948 void
 949 parse_file (const char *fname)
 950 {
 951   yybegin (fname);
 952   for (;;)
 953     {
 954       switch (token ())
 955         {
 956         case EXTERN:
 957         case STATIC:
 958           extern_or_static ();
 959           break;
 960
 961         case STRUCT:
 962         case UNION:
 963           struct_or_union ();
 964           break;
 965
 966         case TYPEDEF:
 967           typedef_decl ();
 968           break;
 969
 970         case DEFVEC_OP:
 971         case DEFVEC_I:
 972           def_vec ();
 973           break;
 974
 975         case DEFVEC_ALLOC:
 976           def_vec_alloc ();
 977           break;
 978
 979         case EOF_TOKEN:
 980           goto eof;
 981
 982         default:
 983           parse_error ("unexpected top level token, %s", print_cur_token ());
 984           goto eof;
 985         }
 986       lexer_toplevel_done = 1;
 987     }
 988
 989  eof:
 990   advance ();
 991   yyend ();
 992 }