OSDN Git Service

2009-04-24 Ed Schonberg <schonberg@adacore.com>
[pf3gnuchains/gcc-fork.git] / 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   *optsp = 0;
681   switch (token ())
682     {
683     case SCALAR:
684       s = advance ();
685       return create_scalar_type (s);
686
687     case ID:
688     case VEC_TOKEN:
689       s = typedef_name ();
690       return resolve_typedef (s, &lexer_line);
691
692     case STRUCT:
693     case UNION:
694       {
695         options_p opts = 0;
696     /* GTY annotations follow attribute syntax 
697        GTY_BEFORE_ID is for union/struct declarations
698        GTY_AFTER_ID is for variable declarations.  */
699     enum {
700         NO_GTY,
701         GTY_BEFORE_ID,
702         GTY_AFTER_ID
703     } is_gty = NO_GTY;
704     bool is_union = (token () == UNION);
705         advance ();
706
707         /* Top-level structures that are not explicitly tagged GTY(())
708            are treated as mere forward declarations.  This is because
709            there are a lot of structures that we don't need to know
710            about, and some of those have weird macro stuff in them
711            that we can't handle.  */
712         if (nested || token () == GTY_TOKEN)
713           {
714         is_gty = GTY_BEFORE_ID;
715         opts = gtymarker_opt ();
716           }
717
718         if (token () == ID)
719           s = advance ();
720         else
721           s = xasprintf ("anonymous:%s:%d", lexer_line.file, lexer_line.line);
722
723         /* Unfortunately above GTY_TOKEN check does not capture the
724            typedef struct_type GTY case.  */
725         if (token () == GTY_TOKEN)
726           {
727         is_gty = GTY_AFTER_ID;
728         opts = gtymarker_opt ();
729           }
730         
731     if (is_gty) 
732       {
733         if (token () == '{')
734           {
735             pair_p fields;
736
737             if (is_gty == GTY_AFTER_ID) 
738                 parse_error ("GTY must be specified before identifier");
739               
740             advance ();
741             fields = struct_field_seq ();
742             require ('}');
743             return new_structure (s, is_union, &lexer_line, fields, opts);
744           }
745       } 
746     else if (token () == '{')
747       consume_balanced ('{', '}');
748         if (opts)
749           *optsp = opts;
750         return find_structure (s, is_union);
751       }
752
753     case ENUM:
754       advance ();
755         if (token () == ID)
756           s = advance ();
757         else
758           s = xasprintf ("anonymous:%s:%d", lexer_line.file, lexer_line.line);
759
760       if (token () == '{')
761         consume_balanced ('{','}');
762       return create_scalar_type (s);
763
764     default:
765       parse_error ("expected a type specifier, have %s", print_cur_token ());
766       advance ();
767       return create_scalar_type ("erroneous type");
768     }
769 }
770 \f
771 /* Top level constructs.  */
772
773 /* Dispatch declarations beginning with 'typedef'.  */
774
775 static void
776 typedef_decl (void)
777 {
778   type_p ty, dty;
779   const char *name;
780   options_p opts;
781   bool another;
782
783   gcc_assert (token () == TYPEDEF);
784   advance ();
785
786   ty = type (&opts, false);
787   if (!ty)
788     return;
789   if (opts)
790     parse_error ("GTY((...)) cannot be applied to a typedef");
791   do
792     {
793       dty = declarator (ty, &name, &opts);
794       if (opts)
795         parse_error ("GTY((...)) cannot be applied to a typedef");
796
797       /* Yet another place where we could have junk (notably attributes)
798          after the declarator.  */
799       another = consume_until_comma_or_semi (false);
800       if (dty)
801         do_typedef (name, dty, &lexer_line);
802     }
803   while (another);
804 }
805
806 /* Structure definition: type() does all the work.  */
807
808 static void
809 struct_or_union (void)
810 {
811   options_p dummy;
812   type (&dummy, false);
813   /* There may be junk after the type: notably, we cannot currently
814      distinguish 'struct foo *function(prototype);' from 'struct foo;'
815      ...  we could call declarator(), but it's a waste of time at
816      present.  Instead, just eat whatever token is currently lookahead
817      and go back to lexical skipping mode. */
818   advance ();
819 }
820
821 /* GC root declaration:
822      (extern|static) gtymarker? type ID array_declarators_opt (';'|'=')
823    If the gtymarker is not present, we ignore the rest of the declaration.  */
824 static void
825 extern_or_static (void)
826 {
827   options_p opts, opts2, dopts;
828   type_p ty, dty;
829   const char *name;
830   require2 (EXTERN, STATIC);
831
832   if (token () != GTY_TOKEN)
833     {
834       advance ();
835       return;
836     }
837
838   opts = gtymarker ();
839   ty   = type (&opts2, true);  /* if we get here, it's got a GTY(()) */
840   dty  = declarator (ty, &name, &dopts);
841
842   if ((opts && dopts) || (opts && opts2) || (opts2 && dopts))
843     parse_error ("GTY((...)) specified more than once for %s", name);
844   else if (opts2)
845     opts = opts2;
846   else if (dopts)
847     opts = dopts;
848
849   if (dty)
850     {
851       note_variable (name, adjust_field_type (dty, opts), opts, &lexer_line);
852       require2 (';', '=');
853     }
854 }
855
856 /* Definition of a generic VEC structure:
857
858    'DEF_VEC_[IPO]' '(' id ')' ';'
859
860    Scalar VECs require slightly different treatment than otherwise -
861    that's handled in note_def_vec, we just pass it along.*/
862 static void
863 def_vec (void)
864 {
865   bool is_scalar = (token() == DEFVEC_I);
866   const char *type;
867
868   require2 (DEFVEC_OP, DEFVEC_I);
869   require ('(');
870   type = require2 (ID, SCALAR);
871   require (')');
872   require (';');
873
874   if (!type)
875     return;
876
877   note_def_vec (type, is_scalar, &lexer_line);
878   note_def_vec_alloc (type, "none", &lexer_line);
879 }
880
881 /* Definition of an allocation strategy for a VEC structure:
882
883    'DEF_VEC_ALLOC_[IPO]' '(' id ',' id ')' ';'
884
885    For purposes of gengtype, this just declares a wrapper structure.  */
886 static void
887 def_vec_alloc (void)
888 {
889   const char *type, *astrat;
890
891   require (DEFVEC_ALLOC);
892   require ('(');
893   type = require2 (ID, SCALAR);
894   require (',');
895   astrat = require (ID);
896   require (')');
897   require (';');
898
899   if (!type || !astrat)
900     return;
901
902   note_def_vec_alloc (type, astrat, &lexer_line);
903 }
904
905 /* Parse the file FNAME for GC-relevant declarations and definitions.
906    This is the only entry point to this file.  */
907 void
908 parse_file (const char *fname)
909 {
910   yybegin (fname);
911   for (;;)
912     {
913       switch (token ())
914         {
915         case EXTERN:
916         case STATIC:
917           extern_or_static ();
918           break;
919
920         case STRUCT:
921         case UNION:
922           struct_or_union ();
923           break;
924
925         case TYPEDEF:
926           typedef_decl ();
927           break;
928
929         case DEFVEC_OP:
930         case DEFVEC_I:
931           def_vec ();
932           break;
933
934         case DEFVEC_ALLOC:
935           def_vec_alloc ();
936           break;
937
938         case EOF_TOKEN:
939           goto eof;
940
941         default:
942           parse_error ("unexpected top level token, %s", print_cur_token ());
943           goto eof;
944         }
945       lexer_toplevel_done = 1;
946     }
947
948  eof:
949   advance ();
950   yyend ();
951 }