gcc/gengtype-parse.c

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