1 // THIS FILE IS GENERATED 2 // WARNING! All changes made in this file will be lost! 3 4 #include "cool_parser.h" 5 6 7 #include "cool_lexer.h" 8 9 10 namespace cool 11 { 12 tokenize(char * contents)13 void parser::tokenize( char *contents ) 14 { 15 Lexer lexer( this, contents ); 16 17 int kind = parser::Token_EOF; 18 do 19 { 20 kind = lexer.yylex(); 21 //std::cerr << lexer.YYText() << std::endl; //" "; // debug output 22 23 if ( !kind ) // when the lexer returns 0, the end of file is reached 24 kind = parser::Token_EOF; 25 26 parser::token_type &t = this->token_stream->next(); 27 t.kind = kind; 28 t.begin = lexer.tokenBegin(); 29 t.end = lexer.tokenEnd(); 30 t.text = contents; 31 } 32 while ( kind != parser::Token_EOF ); 33 34 this->yylex(); // produce the look ahead token 35 } 36 37 } // end of namespace cool 38 39 40 namespace cool 41 { 42 parse_additive_expression(additive_expression_ast ** yynode)43 bool parser::parse_additive_expression(additive_expression_ast **yynode) 44 { 45 *yynode = create<additive_expression_ast>(); 46 47 (*yynode)->start_token = token_stream->index() - 1; 48 49 if (yytoken == Token_NEW 50 || yytoken == Token_IF 51 || yytoken == Token_WHILE 52 || yytoken == Token_LET 53 || yytoken == Token_CASE 54 || yytoken == Token_LPAREN 55 || yytoken == Token_LBRACE 56 || yytoken == Token_TILDE 57 || yytoken == Token_NOT 58 || yytoken == Token_ISVOID 59 || yytoken == Token_IDENTIFIER 60 || yytoken == Token_INTEGER 61 || yytoken == Token_STRING 62 || yytoken == Token_TRUE 63 || yytoken == Token_FALSE) 64 { 65 multiplicative_expression_ast *__node_0 = 0; 66 if (!parse_multiplicative_expression(&__node_0)) 67 { 68 yy_expected_symbol(ast_node::Kind_multiplicative_expression, "multiplicative_expression"); 69 return false; 70 } 71 (*yynode)->expression_sequence = snoc((*yynode)->expression_sequence, __node_0, memory_pool); 72 73 while (yytoken == Token_PLUS 74 || yytoken == Token_MINUS) 75 { 76 if (yytoken == Token_PLUS) 77 { 78 if (yytoken != Token_PLUS) 79 { 80 yy_expected_token(yytoken, Token_PLUS, "+"); 81 return false; 82 } 83 (*yynode)->op = token_stream->index() - 1; 84 yylex(); 85 86 } 87 else if (yytoken == Token_MINUS) 88 { 89 if (yytoken != Token_MINUS) 90 { 91 yy_expected_token(yytoken, Token_MINUS, "-"); 92 return false; 93 } 94 (*yynode)->op = token_stream->index() - 1; 95 yylex(); 96 97 } 98 else 99 { 100 return false; 101 } 102 multiplicative_expression_ast *__node_1 = 0; 103 if (!parse_multiplicative_expression(&__node_1)) 104 { 105 yy_expected_symbol(ast_node::Kind_multiplicative_expression, "multiplicative_expression"); 106 return false; 107 } 108 (*yynode)->expression_sequence = snoc((*yynode)->expression_sequence, __node_1, memory_pool); 109 110 } 111 } 112 else 113 { 114 return false; 115 } 116 117 (*yynode)->end_token = token_stream->index() - 1; 118 119 return true; 120 } 121 parse_block_expression(block_expression_ast ** yynode)122 bool parser::parse_block_expression(block_expression_ast **yynode) 123 { 124 *yynode = create<block_expression_ast>(); 125 126 (*yynode)->start_token = token_stream->index() - 1; 127 128 if (yytoken == Token_LBRACE) 129 { 130 if (yytoken != Token_LBRACE) 131 { 132 yy_expected_token(yytoken, Token_LBRACE, "{"); 133 return false; 134 } 135 yylex(); 136 137 while (yytoken == Token_NEW 138 || yytoken == Token_IF 139 || yytoken == Token_WHILE 140 || yytoken == Token_LET 141 || yytoken == Token_CASE 142 || yytoken == Token_LPAREN 143 || yytoken == Token_LBRACE 144 || yytoken == Token_TILDE 145 || yytoken == Token_NOT 146 || yytoken == Token_ISVOID 147 || yytoken == Token_IDENTIFIER 148 || yytoken == Token_INTEGER 149 || yytoken == Token_STRING 150 || yytoken == Token_TRUE 151 || yytoken == Token_FALSE) 152 { 153 expression_ast *__node_2 = 0; 154 if (!parse_expression(&__node_2)) 155 { 156 yy_expected_symbol(ast_node::Kind_expression, "expression"); 157 return false; 158 } 159 (*yynode)->expression_sequence = snoc((*yynode)->expression_sequence, __node_2, memory_pool); 160 161 if (yytoken != Token_SEMICOLON) 162 { 163 yy_expected_token(yytoken, Token_SEMICOLON, ";"); 164 return false; 165 } 166 yylex(); 167 168 } 169 if (yytoken != Token_RBRACE) 170 { 171 yy_expected_token(yytoken, Token_RBRACE, "}"); 172 return false; 173 } 174 yylex(); 175 176 } 177 else 178 { 179 return false; 180 } 181 182 (*yynode)->end_token = token_stream->index() - 1; 183 184 return true; 185 } 186 parse_case_condition(case_condition_ast ** yynode)187 bool parser::parse_case_condition(case_condition_ast **yynode) 188 { 189 *yynode = create<case_condition_ast>(); 190 191 (*yynode)->start_token = token_stream->index() - 1; 192 193 if (yytoken == Token_IDENTIFIER) 194 { 195 if (yytoken != Token_IDENTIFIER) 196 { 197 yy_expected_token(yytoken, Token_IDENTIFIER, "identifier"); 198 return false; 199 } 200 (*yynode)->name = token_stream->index() - 1; 201 yylex(); 202 203 if (yytoken != Token_COLON) 204 { 205 yy_expected_token(yytoken, Token_COLON, ":"); 206 return false; 207 } 208 yylex(); 209 210 if (yytoken != Token_TYPE) 211 { 212 yy_expected_token(yytoken, Token_TYPE, "type specification"); 213 return false; 214 } 215 (*yynode)->type = token_stream->index() - 1; 216 yylex(); 217 218 if (yytoken != Token_ARROW_RIGHT) 219 { 220 yy_expected_token(yytoken, Token_ARROW_RIGHT, "=>"); 221 return false; 222 } 223 yylex(); 224 225 expression_ast *__node_3 = 0; 226 if (!parse_expression(&__node_3)) 227 { 228 yy_expected_symbol(ast_node::Kind_expression, "expression"); 229 return false; 230 } 231 (*yynode)->expression = __node_3; 232 233 } 234 else 235 { 236 return false; 237 } 238 239 (*yynode)->end_token = token_stream->index() - 1; 240 241 return true; 242 } 243 parse_case_expression(case_expression_ast ** yynode)244 bool parser::parse_case_expression(case_expression_ast **yynode) 245 { 246 *yynode = create<case_expression_ast>(); 247 248 (*yynode)->start_token = token_stream->index() - 1; 249 250 if (yytoken == Token_CASE) 251 { 252 if (yytoken != Token_CASE) 253 { 254 yy_expected_token(yytoken, Token_CASE, "case"); 255 return false; 256 } 257 yylex(); 258 259 expression_ast *__node_4 = 0; 260 if (!parse_expression(&__node_4)) 261 { 262 yy_expected_symbol(ast_node::Kind_expression, "expression"); 263 return false; 264 } 265 (*yynode)->expression = __node_4; 266 267 if (yytoken != Token_OF) 268 { 269 yy_expected_token(yytoken, Token_OF, "of"); 270 return false; 271 } 272 yylex(); 273 274 while (yytoken == Token_IDENTIFIER) 275 { 276 case_condition_ast *__node_5 = 0; 277 if (!parse_case_condition(&__node_5)) 278 { 279 yy_expected_symbol(ast_node::Kind_case_condition, "case_condition"); 280 return false; 281 } 282 (*yynode)->condition_sequence = snoc((*yynode)->condition_sequence, __node_5, memory_pool); 283 284 if (yytoken != Token_SEMICOLON) 285 { 286 yy_expected_token(yytoken, Token_SEMICOLON, ";"); 287 return false; 288 } 289 yylex(); 290 291 } 292 if (yytoken != Token_ESAC) 293 { 294 yy_expected_token(yytoken, Token_ESAC, "esac"); 295 return false; 296 } 297 yylex(); 298 299 } 300 else 301 { 302 return false; 303 } 304 305 (*yynode)->end_token = token_stream->index() - 1; 306 307 return true; 308 } 309 parse_class(class_ast ** yynode)310 bool parser::parse_class(class_ast **yynode) 311 { 312 *yynode = create<class_ast>(); 313 314 (*yynode)->start_token = token_stream->index() - 1; 315 316 if (yytoken == Token_CLASS) 317 { 318 if (yytoken != Token_CLASS) 319 { 320 yy_expected_token(yytoken, Token_CLASS, "class"); 321 return false; 322 } 323 yylex(); 324 325 if (yytoken != Token_TYPE) 326 { 327 yy_expected_token(yytoken, Token_TYPE, "type specification"); 328 return false; 329 } 330 (*yynode)->type = token_stream->index() - 1; 331 yylex(); 332 333 if (yytoken == Token_INHERITS) 334 { 335 if (yytoken != Token_INHERITS) 336 { 337 yy_expected_token(yytoken, Token_INHERITS, "inherits"); 338 return false; 339 } 340 yylex(); 341 342 if (yytoken != Token_TYPE) 343 { 344 yy_expected_token(yytoken, Token_TYPE, "type specification"); 345 return false; 346 } 347 (*yynode)->base_type = token_stream->index() - 1; 348 yylex(); 349 350 } 351 else if (true /*epsilon*/) 352 {} 353 else 354 { 355 return false; 356 } 357 if (yytoken != Token_LBRACE) 358 { 359 yy_expected_token(yytoken, Token_LBRACE, "{"); 360 return false; 361 } 362 yylex(); 363 364 while (yytoken == Token_IDENTIFIER) 365 { 366 feature_ast *__node_6 = 0; 367 if (!parse_feature(&__node_6)) 368 { 369 yy_expected_symbol(ast_node::Kind_feature, "feature"); 370 return false; 371 } 372 (*yynode)->feature_sequence = snoc((*yynode)->feature_sequence, __node_6, memory_pool); 373 374 if (yytoken != Token_SEMICOLON) 375 { 376 yy_expected_token(yytoken, Token_SEMICOLON, ";"); 377 return false; 378 } 379 yylex(); 380 381 } 382 if (yytoken != Token_RBRACE) 383 { 384 yy_expected_token(yytoken, Token_RBRACE, "}"); 385 return false; 386 } 387 yylex(); 388 389 } 390 else 391 { 392 return false; 393 } 394 395 (*yynode)->end_token = token_stream->index() - 1; 396 397 return true; 398 } 399 parse_expression(expression_ast ** yynode)400 bool parser::parse_expression(expression_ast **yynode) 401 { 402 *yynode = create<expression_ast>(); 403 404 (*yynode)->start_token = token_stream->index() - 1; 405 406 if (yytoken == Token_NEW 407 || yytoken == Token_IF 408 || yytoken == Token_WHILE 409 || yytoken == Token_LET 410 || yytoken == Token_CASE 411 || yytoken == Token_LPAREN 412 || yytoken == Token_LBRACE 413 || yytoken == Token_TILDE 414 || yytoken == Token_NOT 415 || yytoken == Token_ISVOID 416 || yytoken == Token_IDENTIFIER 417 || yytoken == Token_INTEGER 418 || yytoken == Token_STRING 419 || yytoken == Token_TRUE 420 || yytoken == Token_FALSE) 421 { 422 relational_expression_ast *__node_7 = 0; 423 if (!parse_relational_expression(&__node_7)) 424 { 425 yy_expected_symbol(ast_node::Kind_relational_expression, "relational_expression"); 426 return false; 427 } 428 (*yynode)->expression = __node_7; 429 430 } 431 else 432 { 433 return false; 434 } 435 436 (*yynode)->end_token = token_stream->index() - 1; 437 438 return true; 439 } 440 parse_feature(feature_ast ** yynode)441 bool parser::parse_feature(feature_ast **yynode) 442 { 443 *yynode = create<feature_ast>(); 444 445 (*yynode)->start_token = token_stream->index() - 1; 446 447 if (yytoken == Token_IDENTIFIER) 448 { 449 if ((yytoken == Token_IDENTIFIER) && ( LA(2).kind == Token_LPAREN )) 450 { 451 if (yytoken != Token_IDENTIFIER) 452 { 453 yy_expected_token(yytoken, Token_IDENTIFIER, "identifier"); 454 return false; 455 } 456 (*yynode)->name = token_stream->index() - 1; 457 yylex(); 458 459 if (yytoken != Token_LPAREN) 460 { 461 yy_expected_token(yytoken, Token_LPAREN, "("); 462 return false; 463 } 464 yylex(); 465 466 if (yytoken == Token_IDENTIFIER) 467 { 468 formal_ast *__node_8 = 0; 469 if (!parse_formal(&__node_8)) 470 { 471 yy_expected_symbol(ast_node::Kind_formal, "formal"); 472 return false; 473 } 474 (*yynode)->formal_sequence = snoc((*yynode)->formal_sequence, __node_8, memory_pool); 475 476 while (yytoken == Token_COMMA) 477 { 478 if (yytoken != Token_COMMA) 479 { 480 yy_expected_token(yytoken, Token_COMMA, ","); 481 return false; 482 } 483 yylex(); 484 485 formal_ast *__node_9 = 0; 486 if (!parse_formal(&__node_9)) 487 { 488 yy_expected_symbol(ast_node::Kind_formal, "formal"); 489 return false; 490 } 491 (*yynode)->formal_sequence = snoc((*yynode)->formal_sequence, __node_9, memory_pool); 492 493 } 494 } 495 else if (true /*epsilon*/) 496 {} 497 else 498 { 499 return false; 500 } 501 if (yytoken != Token_RPAREN) 502 { 503 yy_expected_token(yytoken, Token_RPAREN, ")"); 504 return false; 505 } 506 yylex(); 507 508 if (yytoken != Token_COLON) 509 { 510 yy_expected_token(yytoken, Token_COLON, ":"); 511 return false; 512 } 513 yylex(); 514 515 if (yytoken != Token_TYPE) 516 { 517 yy_expected_token(yytoken, Token_TYPE, "type specification"); 518 return false; 519 } 520 (*yynode)->type = token_stream->index() - 1; 521 yylex(); 522 523 if (yytoken != Token_LBRACE) 524 { 525 yy_expected_token(yytoken, Token_LBRACE, "{"); 526 return false; 527 } 528 yylex(); 529 530 expression_ast *__node_10 = 0; 531 if (!parse_expression(&__node_10)) 532 { 533 yy_expected_symbol(ast_node::Kind_expression, "expression"); 534 return false; 535 } 536 (*yynode)->expression = __node_10; 537 538 if (yytoken != Token_RBRACE) 539 { 540 yy_expected_token(yytoken, Token_RBRACE, "}"); 541 return false; 542 } 543 yylex(); 544 545 } 546 else if (yytoken == Token_IDENTIFIER) 547 { 548 if (yytoken != Token_IDENTIFIER) 549 { 550 yy_expected_token(yytoken, Token_IDENTIFIER, "identifier"); 551 return false; 552 } 553 (*yynode)->name = token_stream->index() - 1; 554 yylex(); 555 556 if (yytoken != Token_COLON) 557 { 558 yy_expected_token(yytoken, Token_COLON, ":"); 559 return false; 560 } 561 yylex(); 562 563 if (yytoken != Token_TYPE) 564 { 565 yy_expected_token(yytoken, Token_TYPE, "type specification"); 566 return false; 567 } 568 (*yynode)->type = token_stream->index() - 1; 569 yylex(); 570 571 if (yytoken == Token_ARROW_LEFT) 572 { 573 if (yytoken != Token_ARROW_LEFT) 574 { 575 yy_expected_token(yytoken, Token_ARROW_LEFT, "<-"); 576 return false; 577 } 578 yylex(); 579 580 expression_ast *__node_11 = 0; 581 if (!parse_expression(&__node_11)) 582 { 583 yy_expected_symbol(ast_node::Kind_expression, "expression"); 584 return false; 585 } 586 (*yynode)->expression = __node_11; 587 588 } 589 else if (true /*epsilon*/) 590 {} 591 else 592 { 593 return false; 594 } 595 } 596 else 597 { 598 return false; 599 } 600 } 601 else 602 { 603 return false; 604 } 605 606 (*yynode)->end_token = token_stream->index() - 1; 607 608 return true; 609 } 610 parse_formal(formal_ast ** yynode)611 bool parser::parse_formal(formal_ast **yynode) 612 { 613 *yynode = create<formal_ast>(); 614 615 (*yynode)->start_token = token_stream->index() - 1; 616 617 if (yytoken == Token_IDENTIFIER) 618 { 619 if (yytoken != Token_IDENTIFIER) 620 { 621 yy_expected_token(yytoken, Token_IDENTIFIER, "identifier"); 622 return false; 623 } 624 (*yynode)->name = token_stream->index() - 1; 625 yylex(); 626 627 if (yytoken != Token_COLON) 628 { 629 yy_expected_token(yytoken, Token_COLON, ":"); 630 return false; 631 } 632 yylex(); 633 634 if (yytoken != Token_TYPE) 635 { 636 yy_expected_token(yytoken, Token_TYPE, "type specification"); 637 return false; 638 } 639 (*yynode)->type = token_stream->index() - 1; 640 yylex(); 641 642 } 643 else 644 { 645 return false; 646 } 647 648 (*yynode)->end_token = token_stream->index() - 1; 649 650 return true; 651 } 652 parse_if_expression(if_expression_ast ** yynode)653 bool parser::parse_if_expression(if_expression_ast **yynode) 654 { 655 *yynode = create<if_expression_ast>(); 656 657 (*yynode)->start_token = token_stream->index() - 1; 658 659 if (yytoken == Token_IF) 660 { 661 if (yytoken != Token_IF) 662 { 663 yy_expected_token(yytoken, Token_IF, "if"); 664 return false; 665 } 666 yylex(); 667 668 expression_ast *__node_12 = 0; 669 if (!parse_expression(&__node_12)) 670 { 671 yy_expected_symbol(ast_node::Kind_expression, "expression"); 672 return false; 673 } 674 (*yynode)->condition = __node_12; 675 676 if (yytoken != Token_THEN) 677 { 678 yy_expected_token(yytoken, Token_THEN, "then"); 679 return false; 680 } 681 yylex(); 682 683 expression_ast *__node_13 = 0; 684 if (!parse_expression(&__node_13)) 685 { 686 yy_expected_symbol(ast_node::Kind_expression, "expression"); 687 return false; 688 } 689 (*yynode)->true_expression = __node_13; 690 691 if (yytoken != Token_ELSE) 692 { 693 yy_expected_token(yytoken, Token_ELSE, "else"); 694 return false; 695 } 696 yylex(); 697 698 expression_ast *__node_14 = 0; 699 if (!parse_expression(&__node_14)) 700 { 701 yy_expected_symbol(ast_node::Kind_expression, "expression"); 702 return false; 703 } 704 (*yynode)->false_expression = __node_14; 705 706 if (yytoken != Token_FI) 707 { 708 yy_expected_token(yytoken, Token_FI, "fi"); 709 return false; 710 } 711 yylex(); 712 713 } 714 else 715 { 716 return false; 717 } 718 719 (*yynode)->end_token = token_stream->index() - 1; 720 721 return true; 722 } 723 parse_let_declaration(let_declaration_ast ** yynode)724 bool parser::parse_let_declaration(let_declaration_ast **yynode) 725 { 726 *yynode = create<let_declaration_ast>(); 727 728 (*yynode)->start_token = token_stream->index() - 1; 729 730 if (yytoken == Token_IDENTIFIER) 731 { 732 if (yytoken != Token_IDENTIFIER) 733 { 734 yy_expected_token(yytoken, Token_IDENTIFIER, "identifier"); 735 return false; 736 } 737 (*yynode)->name = token_stream->index() - 1; 738 yylex(); 739 740 if (yytoken != Token_COLON) 741 { 742 yy_expected_token(yytoken, Token_COLON, ":"); 743 return false; 744 } 745 yylex(); 746 747 if (yytoken != Token_TYPE) 748 { 749 yy_expected_token(yytoken, Token_TYPE, "type specification"); 750 return false; 751 } 752 (*yynode)->type = token_stream->index() - 1; 753 yylex(); 754 755 if (yytoken == Token_ARROW_LEFT) 756 { 757 if (yytoken != Token_ARROW_LEFT) 758 { 759 yy_expected_token(yytoken, Token_ARROW_LEFT, "<-"); 760 return false; 761 } 762 yylex(); 763 764 expression_ast *__node_15 = 0; 765 if (!parse_expression(&__node_15)) 766 { 767 yy_expected_symbol(ast_node::Kind_expression, "expression"); 768 return false; 769 } 770 (*yynode)->expression = __node_15; 771 772 } 773 else if (true /*epsilon*/) 774 {} 775 else 776 { 777 return false; 778 } 779 } 780 else 781 { 782 return false; 783 } 784 785 (*yynode)->end_token = token_stream->index() - 1; 786 787 return true; 788 } 789 parse_let_expression(let_expression_ast ** yynode)790 bool parser::parse_let_expression(let_expression_ast **yynode) 791 { 792 *yynode = create<let_expression_ast>(); 793 794 (*yynode)->start_token = token_stream->index() - 1; 795 796 if (yytoken == Token_LET) 797 { 798 if (yytoken != Token_LET) 799 { 800 yy_expected_token(yytoken, Token_LET, "let"); 801 return false; 802 } 803 yylex(); 804 805 let_declaration_ast *__node_16 = 0; 806 if (!parse_let_declaration(&__node_16)) 807 { 808 yy_expected_symbol(ast_node::Kind_let_declaration, "let_declaration"); 809 return false; 810 } 811 (*yynode)->declaration_sequence = snoc((*yynode)->declaration_sequence, __node_16, memory_pool); 812 813 while (yytoken == Token_COMMA) 814 { 815 if (yytoken != Token_COMMA) 816 { 817 yy_expected_token(yytoken, Token_COMMA, ","); 818 return false; 819 } 820 yylex(); 821 822 let_declaration_ast *__node_17 = 0; 823 if (!parse_let_declaration(&__node_17)) 824 { 825 yy_expected_symbol(ast_node::Kind_let_declaration, "let_declaration"); 826 return false; 827 } 828 (*yynode)->declaration_sequence = snoc((*yynode)->declaration_sequence, __node_17, memory_pool); 829 830 } 831 if (yytoken != Token_IN) 832 { 833 yy_expected_token(yytoken, Token_IN, "in"); 834 return false; 835 } 836 yylex(); 837 838 expression_ast *__node_18 = 0; 839 if (!parse_expression(&__node_18)) 840 { 841 yy_expected_symbol(ast_node::Kind_expression, "expression"); 842 return false; 843 } 844 (*yynode)->body_expression = __node_18; 845 846 } 847 else 848 { 849 return false; 850 } 851 852 (*yynode)->end_token = token_stream->index() - 1; 853 854 return true; 855 } 856 parse_multiplicative_expression(multiplicative_expression_ast ** yynode)857 bool parser::parse_multiplicative_expression(multiplicative_expression_ast **yynode) 858 { 859 *yynode = create<multiplicative_expression_ast>(); 860 861 (*yynode)->start_token = token_stream->index() - 1; 862 863 if (yytoken == Token_NEW 864 || yytoken == Token_IF 865 || yytoken == Token_WHILE 866 || yytoken == Token_LET 867 || yytoken == Token_CASE 868 || yytoken == Token_LPAREN 869 || yytoken == Token_LBRACE 870 || yytoken == Token_TILDE 871 || yytoken == Token_NOT 872 || yytoken == Token_ISVOID 873 || yytoken == Token_IDENTIFIER 874 || yytoken == Token_INTEGER 875 || yytoken == Token_STRING 876 || yytoken == Token_TRUE 877 || yytoken == Token_FALSE) 878 { 879 postfix_expression_ast *__node_19 = 0; 880 if (!parse_postfix_expression(&__node_19)) 881 { 882 yy_expected_symbol(ast_node::Kind_postfix_expression, "postfix_expression"); 883 return false; 884 } 885 (*yynode)->expression_sequence = snoc((*yynode)->expression_sequence, __node_19, memory_pool); 886 887 while (yytoken == Token_STAR 888 || yytoken == Token_SLASH) 889 { 890 if (yytoken == Token_STAR) 891 { 892 if (yytoken != Token_STAR) 893 { 894 yy_expected_token(yytoken, Token_STAR, "*"); 895 return false; 896 } 897 (*yynode)->op = token_stream->index() - 1; 898 yylex(); 899 900 } 901 else if (yytoken == Token_SLASH) 902 { 903 if (yytoken != Token_SLASH) 904 { 905 yy_expected_token(yytoken, Token_SLASH, "/"); 906 return false; 907 } 908 (*yynode)->op = token_stream->index() - 1; 909 yylex(); 910 911 } 912 else 913 { 914 return false; 915 } 916 postfix_expression_ast *__node_20 = 0; 917 if (!parse_postfix_expression(&__node_20)) 918 { 919 yy_expected_symbol(ast_node::Kind_postfix_expression, "postfix_expression"); 920 return false; 921 } 922 (*yynode)->expression_sequence = snoc((*yynode)->expression_sequence, __node_20, memory_pool); 923 924 } 925 } 926 else 927 { 928 return false; 929 } 930 931 (*yynode)->end_token = token_stream->index() - 1; 932 933 return true; 934 } 935 parse_postfix_expression(postfix_expression_ast ** yynode)936 bool parser::parse_postfix_expression(postfix_expression_ast **yynode) 937 { 938 *yynode = create<postfix_expression_ast>(); 939 940 (*yynode)->start_token = token_stream->index() - 1; 941 942 if (yytoken == Token_NEW 943 || yytoken == Token_IF 944 || yytoken == Token_WHILE 945 || yytoken == Token_LET 946 || yytoken == Token_CASE 947 || yytoken == Token_LPAREN 948 || yytoken == Token_LBRACE 949 || yytoken == Token_TILDE 950 || yytoken == Token_NOT 951 || yytoken == Token_ISVOID 952 || yytoken == Token_IDENTIFIER 953 || yytoken == Token_INTEGER 954 || yytoken == Token_STRING 955 || yytoken == Token_TRUE 956 || yytoken == Token_FALSE) 957 { 958 unary_expression_ast *__node_21 = 0; 959 if (!parse_unary_expression(&__node_21)) 960 { 961 yy_expected_symbol(ast_node::Kind_unary_expression, "unary_expression"); 962 return false; 963 } 964 (*yynode)->base_expression = __node_21; 965 966 while (yytoken == Token_DOT 967 || yytoken == Token_AT) 968 { 969 if (yytoken == Token_AT) 970 { 971 if (yytoken != Token_AT) 972 { 973 yy_expected_token(yytoken, Token_AT, "@"); 974 return false; 975 } 976 yylex(); 977 978 if (yytoken != Token_TYPE) 979 { 980 yy_expected_token(yytoken, Token_TYPE, "type specification"); 981 return false; 982 } 983 (*yynode)->at_type = token_stream->index() - 1; 984 yylex(); 985 986 if (yytoken != Token_DOT) 987 { 988 yy_expected_token(yytoken, Token_DOT, "."); 989 return false; 990 } 991 yylex(); 992 993 if (yytoken != Token_IDENTIFIER) 994 { 995 yy_expected_token(yytoken, Token_IDENTIFIER, "identifier"); 996 return false; 997 } 998 (*yynode)->name = token_stream->index() - 1; 999 yylex(); 1000 1001 if (yytoken != Token_LPAREN) 1002 { 1003 yy_expected_token(yytoken, Token_LPAREN, "("); 1004 return false; 1005 } 1006 yylex(); 1007 1008 if (yytoken == Token_NEW 1009 || yytoken == Token_IF 1010 || yytoken == Token_WHILE 1011 || yytoken == Token_LET 1012 || yytoken == Token_CASE 1013 || yytoken == Token_LPAREN 1014 || yytoken == Token_LBRACE 1015 || yytoken == Token_TILDE 1016 || yytoken == Token_NOT 1017 || yytoken == Token_ISVOID 1018 || yytoken == Token_IDENTIFIER 1019 || yytoken == Token_INTEGER 1020 || yytoken == Token_STRING 1021 || yytoken == Token_TRUE 1022 || yytoken == Token_FALSE) 1023 { 1024 expression_ast *__node_22 = 0; 1025 if (!parse_expression(&__node_22)) 1026 { 1027 yy_expected_symbol(ast_node::Kind_expression, "expression"); 1028 return false; 1029 } 1030 (*yynode)->arguments_sequence = snoc((*yynode)->arguments_sequence, __node_22, memory_pool); 1031 1032 while (yytoken == Token_COMMA) 1033 { 1034 if (yytoken != Token_COMMA) 1035 { 1036 yy_expected_token(yytoken, Token_COMMA, ","); 1037 return false; 1038 } 1039 yylex(); 1040 1041 expression_ast *__node_23 = 0; 1042 if (!parse_expression(&__node_23)) 1043 { 1044 yy_expected_symbol(ast_node::Kind_expression, "expression"); 1045 return false; 1046 } 1047 (*yynode)->arguments_sequence = snoc((*yynode)->arguments_sequence, __node_23, memory_pool); 1048 1049 } 1050 } 1051 else if (true /*epsilon*/) 1052 {} 1053 else 1054 { 1055 return false; 1056 } 1057 if (yytoken != Token_RPAREN) 1058 { 1059 yy_expected_token(yytoken, Token_RPAREN, ")"); 1060 return false; 1061 } 1062 yylex(); 1063 1064 } 1065 else if (yytoken == Token_DOT) 1066 { 1067 if (yytoken != Token_DOT) 1068 { 1069 yy_expected_token(yytoken, Token_DOT, "."); 1070 return false; 1071 } 1072 yylex(); 1073 1074 if (yytoken != Token_IDENTIFIER) 1075 { 1076 yy_expected_token(yytoken, Token_IDENTIFIER, "identifier"); 1077 return false; 1078 } 1079 (*yynode)->name = token_stream->index() - 1; 1080 yylex(); 1081 1082 if (yytoken != Token_LPAREN) 1083 { 1084 yy_expected_token(yytoken, Token_LPAREN, "("); 1085 return false; 1086 } 1087 yylex(); 1088 1089 if (yytoken == Token_NEW 1090 || yytoken == Token_IF 1091 || yytoken == Token_WHILE 1092 || yytoken == Token_LET 1093 || yytoken == Token_CASE 1094 || yytoken == Token_LPAREN 1095 || yytoken == Token_LBRACE 1096 || yytoken == Token_TILDE 1097 || yytoken == Token_NOT 1098 || yytoken == Token_ISVOID 1099 || yytoken == Token_IDENTIFIER 1100 || yytoken == Token_INTEGER 1101 || yytoken == Token_STRING 1102 || yytoken == Token_TRUE 1103 || yytoken == Token_FALSE) 1104 { 1105 expression_ast *__node_24 = 0; 1106 if (!parse_expression(&__node_24)) 1107 { 1108 yy_expected_symbol(ast_node::Kind_expression, "expression"); 1109 return false; 1110 } 1111 (*yynode)->arguments_sequence = snoc((*yynode)->arguments_sequence, __node_24, memory_pool); 1112 1113 while (yytoken == Token_COMMA) 1114 { 1115 if (yytoken != Token_COMMA) 1116 { 1117 yy_expected_token(yytoken, Token_COMMA, ","); 1118 return false; 1119 } 1120 yylex(); 1121 1122 expression_ast *__node_25 = 0; 1123 if (!parse_expression(&__node_25)) 1124 { 1125 yy_expected_symbol(ast_node::Kind_expression, "expression"); 1126 return false; 1127 } 1128 (*yynode)->arguments_sequence = snoc((*yynode)->arguments_sequence, __node_25, memory_pool); 1129 1130 } 1131 } 1132 else if (true /*epsilon*/) 1133 {} 1134 else 1135 { 1136 return false; 1137 } 1138 if (yytoken != Token_RPAREN) 1139 { 1140 yy_expected_token(yytoken, Token_RPAREN, ")"); 1141 return false; 1142 } 1143 yylex(); 1144 1145 } 1146 else 1147 { 1148 return false; 1149 } 1150 } 1151 } 1152 else 1153 { 1154 return false; 1155 } 1156 1157 (*yynode)->end_token = token_stream->index() - 1; 1158 1159 return true; 1160 } 1161 parse_primary_expression(primary_expression_ast ** yynode)1162 bool parser::parse_primary_expression(primary_expression_ast **yynode) 1163 { 1164 *yynode = create<primary_expression_ast>(); 1165 1166 (*yynode)->start_token = token_stream->index() - 1; 1167 1168 if (yytoken == Token_NEW 1169 || yytoken == Token_IF 1170 || yytoken == Token_WHILE 1171 || yytoken == Token_LET 1172 || yytoken == Token_CASE 1173 || yytoken == Token_LPAREN 1174 || yytoken == Token_LBRACE 1175 || yytoken == Token_IDENTIFIER 1176 || yytoken == Token_INTEGER 1177 || yytoken == Token_STRING 1178 || yytoken == Token_TRUE 1179 || yytoken == Token_FALSE) 1180 { 1181 if ((yytoken == Token_IDENTIFIER) && ( LA(2).kind == Token_ARROW_LEFT )) 1182 { 1183 if (yytoken != Token_IDENTIFIER) 1184 { 1185 yy_expected_token(yytoken, Token_IDENTIFIER, "identifier"); 1186 return false; 1187 } 1188 (*yynode)->name = token_stream->index() - 1; 1189 yylex(); 1190 1191 if (yytoken != Token_ARROW_LEFT) 1192 { 1193 yy_expected_token(yytoken, Token_ARROW_LEFT, "<-"); 1194 return false; 1195 } 1196 yylex(); 1197 1198 expression_ast *__node_26 = 0; 1199 if (!parse_expression(&__node_26)) 1200 { 1201 yy_expected_symbol(ast_node::Kind_expression, "expression"); 1202 return false; 1203 } 1204 (*yynode)->expression = __node_26; 1205 1206 } 1207 else if ((yytoken == Token_IDENTIFIER) && ( LA(2).kind == Token_LPAREN )) 1208 { 1209 if (yytoken != Token_IDENTIFIER) 1210 { 1211 yy_expected_token(yytoken, Token_IDENTIFIER, "identifier"); 1212 return false; 1213 } 1214 (*yynode)->name = token_stream->index() - 1; 1215 yylex(); 1216 1217 if (yytoken != Token_LPAREN) 1218 { 1219 yy_expected_token(yytoken, Token_LPAREN, "("); 1220 return false; 1221 } 1222 yylex(); 1223 1224 if (yytoken == Token_NEW 1225 || yytoken == Token_IF 1226 || yytoken == Token_WHILE 1227 || yytoken == Token_LET 1228 || yytoken == Token_CASE 1229 || yytoken == Token_LPAREN 1230 || yytoken == Token_LBRACE 1231 || yytoken == Token_TILDE 1232 || yytoken == Token_NOT 1233 || yytoken == Token_ISVOID 1234 || yytoken == Token_IDENTIFIER 1235 || yytoken == Token_INTEGER 1236 || yytoken == Token_STRING 1237 || yytoken == Token_TRUE 1238 || yytoken == Token_FALSE) 1239 { 1240 expression_ast *__node_27 = 0; 1241 if (!parse_expression(&__node_27)) 1242 { 1243 yy_expected_symbol(ast_node::Kind_expression, "expression"); 1244 return false; 1245 } 1246 (*yynode)->argument_sequence = snoc((*yynode)->argument_sequence, __node_27, memory_pool); 1247 1248 while (yytoken == Token_COMMA) 1249 { 1250 if (yytoken != Token_COMMA) 1251 { 1252 yy_expected_token(yytoken, Token_COMMA, ","); 1253 return false; 1254 } 1255 yylex(); 1256 1257 expression_ast *__node_28 = 0; 1258 if (!parse_expression(&__node_28)) 1259 { 1260 yy_expected_symbol(ast_node::Kind_expression, "expression"); 1261 return false; 1262 } 1263 (*yynode)->argument_sequence = snoc((*yynode)->argument_sequence, __node_28, memory_pool); 1264 1265 } 1266 } 1267 else if (true /*epsilon*/) 1268 {} 1269 else 1270 { 1271 return false; 1272 } 1273 if (yytoken != Token_RPAREN) 1274 { 1275 yy_expected_token(yytoken, Token_RPAREN, ")"); 1276 return false; 1277 } 1278 yylex(); 1279 1280 } 1281 else if (yytoken == Token_IDENTIFIER) 1282 { 1283 if (yytoken != Token_IDENTIFIER) 1284 { 1285 yy_expected_token(yytoken, Token_IDENTIFIER, "identifier"); 1286 return false; 1287 } 1288 (*yynode)->variable = token_stream->index() - 1; 1289 yylex(); 1290 1291 } 1292 else if (yytoken == Token_INTEGER) 1293 { 1294 if (yytoken != Token_INTEGER) 1295 { 1296 yy_expected_token(yytoken, Token_INTEGER, "integer literal"); 1297 return false; 1298 } 1299 (*yynode)->integer_literal = token_stream->index() - 1; 1300 yylex(); 1301 1302 } 1303 else if (yytoken == Token_STRING) 1304 { 1305 if (yytoken != Token_STRING) 1306 { 1307 yy_expected_token(yytoken, Token_STRING, "string literal"); 1308 return false; 1309 } 1310 (*yynode)->string_literal = token_stream->index() - 1; 1311 yylex(); 1312 1313 } 1314 else if (yytoken == Token_TRUE) 1315 { 1316 if (yytoken != Token_TRUE) 1317 { 1318 yy_expected_token(yytoken, Token_TRUE, "true"); 1319 return false; 1320 } 1321 (*yynode)->true_literal = token_stream->index() - 1; 1322 yylex(); 1323 1324 } 1325 else if (yytoken == Token_FALSE) 1326 { 1327 if (yytoken != Token_FALSE) 1328 { 1329 yy_expected_token(yytoken, Token_FALSE, "false"); 1330 return false; 1331 } 1332 (*yynode)->false_literal = token_stream->index() - 1; 1333 yylex(); 1334 1335 } 1336 else if (yytoken == Token_NEW) 1337 { 1338 if (yytoken != Token_NEW) 1339 { 1340 yy_expected_token(yytoken, Token_NEW, "new"); 1341 return false; 1342 } 1343 yylex(); 1344 1345 if (yytoken != Token_TYPE) 1346 { 1347 yy_expected_token(yytoken, Token_TYPE, "type specification"); 1348 return false; 1349 } 1350 (*yynode)->new_type = token_stream->index() - 1; 1351 yylex(); 1352 1353 } 1354 else if (yytoken == Token_LPAREN) 1355 { 1356 if (yytoken != Token_LPAREN) 1357 { 1358 yy_expected_token(yytoken, Token_LPAREN, "("); 1359 return false; 1360 } 1361 yylex(); 1362 1363 expression_ast *__node_29 = 0; 1364 if (!parse_expression(&__node_29)) 1365 { 1366 yy_expected_symbol(ast_node::Kind_expression, "expression"); 1367 return false; 1368 } 1369 (*yynode)->expression = __node_29; 1370 1371 if (yytoken != Token_RPAREN) 1372 { 1373 yy_expected_token(yytoken, Token_RPAREN, ")"); 1374 return false; 1375 } 1376 yylex(); 1377 1378 } 1379 else if (yytoken == Token_IF) 1380 { 1381 if_expression_ast *__node_30 = 0; 1382 if (!parse_if_expression(&__node_30)) 1383 { 1384 yy_expected_symbol(ast_node::Kind_if_expression, "if_expression"); 1385 return false; 1386 } 1387 (*yynode)->if_expression = __node_30; 1388 1389 } 1390 else if (yytoken == Token_WHILE) 1391 { 1392 while_expression_ast *__node_31 = 0; 1393 if (!parse_while_expression(&__node_31)) 1394 { 1395 yy_expected_symbol(ast_node::Kind_while_expression, "while_expression"); 1396 return false; 1397 } 1398 (*yynode)->while_expression = __node_31; 1399 1400 } 1401 else if (yytoken == Token_LBRACE) 1402 { 1403 block_expression_ast *__node_32 = 0; 1404 if (!parse_block_expression(&__node_32)) 1405 { 1406 yy_expected_symbol(ast_node::Kind_block_expression, "block_expression"); 1407 return false; 1408 } 1409 (*yynode)->block_expression = __node_32; 1410 1411 } 1412 else if (yytoken == Token_LET) 1413 { 1414 let_expression_ast *__node_33 = 0; 1415 if (!parse_let_expression(&__node_33)) 1416 { 1417 yy_expected_symbol(ast_node::Kind_let_expression, "let_expression"); 1418 return false; 1419 } 1420 (*yynode)->let_expression = __node_33; 1421 1422 } 1423 else if (yytoken == Token_CASE) 1424 { 1425 case_expression_ast *__node_34 = 0; 1426 if (!parse_case_expression(&__node_34)) 1427 { 1428 yy_expected_symbol(ast_node::Kind_case_expression, "case_expression"); 1429 return false; 1430 } 1431 (*yynode)->case_expression = __node_34; 1432 1433 } 1434 else 1435 { 1436 return false; 1437 } 1438 } 1439 else 1440 { 1441 return false; 1442 } 1443 1444 (*yynode)->end_token = token_stream->index() - 1; 1445 1446 return true; 1447 } 1448 parse_program(program_ast ** yynode)1449 bool parser::parse_program(program_ast **yynode) 1450 { 1451 *yynode = create<program_ast>(); 1452 1453 (*yynode)->start_token = token_stream->index() - 1; 1454 1455 if (yytoken == Token_CLASS || yytoken == Token_EOF) 1456 { 1457 while (yytoken == Token_CLASS) 1458 { 1459 class_ast *__node_35 = 0; 1460 if (!parse_class(&__node_35)) 1461 { 1462 yy_expected_symbol(ast_node::Kind_class, "class"); 1463 return false; 1464 } 1465 (*yynode)->klass_sequence = snoc((*yynode)->klass_sequence, __node_35, memory_pool); 1466 1467 if (yytoken != Token_SEMICOLON) 1468 { 1469 yy_expected_token(yytoken, Token_SEMICOLON, ";"); 1470 return false; 1471 } 1472 yylex(); 1473 1474 } 1475 if (Token_EOF != yytoken) 1476 { 1477 return false; 1478 } 1479 } 1480 else 1481 { 1482 return false; 1483 } 1484 1485 (*yynode)->end_token = token_stream->index() - 1; 1486 1487 return true; 1488 } 1489 parse_relational_expression(relational_expression_ast ** yynode)1490 bool parser::parse_relational_expression(relational_expression_ast **yynode) 1491 { 1492 *yynode = create<relational_expression_ast>(); 1493 1494 (*yynode)->start_token = token_stream->index() - 1; 1495 1496 if (yytoken == Token_NEW 1497 || yytoken == Token_IF 1498 || yytoken == Token_WHILE 1499 || yytoken == Token_LET 1500 || yytoken == Token_CASE 1501 || yytoken == Token_LPAREN 1502 || yytoken == Token_LBRACE 1503 || yytoken == Token_TILDE 1504 || yytoken == Token_NOT 1505 || yytoken == Token_ISVOID 1506 || yytoken == Token_IDENTIFIER 1507 || yytoken == Token_INTEGER 1508 || yytoken == Token_STRING 1509 || yytoken == Token_TRUE 1510 || yytoken == Token_FALSE) 1511 { 1512 additive_expression_ast *__node_36 = 0; 1513 if (!parse_additive_expression(&__node_36)) 1514 { 1515 yy_expected_symbol(ast_node::Kind_additive_expression, "additive_expression"); 1516 return false; 1517 } 1518 (*yynode)->expression_sequence = snoc((*yynode)->expression_sequence, __node_36, memory_pool); 1519 1520 while (yytoken == Token_EQUAL 1521 || yytoken == Token_LESS_EQUAL 1522 || yytoken == Token_LESS) 1523 { 1524 if (yytoken == Token_EQUAL) 1525 { 1526 if (yytoken != Token_EQUAL) 1527 { 1528 yy_expected_token(yytoken, Token_EQUAL, "="); 1529 return false; 1530 } 1531 (*yynode)->op = token_stream->index() - 1; 1532 yylex(); 1533 1534 } 1535 else if (yytoken == Token_LESS_EQUAL) 1536 { 1537 if (yytoken != Token_LESS_EQUAL) 1538 { 1539 yy_expected_token(yytoken, Token_LESS_EQUAL, "<="); 1540 return false; 1541 } 1542 (*yynode)->op = token_stream->index() - 1; 1543 yylex(); 1544 1545 } 1546 else if (yytoken == Token_LESS) 1547 { 1548 if (yytoken != Token_LESS) 1549 { 1550 yy_expected_token(yytoken, Token_LESS, "<"); 1551 return false; 1552 } 1553 (*yynode)->op = token_stream->index() - 1; 1554 yylex(); 1555 1556 } 1557 else 1558 { 1559 return false; 1560 } 1561 additive_expression_ast *__node_37 = 0; 1562 if (!parse_additive_expression(&__node_37)) 1563 { 1564 yy_expected_symbol(ast_node::Kind_additive_expression, "additive_expression"); 1565 return false; 1566 } 1567 (*yynode)->expression_sequence = snoc((*yynode)->expression_sequence, __node_37, memory_pool); 1568 1569 } 1570 } 1571 else 1572 { 1573 return false; 1574 } 1575 1576 (*yynode)->end_token = token_stream->index() - 1; 1577 1578 return true; 1579 } 1580 parse_unary_expression(unary_expression_ast ** yynode)1581 bool parser::parse_unary_expression(unary_expression_ast **yynode) 1582 { 1583 *yynode = create<unary_expression_ast>(); 1584 1585 (*yynode)->start_token = token_stream->index() - 1; 1586 1587 if (yytoken == Token_NEW 1588 || yytoken == Token_IF 1589 || yytoken == Token_WHILE 1590 || yytoken == Token_LET 1591 || yytoken == Token_CASE 1592 || yytoken == Token_LPAREN 1593 || yytoken == Token_LBRACE 1594 || yytoken == Token_TILDE 1595 || yytoken == Token_NOT 1596 || yytoken == Token_ISVOID 1597 || yytoken == Token_IDENTIFIER 1598 || yytoken == Token_INTEGER 1599 || yytoken == Token_STRING 1600 || yytoken == Token_TRUE 1601 || yytoken == Token_FALSE) 1602 { 1603 if (yytoken == Token_TILDE) 1604 { 1605 if (yytoken != Token_TILDE) 1606 { 1607 yy_expected_token(yytoken, Token_TILDE, "~"); 1608 return false; 1609 } 1610 (*yynode)->op = token_stream->index() - 1; 1611 yylex(); 1612 1613 primary_expression_ast *__node_38 = 0; 1614 if (!parse_primary_expression(&__node_38)) 1615 { 1616 yy_expected_symbol(ast_node::Kind_primary_expression, "primary_expression"); 1617 return false; 1618 } 1619 (*yynode)->expression = __node_38; 1620 1621 } 1622 else if (yytoken == Token_NOT) 1623 { 1624 if (yytoken != Token_NOT) 1625 { 1626 yy_expected_token(yytoken, Token_NOT, "not"); 1627 return false; 1628 } 1629 (*yynode)->op = token_stream->index() - 1; 1630 yylex(); 1631 1632 primary_expression_ast *__node_39 = 0; 1633 if (!parse_primary_expression(&__node_39)) 1634 { 1635 yy_expected_symbol(ast_node::Kind_primary_expression, "primary_expression"); 1636 return false; 1637 } 1638 (*yynode)->expression = __node_39; 1639 1640 } 1641 else if (yytoken == Token_ISVOID) 1642 { 1643 if (yytoken != Token_ISVOID) 1644 { 1645 yy_expected_token(yytoken, Token_ISVOID, "isvoid"); 1646 return false; 1647 } 1648 (*yynode)->op = token_stream->index() - 1; 1649 yylex(); 1650 1651 primary_expression_ast *__node_40 = 0; 1652 if (!parse_primary_expression(&__node_40)) 1653 { 1654 yy_expected_symbol(ast_node::Kind_primary_expression, "primary_expression"); 1655 return false; 1656 } 1657 (*yynode)->expression = __node_40; 1658 1659 } 1660 else if (yytoken == Token_NEW 1661 || yytoken == Token_IF 1662 || yytoken == Token_WHILE 1663 || yytoken == Token_LET 1664 || yytoken == Token_CASE 1665 || yytoken == Token_LPAREN 1666 || yytoken == Token_LBRACE 1667 || yytoken == Token_IDENTIFIER 1668 || yytoken == Token_INTEGER 1669 || yytoken == Token_STRING 1670 || yytoken == Token_TRUE 1671 || yytoken == Token_FALSE) 1672 { 1673 primary_expression_ast *__node_41 = 0; 1674 if (!parse_primary_expression(&__node_41)) 1675 { 1676 yy_expected_symbol(ast_node::Kind_primary_expression, "primary_expression"); 1677 return false; 1678 } 1679 (*yynode)->expression = __node_41; 1680 1681 } 1682 else 1683 { 1684 return false; 1685 } 1686 } 1687 else 1688 { 1689 return false; 1690 } 1691 1692 (*yynode)->end_token = token_stream->index() - 1; 1693 1694 return true; 1695 } 1696 parse_while_expression(while_expression_ast ** yynode)1697 bool parser::parse_while_expression(while_expression_ast **yynode) 1698 { 1699 *yynode = create<while_expression_ast>(); 1700 1701 (*yynode)->start_token = token_stream->index() - 1; 1702 1703 if (yytoken == Token_WHILE) 1704 { 1705 if (yytoken != Token_WHILE) 1706 { 1707 yy_expected_token(yytoken, Token_WHILE, "while"); 1708 return false; 1709 } 1710 yylex(); 1711 1712 expression_ast *__node_42 = 0; 1713 if (!parse_expression(&__node_42)) 1714 { 1715 yy_expected_symbol(ast_node::Kind_expression, "expression"); 1716 return false; 1717 } 1718 (*yynode)->condition = __node_42; 1719 1720 if (yytoken != Token_LOOP) 1721 { 1722 yy_expected_token(yytoken, Token_LOOP, "loop"); 1723 return false; 1724 } 1725 yylex(); 1726 1727 expression_ast *__node_43 = 0; 1728 if (!parse_expression(&__node_43)) 1729 { 1730 yy_expected_symbol(ast_node::Kind_expression, "expression"); 1731 return false; 1732 } 1733 (*yynode)->loop_expression = __node_43; 1734 1735 if (yytoken != Token_POOL) 1736 { 1737 yy_expected_token(yytoken, Token_POOL, "pool"); 1738 return false; 1739 } 1740 yylex(); 1741 1742 } 1743 else 1744 { 1745 return false; 1746 } 1747 1748 (*yynode)->end_token = token_stream->index() - 1; 1749 1750 return true; 1751 } 1752 1753 1754 } // end of namespace cool 1755 1756 1757