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