File indexing completed on 2024-05-05 04:37:07
0001 // THIS FILE IS GENERATED 0002 // WARNING! All changes made in this file will be lost! 0003 0004 #include "cool_parser.h" 0005 0006 0007 #include "cool_lexer.h" 0008 0009 0010 namespace cool 0011 { 0012 0013 void parser::tokenize( char *contents ) 0014 { 0015 Lexer lexer( this, contents ); 0016 0017 int kind = parser::Token_EOF; 0018 do 0019 { 0020 kind = lexer.yylex(); 0021 //std::cerr << lexer.YYText() << std::endl; //" "; // debug output 0022 0023 if ( !kind ) // when the lexer returns 0, the end of file is reached 0024 kind = parser::Token_EOF; 0025 0026 parser::token_type &t = this->token_stream->next(); 0027 t.kind = kind; 0028 t.begin = lexer.tokenBegin(); 0029 t.end = lexer.tokenEnd(); 0030 t.text = contents; 0031 } 0032 while ( kind != parser::Token_EOF ); 0033 0034 this->yylex(); // produce the look ahead token 0035 } 0036 0037 } // end of namespace cool 0038 0039 0040 namespace cool 0041 { 0042 0043 bool parser::parse_additive_expression(additive_expression_ast **yynode) 0044 { 0045 *yynode = create<additive_expression_ast>(); 0046 0047 (*yynode)->start_token = token_stream->index() - 1; 0048 0049 if (yytoken == Token_NEW 0050 || yytoken == Token_IF 0051 || yytoken == Token_WHILE 0052 || yytoken == Token_LET 0053 || yytoken == Token_CASE 0054 || yytoken == Token_LPAREN 0055 || yytoken == Token_LBRACE 0056 || yytoken == Token_TILDE 0057 || yytoken == Token_NOT 0058 || yytoken == Token_ISVOID 0059 || yytoken == Token_IDENTIFIER 0060 || yytoken == Token_INTEGER 0061 || yytoken == Token_STRING 0062 || yytoken == Token_TRUE 0063 || yytoken == Token_FALSE) 0064 { 0065 multiplicative_expression_ast *__node_0 = 0; 0066 if (!parse_multiplicative_expression(&__node_0)) 0067 { 0068 yy_expected_symbol(ast_node::Kind_multiplicative_expression, "multiplicative_expression"); 0069 return false; 0070 } 0071 (*yynode)->expression_sequence = snoc((*yynode)->expression_sequence, __node_0, memory_pool); 0072 0073 while (yytoken == Token_PLUS 0074 || yytoken == Token_MINUS) 0075 { 0076 if (yytoken == Token_PLUS) 0077 { 0078 if (yytoken != Token_PLUS) 0079 { 0080 yy_expected_token(yytoken, Token_PLUS, "+"); 0081 return false; 0082 } 0083 (*yynode)->op = token_stream->index() - 1; 0084 yylex(); 0085 0086 } 0087 else if (yytoken == Token_MINUS) 0088 { 0089 if (yytoken != Token_MINUS) 0090 { 0091 yy_expected_token(yytoken, Token_MINUS, "-"); 0092 return false; 0093 } 0094 (*yynode)->op = token_stream->index() - 1; 0095 yylex(); 0096 0097 } 0098 else 0099 { 0100 return false; 0101 } 0102 multiplicative_expression_ast *__node_1 = 0; 0103 if (!parse_multiplicative_expression(&__node_1)) 0104 { 0105 yy_expected_symbol(ast_node::Kind_multiplicative_expression, "multiplicative_expression"); 0106 return false; 0107 } 0108 (*yynode)->expression_sequence = snoc((*yynode)->expression_sequence, __node_1, memory_pool); 0109 0110 } 0111 } 0112 else 0113 { 0114 return false; 0115 } 0116 0117 (*yynode)->end_token = token_stream->index() - 1; 0118 0119 return true; 0120 } 0121 0122 bool parser::parse_block_expression(block_expression_ast **yynode) 0123 { 0124 *yynode = create<block_expression_ast>(); 0125 0126 (*yynode)->start_token = token_stream->index() - 1; 0127 0128 if (yytoken == Token_LBRACE) 0129 { 0130 if (yytoken != Token_LBRACE) 0131 { 0132 yy_expected_token(yytoken, Token_LBRACE, "{"); 0133 return false; 0134 } 0135 yylex(); 0136 0137 while (yytoken == Token_NEW 0138 || yytoken == Token_IF 0139 || yytoken == Token_WHILE 0140 || yytoken == Token_LET 0141 || yytoken == Token_CASE 0142 || yytoken == Token_LPAREN 0143 || yytoken == Token_LBRACE 0144 || yytoken == Token_TILDE 0145 || yytoken == Token_NOT 0146 || yytoken == Token_ISVOID 0147 || yytoken == Token_IDENTIFIER 0148 || yytoken == Token_INTEGER 0149 || yytoken == Token_STRING 0150 || yytoken == Token_TRUE 0151 || yytoken == Token_FALSE) 0152 { 0153 expression_ast *__node_2 = 0; 0154 if (!parse_expression(&__node_2)) 0155 { 0156 yy_expected_symbol(ast_node::Kind_expression, "expression"); 0157 return false; 0158 } 0159 (*yynode)->expression_sequence = snoc((*yynode)->expression_sequence, __node_2, memory_pool); 0160 0161 if (yytoken != Token_SEMICOLON) 0162 { 0163 yy_expected_token(yytoken, Token_SEMICOLON, ";"); 0164 return false; 0165 } 0166 yylex(); 0167 0168 } 0169 if (yytoken != Token_RBRACE) 0170 { 0171 yy_expected_token(yytoken, Token_RBRACE, "}"); 0172 return false; 0173 } 0174 yylex(); 0175 0176 } 0177 else 0178 { 0179 return false; 0180 } 0181 0182 (*yynode)->end_token = token_stream->index() - 1; 0183 0184 return true; 0185 } 0186 0187 bool parser::parse_case_condition(case_condition_ast **yynode) 0188 { 0189 *yynode = create<case_condition_ast>(); 0190 0191 (*yynode)->start_token = token_stream->index() - 1; 0192 0193 if (yytoken == Token_IDENTIFIER) 0194 { 0195 if (yytoken != Token_IDENTIFIER) 0196 { 0197 yy_expected_token(yytoken, Token_IDENTIFIER, "identifier"); 0198 return false; 0199 } 0200 (*yynode)->name = token_stream->index() - 1; 0201 yylex(); 0202 0203 if (yytoken != Token_COLON) 0204 { 0205 yy_expected_token(yytoken, Token_COLON, ":"); 0206 return false; 0207 } 0208 yylex(); 0209 0210 if (yytoken != Token_TYPE) 0211 { 0212 yy_expected_token(yytoken, Token_TYPE, "type specification"); 0213 return false; 0214 } 0215 (*yynode)->type = token_stream->index() - 1; 0216 yylex(); 0217 0218 if (yytoken != Token_ARROW_RIGHT) 0219 { 0220 yy_expected_token(yytoken, Token_ARROW_RIGHT, "=>"); 0221 return false; 0222 } 0223 yylex(); 0224 0225 expression_ast *__node_3 = 0; 0226 if (!parse_expression(&__node_3)) 0227 { 0228 yy_expected_symbol(ast_node::Kind_expression, "expression"); 0229 return false; 0230 } 0231 (*yynode)->expression = __node_3; 0232 0233 } 0234 else 0235 { 0236 return false; 0237 } 0238 0239 (*yynode)->end_token = token_stream->index() - 1; 0240 0241 return true; 0242 } 0243 0244 bool parser::parse_case_expression(case_expression_ast **yynode) 0245 { 0246 *yynode = create<case_expression_ast>(); 0247 0248 (*yynode)->start_token = token_stream->index() - 1; 0249 0250 if (yytoken == Token_CASE) 0251 { 0252 if (yytoken != Token_CASE) 0253 { 0254 yy_expected_token(yytoken, Token_CASE, "case"); 0255 return false; 0256 } 0257 yylex(); 0258 0259 expression_ast *__node_4 = 0; 0260 if (!parse_expression(&__node_4)) 0261 { 0262 yy_expected_symbol(ast_node::Kind_expression, "expression"); 0263 return false; 0264 } 0265 (*yynode)->expression = __node_4; 0266 0267 if (yytoken != Token_OF) 0268 { 0269 yy_expected_token(yytoken, Token_OF, "of"); 0270 return false; 0271 } 0272 yylex(); 0273 0274 while (yytoken == Token_IDENTIFIER) 0275 { 0276 case_condition_ast *__node_5 = 0; 0277 if (!parse_case_condition(&__node_5)) 0278 { 0279 yy_expected_symbol(ast_node::Kind_case_condition, "case_condition"); 0280 return false; 0281 } 0282 (*yynode)->condition_sequence = snoc((*yynode)->condition_sequence, __node_5, memory_pool); 0283 0284 if (yytoken != Token_SEMICOLON) 0285 { 0286 yy_expected_token(yytoken, Token_SEMICOLON, ";"); 0287 return false; 0288 } 0289 yylex(); 0290 0291 } 0292 if (yytoken != Token_ESAC) 0293 { 0294 yy_expected_token(yytoken, Token_ESAC, "esac"); 0295 return false; 0296 } 0297 yylex(); 0298 0299 } 0300 else 0301 { 0302 return false; 0303 } 0304 0305 (*yynode)->end_token = token_stream->index() - 1; 0306 0307 return true; 0308 } 0309 0310 bool parser::parse_class(class_ast **yynode) 0311 { 0312 *yynode = create<class_ast>(); 0313 0314 (*yynode)->start_token = token_stream->index() - 1; 0315 0316 if (yytoken == Token_CLASS) 0317 { 0318 if (yytoken != Token_CLASS) 0319 { 0320 yy_expected_token(yytoken, Token_CLASS, "class"); 0321 return false; 0322 } 0323 yylex(); 0324 0325 if (yytoken != Token_TYPE) 0326 { 0327 yy_expected_token(yytoken, Token_TYPE, "type specification"); 0328 return false; 0329 } 0330 (*yynode)->type = token_stream->index() - 1; 0331 yylex(); 0332 0333 if (yytoken == Token_INHERITS) 0334 { 0335 if (yytoken != Token_INHERITS) 0336 { 0337 yy_expected_token(yytoken, Token_INHERITS, "inherits"); 0338 return false; 0339 } 0340 yylex(); 0341 0342 if (yytoken != Token_TYPE) 0343 { 0344 yy_expected_token(yytoken, Token_TYPE, "type specification"); 0345 return false; 0346 } 0347 (*yynode)->base_type = token_stream->index() - 1; 0348 yylex(); 0349 0350 } 0351 else if (true /*epsilon*/) 0352 {} 0353 else 0354 { 0355 return false; 0356 } 0357 if (yytoken != Token_LBRACE) 0358 { 0359 yy_expected_token(yytoken, Token_LBRACE, "{"); 0360 return false; 0361 } 0362 yylex(); 0363 0364 while (yytoken == Token_IDENTIFIER) 0365 { 0366 feature_ast *__node_6 = 0; 0367 if (!parse_feature(&__node_6)) 0368 { 0369 yy_expected_symbol(ast_node::Kind_feature, "feature"); 0370 return false; 0371 } 0372 (*yynode)->feature_sequence = snoc((*yynode)->feature_sequence, __node_6, memory_pool); 0373 0374 if (yytoken != Token_SEMICOLON) 0375 { 0376 yy_expected_token(yytoken, Token_SEMICOLON, ";"); 0377 return false; 0378 } 0379 yylex(); 0380 0381 } 0382 if (yytoken != Token_RBRACE) 0383 { 0384 yy_expected_token(yytoken, Token_RBRACE, "}"); 0385 return false; 0386 } 0387 yylex(); 0388 0389 } 0390 else 0391 { 0392 return false; 0393 } 0394 0395 (*yynode)->end_token = token_stream->index() - 1; 0396 0397 return true; 0398 } 0399 0400 bool parser::parse_expression(expression_ast **yynode) 0401 { 0402 *yynode = create<expression_ast>(); 0403 0404 (*yynode)->start_token = token_stream->index() - 1; 0405 0406 if (yytoken == Token_NEW 0407 || yytoken == Token_IF 0408 || yytoken == Token_WHILE 0409 || yytoken == Token_LET 0410 || yytoken == Token_CASE 0411 || yytoken == Token_LPAREN 0412 || yytoken == Token_LBRACE 0413 || yytoken == Token_TILDE 0414 || yytoken == Token_NOT 0415 || yytoken == Token_ISVOID 0416 || yytoken == Token_IDENTIFIER 0417 || yytoken == Token_INTEGER 0418 || yytoken == Token_STRING 0419 || yytoken == Token_TRUE 0420 || yytoken == Token_FALSE) 0421 { 0422 relational_expression_ast *__node_7 = 0; 0423 if (!parse_relational_expression(&__node_7)) 0424 { 0425 yy_expected_symbol(ast_node::Kind_relational_expression, "relational_expression"); 0426 return false; 0427 } 0428 (*yynode)->expression = __node_7; 0429 0430 } 0431 else 0432 { 0433 return false; 0434 } 0435 0436 (*yynode)->end_token = token_stream->index() - 1; 0437 0438 return true; 0439 } 0440 0441 bool parser::parse_feature(feature_ast **yynode) 0442 { 0443 *yynode = create<feature_ast>(); 0444 0445 (*yynode)->start_token = token_stream->index() - 1; 0446 0447 if (yytoken == Token_IDENTIFIER) 0448 { 0449 if ((yytoken == Token_IDENTIFIER) && ( LA(2).kind == Token_LPAREN )) 0450 { 0451 if (yytoken != Token_IDENTIFIER) 0452 { 0453 yy_expected_token(yytoken, Token_IDENTIFIER, "identifier"); 0454 return false; 0455 } 0456 (*yynode)->name = token_stream->index() - 1; 0457 yylex(); 0458 0459 if (yytoken != Token_LPAREN) 0460 { 0461 yy_expected_token(yytoken, Token_LPAREN, "("); 0462 return false; 0463 } 0464 yylex(); 0465 0466 if (yytoken == Token_IDENTIFIER) 0467 { 0468 formal_ast *__node_8 = 0; 0469 if (!parse_formal(&__node_8)) 0470 { 0471 yy_expected_symbol(ast_node::Kind_formal, "formal"); 0472 return false; 0473 } 0474 (*yynode)->formal_sequence = snoc((*yynode)->formal_sequence, __node_8, memory_pool); 0475 0476 while (yytoken == Token_COMMA) 0477 { 0478 if (yytoken != Token_COMMA) 0479 { 0480 yy_expected_token(yytoken, Token_COMMA, ","); 0481 return false; 0482 } 0483 yylex(); 0484 0485 formal_ast *__node_9 = 0; 0486 if (!parse_formal(&__node_9)) 0487 { 0488 yy_expected_symbol(ast_node::Kind_formal, "formal"); 0489 return false; 0490 } 0491 (*yynode)->formal_sequence = snoc((*yynode)->formal_sequence, __node_9, memory_pool); 0492 0493 } 0494 } 0495 else if (true /*epsilon*/) 0496 {} 0497 else 0498 { 0499 return false; 0500 } 0501 if (yytoken != Token_RPAREN) 0502 { 0503 yy_expected_token(yytoken, Token_RPAREN, ")"); 0504 return false; 0505 } 0506 yylex(); 0507 0508 if (yytoken != Token_COLON) 0509 { 0510 yy_expected_token(yytoken, Token_COLON, ":"); 0511 return false; 0512 } 0513 yylex(); 0514 0515 if (yytoken != Token_TYPE) 0516 { 0517 yy_expected_token(yytoken, Token_TYPE, "type specification"); 0518 return false; 0519 } 0520 (*yynode)->type = token_stream->index() - 1; 0521 yylex(); 0522 0523 if (yytoken != Token_LBRACE) 0524 { 0525 yy_expected_token(yytoken, Token_LBRACE, "{"); 0526 return false; 0527 } 0528 yylex(); 0529 0530 expression_ast *__node_10 = 0; 0531 if (!parse_expression(&__node_10)) 0532 { 0533 yy_expected_symbol(ast_node::Kind_expression, "expression"); 0534 return false; 0535 } 0536 (*yynode)->expression = __node_10; 0537 0538 if (yytoken != Token_RBRACE) 0539 { 0540 yy_expected_token(yytoken, Token_RBRACE, "}"); 0541 return false; 0542 } 0543 yylex(); 0544 0545 } 0546 else if (yytoken == Token_IDENTIFIER) 0547 { 0548 if (yytoken != Token_IDENTIFIER) 0549 { 0550 yy_expected_token(yytoken, Token_IDENTIFIER, "identifier"); 0551 return false; 0552 } 0553 (*yynode)->name = token_stream->index() - 1; 0554 yylex(); 0555 0556 if (yytoken != Token_COLON) 0557 { 0558 yy_expected_token(yytoken, Token_COLON, ":"); 0559 return false; 0560 } 0561 yylex(); 0562 0563 if (yytoken != Token_TYPE) 0564 { 0565 yy_expected_token(yytoken, Token_TYPE, "type specification"); 0566 return false; 0567 } 0568 (*yynode)->type = token_stream->index() - 1; 0569 yylex(); 0570 0571 if (yytoken == Token_ARROW_LEFT) 0572 { 0573 if (yytoken != Token_ARROW_LEFT) 0574 { 0575 yy_expected_token(yytoken, Token_ARROW_LEFT, "<-"); 0576 return false; 0577 } 0578 yylex(); 0579 0580 expression_ast *__node_11 = 0; 0581 if (!parse_expression(&__node_11)) 0582 { 0583 yy_expected_symbol(ast_node::Kind_expression, "expression"); 0584 return false; 0585 } 0586 (*yynode)->expression = __node_11; 0587 0588 } 0589 else if (true /*epsilon*/) 0590 {} 0591 else 0592 { 0593 return false; 0594 } 0595 } 0596 else 0597 { 0598 return false; 0599 } 0600 } 0601 else 0602 { 0603 return false; 0604 } 0605 0606 (*yynode)->end_token = token_stream->index() - 1; 0607 0608 return true; 0609 } 0610 0611 bool parser::parse_formal(formal_ast **yynode) 0612 { 0613 *yynode = create<formal_ast>(); 0614 0615 (*yynode)->start_token = token_stream->index() - 1; 0616 0617 if (yytoken == Token_IDENTIFIER) 0618 { 0619 if (yytoken != Token_IDENTIFIER) 0620 { 0621 yy_expected_token(yytoken, Token_IDENTIFIER, "identifier"); 0622 return false; 0623 } 0624 (*yynode)->name = token_stream->index() - 1; 0625 yylex(); 0626 0627 if (yytoken != Token_COLON) 0628 { 0629 yy_expected_token(yytoken, Token_COLON, ":"); 0630 return false; 0631 } 0632 yylex(); 0633 0634 if (yytoken != Token_TYPE) 0635 { 0636 yy_expected_token(yytoken, Token_TYPE, "type specification"); 0637 return false; 0638 } 0639 (*yynode)->type = token_stream->index() - 1; 0640 yylex(); 0641 0642 } 0643 else 0644 { 0645 return false; 0646 } 0647 0648 (*yynode)->end_token = token_stream->index() - 1; 0649 0650 return true; 0651 } 0652 0653 bool parser::parse_if_expression(if_expression_ast **yynode) 0654 { 0655 *yynode = create<if_expression_ast>(); 0656 0657 (*yynode)->start_token = token_stream->index() - 1; 0658 0659 if (yytoken == Token_IF) 0660 { 0661 if (yytoken != Token_IF) 0662 { 0663 yy_expected_token(yytoken, Token_IF, "if"); 0664 return false; 0665 } 0666 yylex(); 0667 0668 expression_ast *__node_12 = 0; 0669 if (!parse_expression(&__node_12)) 0670 { 0671 yy_expected_symbol(ast_node::Kind_expression, "expression"); 0672 return false; 0673 } 0674 (*yynode)->condition = __node_12; 0675 0676 if (yytoken != Token_THEN) 0677 { 0678 yy_expected_token(yytoken, Token_THEN, "then"); 0679 return false; 0680 } 0681 yylex(); 0682 0683 expression_ast *__node_13 = 0; 0684 if (!parse_expression(&__node_13)) 0685 { 0686 yy_expected_symbol(ast_node::Kind_expression, "expression"); 0687 return false; 0688 } 0689 (*yynode)->true_expression = __node_13; 0690 0691 if (yytoken != Token_ELSE) 0692 { 0693 yy_expected_token(yytoken, Token_ELSE, "else"); 0694 return false; 0695 } 0696 yylex(); 0697 0698 expression_ast *__node_14 = 0; 0699 if (!parse_expression(&__node_14)) 0700 { 0701 yy_expected_symbol(ast_node::Kind_expression, "expression"); 0702 return false; 0703 } 0704 (*yynode)->false_expression = __node_14; 0705 0706 if (yytoken != Token_FI) 0707 { 0708 yy_expected_token(yytoken, Token_FI, "fi"); 0709 return false; 0710 } 0711 yylex(); 0712 0713 } 0714 else 0715 { 0716 return false; 0717 } 0718 0719 (*yynode)->end_token = token_stream->index() - 1; 0720 0721 return true; 0722 } 0723 0724 bool parser::parse_let_declaration(let_declaration_ast **yynode) 0725 { 0726 *yynode = create<let_declaration_ast>(); 0727 0728 (*yynode)->start_token = token_stream->index() - 1; 0729 0730 if (yytoken == Token_IDENTIFIER) 0731 { 0732 if (yytoken != Token_IDENTIFIER) 0733 { 0734 yy_expected_token(yytoken, Token_IDENTIFIER, "identifier"); 0735 return false; 0736 } 0737 (*yynode)->name = token_stream->index() - 1; 0738 yylex(); 0739 0740 if (yytoken != Token_COLON) 0741 { 0742 yy_expected_token(yytoken, Token_COLON, ":"); 0743 return false; 0744 } 0745 yylex(); 0746 0747 if (yytoken != Token_TYPE) 0748 { 0749 yy_expected_token(yytoken, Token_TYPE, "type specification"); 0750 return false; 0751 } 0752 (*yynode)->type = token_stream->index() - 1; 0753 yylex(); 0754 0755 if (yytoken == Token_ARROW_LEFT) 0756 { 0757 if (yytoken != Token_ARROW_LEFT) 0758 { 0759 yy_expected_token(yytoken, Token_ARROW_LEFT, "<-"); 0760 return false; 0761 } 0762 yylex(); 0763 0764 expression_ast *__node_15 = 0; 0765 if (!parse_expression(&__node_15)) 0766 { 0767 yy_expected_symbol(ast_node::Kind_expression, "expression"); 0768 return false; 0769 } 0770 (*yynode)->expression = __node_15; 0771 0772 } 0773 else if (true /*epsilon*/) 0774 {} 0775 else 0776 { 0777 return false; 0778 } 0779 } 0780 else 0781 { 0782 return false; 0783 } 0784 0785 (*yynode)->end_token = token_stream->index() - 1; 0786 0787 return true; 0788 } 0789 0790 bool parser::parse_let_expression(let_expression_ast **yynode) 0791 { 0792 *yynode = create<let_expression_ast>(); 0793 0794 (*yynode)->start_token = token_stream->index() - 1; 0795 0796 if (yytoken == Token_LET) 0797 { 0798 if (yytoken != Token_LET) 0799 { 0800 yy_expected_token(yytoken, Token_LET, "let"); 0801 return false; 0802 } 0803 yylex(); 0804 0805 let_declaration_ast *__node_16 = 0; 0806 if (!parse_let_declaration(&__node_16)) 0807 { 0808 yy_expected_symbol(ast_node::Kind_let_declaration, "let_declaration"); 0809 return false; 0810 } 0811 (*yynode)->declaration_sequence = snoc((*yynode)->declaration_sequence, __node_16, memory_pool); 0812 0813 while (yytoken == Token_COMMA) 0814 { 0815 if (yytoken != Token_COMMA) 0816 { 0817 yy_expected_token(yytoken, Token_COMMA, ","); 0818 return false; 0819 } 0820 yylex(); 0821 0822 let_declaration_ast *__node_17 = 0; 0823 if (!parse_let_declaration(&__node_17)) 0824 { 0825 yy_expected_symbol(ast_node::Kind_let_declaration, "let_declaration"); 0826 return false; 0827 } 0828 (*yynode)->declaration_sequence = snoc((*yynode)->declaration_sequence, __node_17, memory_pool); 0829 0830 } 0831 if (yytoken != Token_IN) 0832 { 0833 yy_expected_token(yytoken, Token_IN, "in"); 0834 return false; 0835 } 0836 yylex(); 0837 0838 expression_ast *__node_18 = 0; 0839 if (!parse_expression(&__node_18)) 0840 { 0841 yy_expected_symbol(ast_node::Kind_expression, "expression"); 0842 return false; 0843 } 0844 (*yynode)->body_expression = __node_18; 0845 0846 } 0847 else 0848 { 0849 return false; 0850 } 0851 0852 (*yynode)->end_token = token_stream->index() - 1; 0853 0854 return true; 0855 } 0856 0857 bool parser::parse_multiplicative_expression(multiplicative_expression_ast **yynode) 0858 { 0859 *yynode = create<multiplicative_expression_ast>(); 0860 0861 (*yynode)->start_token = token_stream->index() - 1; 0862 0863 if (yytoken == Token_NEW 0864 || yytoken == Token_IF 0865 || yytoken == Token_WHILE 0866 || yytoken == Token_LET 0867 || yytoken == Token_CASE 0868 || yytoken == Token_LPAREN 0869 || yytoken == Token_LBRACE 0870 || yytoken == Token_TILDE 0871 || yytoken == Token_NOT 0872 || yytoken == Token_ISVOID 0873 || yytoken == Token_IDENTIFIER 0874 || yytoken == Token_INTEGER 0875 || yytoken == Token_STRING 0876 || yytoken == Token_TRUE 0877 || yytoken == Token_FALSE) 0878 { 0879 postfix_expression_ast *__node_19 = 0; 0880 if (!parse_postfix_expression(&__node_19)) 0881 { 0882 yy_expected_symbol(ast_node::Kind_postfix_expression, "postfix_expression"); 0883 return false; 0884 } 0885 (*yynode)->expression_sequence = snoc((*yynode)->expression_sequence, __node_19, memory_pool); 0886 0887 while (yytoken == Token_STAR 0888 || yytoken == Token_SLASH) 0889 { 0890 if (yytoken == Token_STAR) 0891 { 0892 if (yytoken != Token_STAR) 0893 { 0894 yy_expected_token(yytoken, Token_STAR, "*"); 0895 return false; 0896 } 0897 (*yynode)->op = token_stream->index() - 1; 0898 yylex(); 0899 0900 } 0901 else if (yytoken == Token_SLASH) 0902 { 0903 if (yytoken != Token_SLASH) 0904 { 0905 yy_expected_token(yytoken, Token_SLASH, "/"); 0906 return false; 0907 } 0908 (*yynode)->op = token_stream->index() - 1; 0909 yylex(); 0910 0911 } 0912 else 0913 { 0914 return false; 0915 } 0916 postfix_expression_ast *__node_20 = 0; 0917 if (!parse_postfix_expression(&__node_20)) 0918 { 0919 yy_expected_symbol(ast_node::Kind_postfix_expression, "postfix_expression"); 0920 return false; 0921 } 0922 (*yynode)->expression_sequence = snoc((*yynode)->expression_sequence, __node_20, memory_pool); 0923 0924 } 0925 } 0926 else 0927 { 0928 return false; 0929 } 0930 0931 (*yynode)->end_token = token_stream->index() - 1; 0932 0933 return true; 0934 } 0935 0936 bool parser::parse_postfix_expression(postfix_expression_ast **yynode) 0937 { 0938 *yynode = create<postfix_expression_ast>(); 0939 0940 (*yynode)->start_token = token_stream->index() - 1; 0941 0942 if (yytoken == Token_NEW 0943 || yytoken == Token_IF 0944 || yytoken == Token_WHILE 0945 || yytoken == Token_LET 0946 || yytoken == Token_CASE 0947 || yytoken == Token_LPAREN 0948 || yytoken == Token_LBRACE 0949 || yytoken == Token_TILDE 0950 || yytoken == Token_NOT 0951 || yytoken == Token_ISVOID 0952 || yytoken == Token_IDENTIFIER 0953 || yytoken == Token_INTEGER 0954 || yytoken == Token_STRING 0955 || yytoken == Token_TRUE 0956 || yytoken == Token_FALSE) 0957 { 0958 unary_expression_ast *__node_21 = 0; 0959 if (!parse_unary_expression(&__node_21)) 0960 { 0961 yy_expected_symbol(ast_node::Kind_unary_expression, "unary_expression"); 0962 return false; 0963 } 0964 (*yynode)->base_expression = __node_21; 0965 0966 while (yytoken == Token_DOT 0967 || yytoken == Token_AT) 0968 { 0969 if (yytoken == Token_AT) 0970 { 0971 if (yytoken != Token_AT) 0972 { 0973 yy_expected_token(yytoken, Token_AT, "@"); 0974 return false; 0975 } 0976 yylex(); 0977 0978 if (yytoken != Token_TYPE) 0979 { 0980 yy_expected_token(yytoken, Token_TYPE, "type specification"); 0981 return false; 0982 } 0983 (*yynode)->at_type = token_stream->index() - 1; 0984 yylex(); 0985 0986 if (yytoken != Token_DOT) 0987 { 0988 yy_expected_token(yytoken, Token_DOT, "."); 0989 return false; 0990 } 0991 yylex(); 0992 0993 if (yytoken != Token_IDENTIFIER) 0994 { 0995 yy_expected_token(yytoken, Token_IDENTIFIER, "identifier"); 0996 return false; 0997 } 0998 (*yynode)->name = token_stream->index() - 1; 0999 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 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 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 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 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 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