1 /* Process source files and output type information. 2 Copyright (C) 2006-2018 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 39 struct token 40 { 41 const char *value; 42 int code; 43 bool valid; 44 }; 45 static 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. */ 49 static inline int 50 token (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. */ 62 static inline const char * 63 advance (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. */ 72 static 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. */ 94 static 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. */ 111 static const char * 112 print_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. */ 127 static inline const char * 128 print_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. */ 136 static void ATTRIBUTE_PRINTF_1 137 parse_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. */ 155 static const char * 156 require (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. */ 170 static const char * 171 require_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. */ 186 static const char * 187 require2 (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. */ 203 static const char * 204 require4 (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. */ 223 static const char * 224 string_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 257 static const char * 258 require_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 || token () == ':' 279 || token () == '+') 280 { 281 str = concat (str, advance (), (char *) 0); 282 continue; 283 } 284 if (token () == '<') 285 { 286 advance (); 287 str = concat (str, "<", (char *) 0); 288 depth += 1; 289 continue; 290 } 291 if (token () == '>') 292 { 293 advance (); 294 str = concat (str, ">", (char *) 0); 295 depth -= 1; 296 continue; 297 } 298 const char *id = require4 (SCALAR, ID, '*', ','); 299 if (id == NULL) 300 { 301 if (T.code == '*') 302 { 303 id = "*"; 304 if (num_indirections++) 305 parse_error ("only one level of indirection is supported" 306 " in template arguments"); 307 } 308 else 309 id = ","; 310 } 311 else 312 num_indirections = 0; 313 str = concat (str, id, (char *) 0); 314 } 315 return str; 316 } 317 318 319 /* typedef_name: either an ID, or a template type 320 specification of the form ID<t1,t2,...,tn>. */ 321 322 static const char * 323 typedef_name (void) 324 { 325 const char *id = require (ID); 326 if (token () == '<') 327 return require_template_declaration (id); 328 else 329 return id; 330 } 331 332 /* Absorb a sequence of tokens delimited by balanced ()[]{}. */ 333 static void 334 consume_balanced (int opener, int closer) 335 { 336 require (opener); 337 for (;;) 338 switch (token ()) 339 { 340 default: 341 advance (); 342 break; 343 case '(': 344 consume_balanced ('(', ')'); 345 break; 346 case '[': 347 consume_balanced ('[', ']'); 348 break; 349 case '{': 350 consume_balanced ('{', '}'); 351 break; 352 353 case '}': 354 case ']': 355 case ')': 356 if (token () != closer) 357 parse_error ("unbalanced delimiters - expected '%c', have '%c'", 358 closer, token ()); 359 advance (); 360 return; 361 362 case EOF_TOKEN: 363 parse_error ("unexpected end of file within %c%c-delimited construct", 364 opener, closer); 365 return; 366 } 367 } 368 369 /* Absorb a sequence of tokens, possibly including ()[]{}-delimited 370 expressions, until we encounter an end-of-statement marker (a ';' or 371 a '}') outside any such delimiters; absorb that too. */ 372 373 static void 374 consume_until_eos (void) 375 { 376 for (;;) 377 switch (token ()) 378 { 379 case ';': 380 advance (); 381 return; 382 383 case '{': 384 consume_balanced ('{', '}'); 385 return; 386 387 case '(': 388 consume_balanced ('(', ')'); 389 break; 390 391 case '[': 392 consume_balanced ('[', ']'); 393 break; 394 395 case '}': 396 case ']': 397 case ')': 398 parse_error ("unmatched '%c' while scanning for ';'", token ()); 399 return; 400 401 case EOF_TOKEN: 402 parse_error ("unexpected end of file while scanning for ';'"); 403 return; 404 405 default: 406 advance (); 407 break; 408 } 409 } 410 411 /* Absorb a sequence of tokens, possibly including ()[]{}-delimited 412 expressions, until we encounter a comma or semicolon outside any 413 such delimiters; absorb that too. Returns true if the loop ended 414 with a comma. */ 415 416 static bool 417 consume_until_comma_or_eos () 418 { 419 for (;;) 420 switch (token ()) 421 { 422 case ',': 423 advance (); 424 return true; 425 426 case ';': 427 advance (); 428 return false; 429 430 case '{': 431 consume_balanced ('{', '}'); 432 return false; 433 434 case '(': 435 consume_balanced ('(', ')'); 436 break; 437 438 case '[': 439 consume_balanced ('[', ']'); 440 break; 441 442 case '}': 443 case ']': 444 case ')': 445 parse_error ("unmatched '%s' while scanning for ',' or ';'", 446 print_cur_token ()); 447 return false; 448 449 case EOF_TOKEN: 450 parse_error ("unexpected end of file while scanning for ',' or ';'"); 451 return false; 452 453 default: 454 advance (); 455 break; 456 } 457 } 458 459 460 /* GTY(()) option handling. */ 461 static type_p type (options_p *optsp, bool nested); 462 463 /* Optional parenthesized string: ('(' string_seq ')')? */ 464 static options_p 465 str_optvalue_opt (options_p prev) 466 { 467 const char *name = advance (); 468 const char *value = ""; 469 if (token () == '(') 470 { 471 advance (); 472 value = string_seq (); 473 require (')'); 474 } 475 return create_string_option (prev, name, value); 476 } 477 478 /* absdecl: type '*'* 479 -- a vague approximation to what the C standard calls an abstract 480 declarator. The only kinds that are actually used are those that 481 are just a bare type and those that have trailing pointer-stars. 482 Further kinds should be implemented if and when they become 483 necessary. Used only within GTY(()) option values, therefore 484 further GTY(()) tags within the type are invalid. Note that the 485 return value has already been run through adjust_field_type. */ 486 static type_p 487 absdecl (void) 488 { 489 type_p ty; 490 options_p opts; 491 492 ty = type (&opts, true); 493 while (token () == '*') 494 { 495 ty = create_pointer (ty); 496 advance (); 497 } 498 499 if (opts) 500 parse_error ("nested GTY(()) options are invalid"); 501 502 return adjust_field_type (ty, 0); 503 } 504 505 /* Type-option: '(' absdecl ')' */ 506 static options_p 507 type_optvalue (options_p prev, const char *name) 508 { 509 type_p ty; 510 require ('('); 511 ty = absdecl (); 512 require (')'); 513 return create_type_option (prev, name, ty); 514 } 515 516 /* Nested pointer data: '(' type '*'* ',' string_seq ',' string_seq ')' */ 517 static options_p 518 nestedptr_optvalue (options_p prev) 519 { 520 type_p ty; 521 const char *from, *to; 522 523 require ('('); 524 ty = absdecl (); 525 require (','); 526 to = string_seq (); 527 require (','); 528 from = string_seq (); 529 require (')'); 530 531 return create_nested_ptr_option (prev, ty, to, from); 532 } 533 534 /* One GTY(()) option: 535 ID str_optvalue_opt 536 | PTR_ALIAS type_optvalue 537 | NESTED_PTR nestedptr_optvalue 538 */ 539 static options_p 540 option (options_p prev) 541 { 542 switch (token ()) 543 { 544 case ID: 545 return str_optvalue_opt (prev); 546 547 case PTR_ALIAS: 548 advance (); 549 return type_optvalue (prev, "ptr_alias"); 550 551 case NESTED_PTR: 552 advance (); 553 return nestedptr_optvalue (prev); 554 555 case USER_GTY: 556 advance (); 557 return create_string_option (prev, "user", ""); 558 559 default: 560 parse_error ("expected an option keyword, have %s", print_cur_token ()); 561 advance (); 562 return create_string_option (prev, "", ""); 563 } 564 } 565 566 /* One comma-separated list of options. */ 567 static options_p 568 option_seq (void) 569 { 570 options_p o; 571 572 o = option (0); 573 while (token () == ',') 574 { 575 advance (); 576 o = option (o); 577 } 578 return o; 579 } 580 581 /* GTY marker: 'GTY' '(' '(' option_seq? ')' ')' */ 582 static options_p 583 gtymarker (void) 584 { 585 options_p result = 0; 586 require (GTY_TOKEN); 587 require ('('); 588 require ('('); 589 if (token () != ')') 590 result = option_seq (); 591 require (')'); 592 require (')'); 593 return result; 594 } 595 596 /* Optional GTY marker. */ 597 static options_p 598 gtymarker_opt (void) 599 { 600 if (token () != GTY_TOKEN) 601 return 0; 602 return gtymarker (); 603 } 604 605 606 607 /* Declarators. The logic here is largely lifted from c-parser.c. 608 Note that we do not have to process abstract declarators, which can 609 appear only in parameter type lists or casts (but see absdecl, 610 above). Also, type qualifiers are thrown out in gengtype-lex.l so 611 we don't have to do it. */ 612 613 /* array_and_function_declarators_opt: 614 \epsilon 615 array_and_function_declarators_opt ARRAY 616 array_and_function_declarators_opt '(' ... ')' 617 618 where '...' indicates stuff we ignore except insofar as grouping 619 symbols ()[]{} must balance. 620 621 Subroutine of direct_declarator - do not use elsewhere. */ 622 623 static type_p 624 array_and_function_declarators_opt (type_p ty) 625 { 626 if (token () == ARRAY) 627 { 628 const char *array = advance (); 629 return create_array (array_and_function_declarators_opt (ty), array); 630 } 631 else if (token () == '(') 632 { 633 /* We don't need exact types for functions. */ 634 consume_balanced ('(', ')'); 635 array_and_function_declarators_opt (ty); 636 return create_scalar_type ("function type"); 637 } 638 else 639 return ty; 640 } 641 642 static type_p inner_declarator (type_p, const char **, options_p *, bool); 643 644 /* direct_declarator: 645 '(' inner_declarator ')' 646 '(' \epsilon ')' <-- C++ ctors/dtors 647 gtymarker_opt ID array_and_function_declarators_opt 648 649 Subroutine of declarator, mutually recursive with inner_declarator; 650 do not use elsewhere. 651 652 IN_STRUCT is true if we are called while parsing structures or classes. */ 653 654 static type_p 655 direct_declarator (type_p ty, const char **namep, options_p *optsp, 656 bool in_struct) 657 { 658 /* The first token in a direct-declarator must be an ID, a 659 GTY marker, or an open parenthesis. */ 660 switch (token ()) 661 { 662 case GTY_TOKEN: 663 *optsp = gtymarker (); 664 /* fall through */ 665 666 case ID: 667 *namep = require (ID); 668 /* If the next token is '(', we are parsing a function declaration. 669 Functions are ignored by gengtype, so we return NULL. */ 670 if (token () == '(') 671 return NULL; 672 break; 673 674 case '(': 675 /* If the declarator starts with a '(', we have three options. We 676 are either parsing 'TYPE (*ID)' (i.e., a function pointer) 677 or 'TYPE(...)'. 678 679 The latter will be a constructor iff we are inside a 680 structure or class. Otherwise, it could be a typedef, but 681 since we explicitly reject typedefs inside structures, we can 682 assume that we found a ctor and return NULL. */ 683 advance (); 684 if (in_struct && token () != '*') 685 { 686 /* Found a constructor. Find and consume the closing ')'. */ 687 while (token () != ')') 688 advance (); 689 advance (); 690 /* Tell the caller to ignore this. */ 691 return NULL; 692 } 693 ty = inner_declarator (ty, namep, optsp, in_struct); 694 require (')'); 695 break; 696 697 case IGNORABLE_CXX_KEYWORD: 698 /* Any C++ keyword like 'operator' means that we are not looking 699 at a regular data declarator. */ 700 return NULL; 701 702 default: 703 parse_error ("expected '(', ')', 'GTY', or an identifier, have %s", 704 print_cur_token ()); 705 /* Do _not_ advance if what we have is a close squiggle brace, as 706 we will get much better error recovery that way. */ 707 if (token () != '}') 708 advance (); 709 return 0; 710 } 711 return array_and_function_declarators_opt (ty); 712 } 713 714 /* The difference between inner_declarator and declarator is in the 715 handling of stars. Consider this declaration: 716 717 char * (*pfc) (void) 718 719 It declares a pointer to a function that takes no arguments and 720 returns a char*. To construct the correct type for this 721 declaration, the star outside the parentheses must be processed 722 _before_ the function type, the star inside the parentheses must 723 be processed _after_ the function type. To accomplish this, 724 declarator() creates pointers before recursing (it is actually 725 coded as a while loop), whereas inner_declarator() recurses before 726 creating pointers. */ 727 728 /* inner_declarator: 729 '*' inner_declarator 730 direct_declarator 731 732 Mutually recursive subroutine of direct_declarator; do not use 733 elsewhere. 734 735 IN_STRUCT is true if we are called while parsing structures or classes. */ 736 737 static type_p 738 inner_declarator (type_p ty, const char **namep, options_p *optsp, 739 bool in_struct) 740 { 741 if (token () == '*') 742 { 743 type_p inner; 744 advance (); 745 inner = inner_declarator (ty, namep, optsp, in_struct); 746 if (inner == 0) 747 return 0; 748 else 749 return create_pointer (ty); 750 } 751 else 752 return direct_declarator (ty, namep, optsp, in_struct); 753 } 754 755 /* declarator: '*'+ direct_declarator 756 757 This is the sole public interface to this part of the grammar. 758 Arguments are the type known so far, a pointer to where the name 759 may be stored, and a pointer to where GTY options may be stored. 760 761 IN_STRUCT is true when we are called to parse declarators inside 762 a structure or class. 763 764 Returns the final type. */ 765 766 static type_p 767 declarator (type_p ty, const char **namep, options_p *optsp, 768 bool in_struct = false) 769 { 770 *namep = 0; 771 *optsp = 0; 772 while (token () == '*') 773 { 774 advance (); 775 ty = create_pointer (ty); 776 } 777 return direct_declarator (ty, namep, optsp, in_struct); 778 } 779 780 /* Types and declarations. */ 781 782 /* Structure field(s) declaration: 783 ( 784 type bitfield ';' 785 | type declarator bitfield? ( ',' declarator bitfield? )+ ';' 786 )* 787 788 Knows that such declarations must end with a close brace (or, 789 erroneously, at EOF). 790 */ 791 static pair_p 792 struct_field_seq (void) 793 { 794 pair_p f = 0; 795 type_p ty, dty; 796 options_p opts, dopts; 797 const char *name; 798 bool another; 799 800 while (token () != '}' && token () != EOF_TOKEN) 801 { 802 ty = type (&opts, true); 803 804 /* Ignore access-control keywords ("public:" etc). */ 805 while (!ty && token () == IGNORABLE_CXX_KEYWORD) 806 { 807 const char *keyword = advance (); 808 if (strcmp (keyword, "public:") != 0 809 && strcmp (keyword, "private:") != 0 810 && strcmp (keyword, "protected:") != 0) 811 break; 812 ty = type (&opts, true); 813 } 814 815 if (!ty || token () == ':') 816 { 817 consume_until_eos (); 818 continue; 819 } 820 821 do 822 { 823 dty = declarator (ty, &name, &dopts, true); 824 825 /* There could be any number of weird things after the declarator, 826 notably bitfield declarations and __attribute__s. If this 827 function returns true, the last thing was a comma, so we have 828 more than one declarator paired with the current type. */ 829 another = consume_until_comma_or_eos (); 830 831 if (!dty) 832 continue; 833 834 if (opts && dopts) 835 parse_error ("two GTY(()) options for field %s", name); 836 if (opts && !dopts) 837 dopts = opts; 838 839 f = create_field_at (f, dty, name, dopts, &lexer_line); 840 } 841 while (another); 842 } 843 return nreverse_pairs (f); 844 } 845 846 /* Return true if OPTS contain the option named STR. */ 847 848 bool 849 opts_have (options_p opts, const char *str) 850 { 851 for (options_p opt = opts; opt; opt = opt->next) 852 if (strcmp (opt->name, str) == 0) 853 return true; 854 return false; 855 } 856 857 858 /* This is called type(), but what it parses (sort of) is what C calls 859 declaration-specifiers and specifier-qualifier-list: 860 861 SCALAR 862 | ID // typedef 863 | (STRUCT|UNION) ID? gtymarker? ( '{' gtymarker? struct_field_seq '}' )? 864 | ENUM ID ( '{' ... '}' )? 865 866 Returns a partial type; under some conditions (notably 867 "struct foo GTY((...)) thing;") it may write an options 868 structure to *OPTSP. 869 870 NESTED is true when parsing a declaration already known to have a 871 GTY marker. In these cases, typedef and enum declarations are not 872 allowed because gengtype only understands types at the global 873 scope. */ 874 875 static type_p 876 type (options_p *optsp, bool nested) 877 { 878 const char *s; 879 *optsp = 0; 880 switch (token ()) 881 { 882 case SCALAR: 883 s = advance (); 884 return create_scalar_type (s); 885 886 case ID: 887 s = typedef_name (); 888 return resolve_typedef (s, &lexer_line); 889 890 case IGNORABLE_CXX_KEYWORD: 891 /* By returning NULL here, we indicate to the caller that they 892 should ignore everything following this keyword up to the 893 next ';' or '}'. */ 894 return NULL; 895 896 case STRUCT: 897 case UNION: 898 { 899 type_p base_class = NULL; 900 options_p opts = 0; 901 /* GTY annotations follow attribute syntax 902 GTY_BEFORE_ID is for union/struct declarations 903 GTY_AFTER_ID is for variable declarations. */ 904 enum 905 { 906 NO_GTY, 907 GTY_BEFORE_ID, 908 GTY_AFTER_ID 909 } is_gty = NO_GTY; 910 enum typekind kind = (token () == UNION) ? TYPE_UNION : TYPE_STRUCT; 911 advance (); 912 913 /* Top-level structures that are not explicitly tagged GTY(()) 914 are treated as mere forward declarations. This is because 915 there are a lot of structures that we don't need to know 916 about, and some of those have C++ and macro constructs that 917 we cannot handle. */ 918 if (nested || token () == GTY_TOKEN) 919 { 920 is_gty = GTY_BEFORE_ID; 921 opts = gtymarker_opt (); 922 } 923 924 if (token () == ID) 925 s = advance (); 926 else 927 s = xasprintf ("anonymous:%s:%d", 928 get_input_file_name (lexer_line.file), 929 lexer_line.line); 930 931 /* Unfortunately above GTY_TOKEN check does not capture the 932 typedef struct_type GTY case. */ 933 if (token () == GTY_TOKEN) 934 { 935 is_gty = GTY_AFTER_ID; 936 opts = gtymarker_opt (); 937 } 938 939 bool is_user_gty = opts_have (opts, "user"); 940 941 if (token () == ':') 942 { 943 if (is_gty && !is_user_gty) 944 { 945 /* For GTY-marked types that are not "user", parse some C++ 946 inheritance specifications. 947 We require single-inheritance from a non-template type. */ 948 advance (); 949 const char *basename = require (ID); 950 /* This may be either an access specifier, or the base name. */ 951 if (strcmp (basename, "public") == 0 952 || strcmp (basename, "protected") == 0 953 || strcmp (basename, "private") == 0) 954 basename = require (ID); 955 base_class = find_structure (basename, TYPE_STRUCT); 956 if (!base_class) 957 parse_error ("unrecognized base class: %s", basename); 958 require_without_advance ('{'); 959 } 960 else 961 { 962 /* For types lacking GTY-markings, skip over C++ inheritance 963 specification (and thus avoid having to parse e.g. template 964 types). */ 965 while (token () != '{') 966 advance (); 967 } 968 } 969 970 if (is_gty) 971 { 972 if (token () == '{') 973 { 974 pair_p fields; 975 976 if (is_gty == GTY_AFTER_ID) 977 parse_error ("GTY must be specified before identifier"); 978 979 if (!is_user_gty) 980 { 981 advance (); 982 fields = struct_field_seq (); 983 require ('}'); 984 } 985 else 986 { 987 /* Do not look inside user defined structures. */ 988 fields = NULL; 989 kind = TYPE_USER_STRUCT; 990 consume_balanced ('{', '}'); 991 return create_user_defined_type (s, &lexer_line); 992 } 993 994 return new_structure (s, kind, &lexer_line, fields, opts, 995 base_class); 996 } 997 } 998 else if (token () == '{') 999 consume_balanced ('{', '}'); 1000 if (opts) 1001 *optsp = opts; 1002 return find_structure (s, kind); 1003 } 1004 1005 case TYPEDEF: 1006 /* In C++, a typedef inside a struct/class/union defines a new 1007 type for that inner scope. We cannot support this in 1008 gengtype because we have no concept of scoping. 1009 1010 We handle typedefs in the global scope separately (see 1011 parse_file), so if we find a 'typedef', we must be inside 1012 a struct. */ 1013 gcc_assert (nested); 1014 parse_error ("typedefs not supported in structures marked with " 1015 "automatic GTY markers. Use GTY((user)) to mark " 1016 "this structure."); 1017 advance (); 1018 return NULL; 1019 1020 case ENUM: 1021 advance (); 1022 if (token () == ID) 1023 s = advance (); 1024 else 1025 s = xasprintf ("anonymous:%s:%d", 1026 get_input_file_name (lexer_line.file), 1027 lexer_line.line); 1028 1029 if (token () == '{') 1030 consume_balanced ('{', '}'); 1031 1032 /* If after parsing the enum we are at the end of the statement, 1033 and we are currently inside a structure, then this was an 1034 enum declaration inside this scope. 1035 1036 We cannot support this for the same reason we cannot support 1037 'typedef' inside structures (see the TYPEDEF handler above). 1038 If this happens, emit an error and return NULL. */ 1039 if (nested && token () == ';') 1040 { 1041 parse_error ("enum definitions not supported in structures marked " 1042 "with automatic GTY markers. Use GTY((user)) to mark " 1043 "this structure."); 1044 advance (); 1045 return NULL; 1046 } 1047 1048 return create_scalar_type (s); 1049 1050 default: 1051 parse_error ("expected a type specifier, have %s", print_cur_token ()); 1052 advance (); 1053 return create_scalar_type ("erroneous type"); 1054 } 1055 } 1056 1057 /* Top level constructs. */ 1058 1059 /* Dispatch declarations beginning with 'typedef'. */ 1060 1061 static void 1062 typedef_decl (void) 1063 { 1064 type_p ty, dty; 1065 const char *name; 1066 options_p opts; 1067 bool another; 1068 1069 gcc_assert (token () == TYPEDEF); 1070 advance (); 1071 1072 ty = type (&opts, false); 1073 if (!ty) 1074 return; 1075 if (opts) 1076 parse_error ("GTY((...)) cannot be applied to a typedef"); 1077 do 1078 { 1079 dty = declarator (ty, &name, &opts); 1080 if (opts) 1081 parse_error ("GTY((...)) cannot be applied to a typedef"); 1082 1083 /* Yet another place where we could have junk (notably attributes) 1084 after the declarator. */ 1085 another = consume_until_comma_or_eos (); 1086 if (dty) 1087 do_typedef (name, dty, &lexer_line); 1088 } 1089 while (another); 1090 } 1091 1092 /* Structure definition: type() does all the work. */ 1093 1094 static void 1095 struct_or_union (void) 1096 { 1097 options_p dummy; 1098 type (&dummy, false); 1099 /* There may be junk after the type: notably, we cannot currently 1100 distinguish 'struct foo *function(prototype);' from 'struct foo;' 1101 ... we could call declarator(), but it's a waste of time at 1102 present. Instead, just eat whatever token is currently lookahead 1103 and go back to lexical skipping mode. */ 1104 advance (); 1105 } 1106 1107 /* GC root declaration: 1108 (extern|static) gtymarker? type ID array_declarators_opt (';'|'=') 1109 If the gtymarker is not present, we ignore the rest of the declaration. */ 1110 static void 1111 extern_or_static (void) 1112 { 1113 options_p opts, opts2, dopts; 1114 type_p ty, dty; 1115 const char *name; 1116 require2 (EXTERN, STATIC); 1117 1118 if (token () != GTY_TOKEN) 1119 { 1120 advance (); 1121 return; 1122 } 1123 1124 opts = gtymarker (); 1125 ty = type (&opts2, true); /* if we get here, it's got a GTY(()) */ 1126 dty = declarator (ty, &name, &dopts); 1127 1128 if ((opts && dopts) || (opts && opts2) || (opts2 && dopts)) 1129 parse_error ("GTY((...)) specified more than once for %s", name); 1130 else if (opts2) 1131 opts = opts2; 1132 else if (dopts) 1133 opts = dopts; 1134 1135 if (dty) 1136 { 1137 note_variable (name, adjust_field_type (dty, opts), opts, &lexer_line); 1138 require2 (';', '='); 1139 } 1140 } 1141 1142 /* Parse the file FNAME for GC-relevant declarations and definitions. 1143 This is the only entry point to this file. */ 1144 void 1145 parse_file (const char *fname) 1146 { 1147 yybegin (fname); 1148 for (;;) 1149 { 1150 switch (token ()) 1151 { 1152 case EXTERN: 1153 case STATIC: 1154 extern_or_static (); 1155 break; 1156 1157 case STRUCT: 1158 case UNION: 1159 struct_or_union (); 1160 break; 1161 1162 case TYPEDEF: 1163 typedef_decl (); 1164 break; 1165 1166 case EOF_TOKEN: 1167 goto eof; 1168 1169 default: 1170 parse_error ("unexpected top level token, %s", print_cur_token ()); 1171 goto eof; 1172 } 1173 lexer_toplevel_done = 1; 1174 } 1175 1176 eof: 1177 advance (); 1178 yyend (); 1179 } 1180