1 /* 2 * Copyright (c) Freescale Semiconductor, Inc. All rights reserved. 3 * See included license file for license details. 4 */ 5 6 /* write header with token defines */ 7 %defines 8 9 /* make it reentrant */ 10 %pure-parser 11 12 /* put more info in error messages */ 13 %error-verbose 14 15 /* enable location processing */ 16 %locations 17 18 %{ 19 #include "ElftosbLexer.h" 20 #include "ElftosbAST.h" 21 #include "Logging.h" 22 #include "Blob.h" 23 #include "format_string.h" 24 #include "Value.h" 25 #include "ConversionController.h" 26 27 using namespace elftosb; 28 29 //! Our special location type. 30 #define YYLTYPE token_loc_t 31 32 // this indicates that we're using our own type. it should be unset automatically 33 // but that's not working for some reason with the .hpp file. 34 #if defined(YYLTYPE_IS_TRIVIAL) 35 #undef YYLTYPE_IS_TRIVIAL 36 #define YYLTYPE_IS_TRIVIAL 0 37 #endif 38 39 //! Default location action 40 #define YYLLOC_DEFAULT(Current, Rhs, N) \ 41 do { \ 42 if (N) \ 43 { \ 44 (Current).m_firstLine = YYRHSLOC(Rhs, 1).m_firstLine; \ 45 (Current).m_lastLine = YYRHSLOC(Rhs, N).m_lastLine; \ 46 } \ 47 else \ 48 { \ 49 (Current).m_firstLine = (Current).m_lastLine = YYRHSLOC(Rhs, 0).m_lastLine; \ 50 } \ 51 } while (0) 52 53 //! Forward declaration of yylex(). 54 static int yylex(YYSTYPE * lvalp, YYLTYPE * yylloc, ElftosbLexer * lexer); 55 56 // Forward declaration of error handling function. 57 static void yyerror(YYLTYPE * yylloc, ElftosbLexer * lexer, CommandFileASTNode ** resultAST, const char * error); 58 59 %} 60 61 /* symbol types */ 62 %union { 63 int m_num; 64 elftosb::SizedIntegerValue * m_int; 65 Blob * m_blob; 66 std::string * m_str; 67 elftosb::ASTNode * m_ast; // must use full name here because this is put into *.tab.hpp 68 } 69 70 /* extra parameters for the parser and lexer */ 71 %parse-param {ElftosbLexer * lexer} 72 %parse-param {CommandFileASTNode ** resultAST} 73 %lex-param {ElftosbLexer * lexer} 74 75 /* token definitions */ 76 %token <m_str> TOK_IDENT "identifier" 77 %token <m_str> TOK_STRING_LITERAL "string" 78 %token <m_int> TOK_INT_LITERAL "integer" 79 %token <m_str> TOK_SECTION_NAME "section name" 80 %token <m_str> TOK_SOURCE_NAME "source name" 81 %token <m_blob> TOK_BLOB "binary object" 82 %token '(' 83 %token ')' 84 %token '{' 85 %token '}' 86 %token '[' 87 %token ']' 88 %token '=' 89 %token ',' 90 %token ';' 91 %token ':' 92 %token '>' 93 %token '.' 94 %token TOK_DOT_DOT ".." 95 %token '~' 96 %token '&' 97 %token '|' 98 %token '<' 99 %token '>' 100 %token '!' 101 %token TOK_AND "&&" 102 %token TOK_OR "||" 103 %token TOK_GEQ ">=" 104 %token TOK_LEQ "<=" 105 %token TOK_EQ "==" 106 %token TOK_NEQ "!=" 107 %token TOK_POWER "**" 108 %token TOK_LSHIFT "<<" 109 %token TOK_RSHIFT ">>" 110 %token <m_int> TOK_INT_SIZE "integer size" 111 %token TOK_OPTIONS "options" 112 %token TOK_CONSTANTS "constants" 113 %token TOK_SOURCES "sources" 114 %token TOK_FILTERS "filters" 115 %token TOK_SECTION "section" 116 %token TOK_EXTERN "extern" 117 %token TOK_FROM "from" 118 %token TOK_RAW "raw" 119 %token TOK_LOAD "load" 120 %token TOK_JUMP "jump" 121 %token TOK_CALL "call" 122 %token TOK_MODE "mode" 123 %token TOK_IF "if" 124 %token TOK_ELSE "else" 125 %token TOK_DEFINED "defined" 126 %token TOK_INFO "info" 127 %token TOK_WARNING "warning" 128 %token TOK_ERROR "error" 129 %token TOK_SIZEOF "sizeof" 130 %token TOK_DCD "dcd" 131 %token TOK_HAB "hab" 132 %token TOK_IVT "ivt" 133 134 /* operator precedence */ 135 %left "&&" "||" 136 %left '>' '<' ">=" "<=" "==" "!=" 137 %left '|' 138 %left '^' 139 %left '&' 140 %left "<<" ">>" 141 %left "**" 142 %left '+' '-' 143 %left '*' '/' '%' 144 %left '.' 145 %right UNARY_OP 146 147 /* nonterminal types - most nonterminal symbols are subclasses of ASTNode */ 148 %type <m_ast> command_file blocks_list pre_section_block options_block const_def_list const_def_list_elem 149 %type <m_ast> const_def const_expr expr int_const_expr unary_expr int_value constants_block 150 %type <m_ast> sources_block source_def_list source_def_list_elem source_def 151 %type <m_ast> section_defs section_def section_contents full_stmt_list full_stmt_list_elem 152 %type <m_ast> basic_stmt load_stmt call_stmt from_stmt load_data load_target call_target 153 %type <m_ast> address_or_range load_target_opt call_arg_opt basic_stmt_list basic_stmt_list_elem 154 %type <m_ast> source_attr_list source_attr_list_elem source_attrs_opt 155 %type <m_ast> section_list section_list_elem symbol_ref mode_stmt 156 %type <m_ast> section_options_opt source_attr_list_opt 157 %type <m_ast> if_stmt else_opt message_stmt 158 %type <m_ast> bool_expr ivt_def assignment_list_opt 159 160 %type <m_num> call_or_jump dcd_opt 161 162 %destructor { delete $$; } TOK_IDENT TOK_STRING_LITERAL TOK_SECTION_NAME TOK_SOURCE_NAME TOK_BLOB TOK_INT_SIZE TOK_INT_LITERAL 163 164 %% 165 166 command_file : blocks_list section_defs 167 { 168 CommandFileASTNode * commandFile = new CommandFileASTNode(); 169 commandFile->setBlocks(dynamic_cast<ListASTNode*>($1)); 170 commandFile->setSections(dynamic_cast<ListASTNode*>($2)); 171 commandFile->setLocation(@1, @2); 172 *resultAST = commandFile; 173 } 174 ; 175 176 blocks_list : pre_section_block 177 { 178 ListASTNode * list = new ListASTNode(); 179 list->appendNode($1); 180 $$ = list; 181 } 182 | blocks_list pre_section_block 183 { 184 dynamic_cast<ListASTNode*>($1)->appendNode($2); 185 $$ = $1; 186 } 187 ; 188 189 pre_section_block 190 : options_block { $$ = $1; } 191 | constants_block { $$ = $1; } 192 | sources_block { $$ = $1; } 193 ; 194 195 options_block : "options" '{' const_def_list '}' 196 { 197 $$ = new OptionsBlockASTNode(dynamic_cast<ListASTNode *>($3)); 198 } 199 ; 200 201 constants_block : "constants" '{' const_def_list '}' 202 { 203 $$ = new ConstantsBlockASTNode(dynamic_cast<ListASTNode *>($3)); 204 } 205 ; 206 207 const_def_list : const_def_list_elem 208 { 209 ListASTNode * list = new ListASTNode(); 210 list->appendNode($1); 211 $$ = list; 212 } 213 | const_def_list const_def_list_elem 214 { 215 dynamic_cast<ListASTNode*>($1)->appendNode($2); 216 $$ = $1; 217 } 218 ; 219 220 const_def_list_elem : const_def ';' { $$ = $1; } 221 | /* empty */ { $$ = NULL; } 222 ; 223 224 const_def : TOK_IDENT '=' const_expr 225 { 226 $$ = new AssignmentASTNode($1, $3); 227 $$->setLocation(@1, @3); 228 } 229 ; 230 231 sources_block : "sources" '{' source_def_list '}' 232 { 233 $$ = new SourcesBlockASTNode(dynamic_cast<ListASTNode *>($3)); 234 } 235 ; 236 237 source_def_list : source_def_list_elem 238 { 239 ListASTNode * list = new ListASTNode(); 240 list->appendNode($1); 241 $$ = list; 242 } 243 | source_def_list source_def_list_elem 244 { 245 dynamic_cast<ListASTNode*>($1)->appendNode($2); 246 $$ = $1; 247 } 248 ; 249 250 source_def_list_elem 251 : source_def source_attrs_opt ';' 252 { 253 // tell the lexer that this is the name of a source file 254 SourceDefASTNode * node = dynamic_cast<SourceDefASTNode*>($1); 255 if ($2) 256 { 257 node->setAttributes(dynamic_cast<ListASTNode*>($2)); 258 } 259 node->setLocation(node->getLocation(), @3); 260 lexer->addSourceName(node->getName()); 261 $$ = $1; 262 } 263 | /* empty */ { $$ = NULL; } 264 ; 265 266 source_def : TOK_IDENT '=' TOK_STRING_LITERAL 267 { 268 $$ = new PathSourceDefASTNode($1, $3); 269 $$->setLocation(@1, @3); 270 } 271 | TOK_IDENT '=' "extern" '(' int_const_expr ')' 272 { 273 $$ = new ExternSourceDefASTNode($1, dynamic_cast<ExprASTNode*>($5)); 274 $$->setLocation(@1, @6); 275 } 276 ; 277 278 source_attrs_opt 279 : '(' source_attr_list ')' { $$ = $2; } 280 | /* empty */ { $$ = NULL; } 281 ; 282 283 source_attr_list 284 : source_attr_list_elem 285 { 286 ListASTNode * list = new ListASTNode(); 287 list->appendNode($1); 288 $$ = list; 289 } 290 | source_attr_list ',' source_attr_list_elem 291 { 292 dynamic_cast<ListASTNode*>($1)->appendNode($3); 293 $$ = $1; 294 } 295 ; 296 297 source_attr_list_elem 298 : TOK_IDENT '=' const_expr 299 { 300 $$ = new AssignmentASTNode($1, $3); 301 $$->setLocation(@1, @3); 302 } 303 ; 304 305 section_defs : section_def 306 { 307 ListASTNode * list = new ListASTNode(); 308 list->appendNode($1); 309 $$ = list; 310 } 311 | section_defs section_def 312 { 313 dynamic_cast<ListASTNode*>($1)->appendNode($2); 314 $$ = $1; 315 } 316 ; 317 318 section_def : "section" '(' int_const_expr section_options_opt ')' section_contents 319 { 320 SectionContentsASTNode * sectionNode = dynamic_cast<SectionContentsASTNode*>($6); 321 if (sectionNode) 322 { 323 ExprASTNode * exprNode = dynamic_cast<ExprASTNode*>($3); 324 sectionNode->setSectionNumberExpr(exprNode); 325 sectionNode->setOptions(dynamic_cast<ListASTNode*>($4)); 326 sectionNode->setLocation(@1, sectionNode->getLocation()); 327 } 328 $$ = $6; 329 } 330 ; 331 332 section_options_opt 333 : ';' source_attr_list_opt 334 { 335 $$ = $2; 336 } 337 | /* empty */ 338 { 339 $$ = NULL; 340 } 341 ; 342 343 source_attr_list_opt 344 : source_attr_list 345 { 346 $$ = $1; 347 } 348 | /* empty */ 349 { 350 $$ = NULL; 351 } 352 ; 353 354 section_contents 355 : "<=" load_data ';' 356 { 357 DataSectionContentsASTNode * dataSection = new DataSectionContentsASTNode($2); 358 dataSection->setLocation(@1, @3); 359 $$ = dataSection; 360 } 361 | '{' full_stmt_list '}' 362 { 363 ListASTNode * listNode = dynamic_cast<ListASTNode*>($2); 364 $$ = new BootableSectionContentsASTNode(listNode); 365 $$->setLocation(@1, @3); 366 } 367 ; 368 369 full_stmt_list : full_stmt_list_elem 370 { 371 ListASTNode * list = new ListASTNode(); 372 list->appendNode($1); 373 $$ = list; 374 } 375 | full_stmt_list full_stmt_list_elem 376 { 377 dynamic_cast<ListASTNode*>($1)->appendNode($2); 378 $$ = $1; 379 } 380 ; 381 382 full_stmt_list_elem 383 : basic_stmt ';' { $$ = $1; } 384 | from_stmt { $$ = $1; } 385 | if_stmt { $$ = $1; } 386 | /* empty */ { $$ = NULL; } 387 ; 388 389 basic_stmt_list : basic_stmt_list_elem 390 { 391 ListASTNode * list = new ListASTNode(); 392 list->appendNode($1); 393 $$ = list; 394 } 395 | basic_stmt_list basic_stmt_list_elem 396 { 397 dynamic_cast<ListASTNode*>($1)->appendNode($2); 398 $$ = $1; 399 } 400 ; 401 402 basic_stmt_list_elem 403 : basic_stmt ';' { $$ = $1; } 404 | if_stmt { $$ = $1; } 405 | /* empty */ { $$ = NULL; } 406 ; 407 408 basic_stmt : load_stmt { $$ = $1; } 409 | call_stmt { $$ = $1; } 410 | mode_stmt { $$ = $1; } 411 | message_stmt { $$ = $1; } 412 ; 413 414 load_stmt : "load" dcd_opt load_data load_target_opt 415 { 416 LoadStatementASTNode * stmt = new LoadStatementASTNode(); 417 stmt->setData($3); 418 stmt->setTarget($4); 419 // set dcd load flag if the "dcd" keyword was present. 420 if ($2) 421 { 422 stmt->setDCDLoad(true); 423 } 424 // set char locations for the statement 425 if ($4) 426 { 427 stmt->setLocation(@1, @4); 428 } 429 else 430 { 431 stmt->setLocation(@1, @3); 432 } 433 $$ = stmt; 434 } 435 ; 436 437 dcd_opt : "dcd" 438 { 439 if (!elftosb::g_enableHABSupport) 440 { 441 yyerror(&yylloc, lexer, resultAST, "HAB features not supported with the selected family"); 442 YYABORT; 443 } 444 445 $$ = 1; 446 } 447 | /* empty */ { $$ = 0; } 448 449 load_data : int_const_expr 450 { 451 $$ = $1; 452 } 453 | TOK_STRING_LITERAL 454 { 455 $$ = new StringConstASTNode($1); 456 $$->setLocation(@1); 457 } 458 | TOK_SOURCE_NAME 459 { 460 $$ = new SourceASTNode($1); 461 $$->setLocation(@1); 462 } 463 | section_list 464 { 465 $$ = new SectionMatchListASTNode(dynamic_cast<ListASTNode*>($1)); 466 $$->setLocation(@1); 467 } 468 | section_list "from" TOK_SOURCE_NAME 469 { 470 $$ = new SectionMatchListASTNode(dynamic_cast<ListASTNode*>($1), $3); 471 $$->setLocation(@1, @3); 472 } 473 | TOK_SOURCE_NAME '[' section_list ']' 474 { 475 $$ = new SectionMatchListASTNode(dynamic_cast<ListASTNode*>($3), $1); 476 $$->setLocation(@1, @4); 477 } 478 | TOK_BLOB 479 { 480 $$ = new BlobConstASTNode($1); 481 $$->setLocation(@1); 482 } 483 | ivt_def 484 { 485 } 486 ; 487 488 section_list : section_list_elem 489 { 490 ListASTNode * list = new ListASTNode(); 491 list->appendNode($1); 492 $$ = list; 493 } 494 | section_list ',' section_list_elem 495 { 496 dynamic_cast<ListASTNode*>($1)->appendNode($3); 497 $$ = $1; 498 } 499 ; 500 501 section_list_elem 502 : TOK_SECTION_NAME 503 { 504 $$ = new SectionASTNode($1, SectionASTNode::kInclude); 505 $$->setLocation(@1); 506 } 507 | '~' TOK_SECTION_NAME 508 { 509 $$ = new SectionASTNode($2, SectionASTNode::kExclude); 510 $$->setLocation(@1, @2); 511 } 512 ; 513 514 load_target_opt : '>' load_target 515 { 516 $$ = $2; 517 } 518 | /* empty */ 519 { 520 $$ = new NaturalLocationASTNode(); 521 // $$->setLocation(); 522 } 523 ; 524 525 load_target : '.' 526 { 527 $$ = new NaturalLocationASTNode(); 528 $$->setLocation(@1); 529 } 530 | address_or_range 531 { 532 $$ = $1; 533 } 534 ; 535 536 ivt_def : "ivt" '(' assignment_list_opt ')' 537 { 538 IVTConstASTNode * ivt = new IVTConstASTNode(); 539 if ($3) 540 { 541 ivt->setFieldAssignments(dynamic_cast<ListASTNode*>($3)); 542 } 543 ivt->setLocation(@1, @4); 544 $$ = ivt; 545 } 546 ; 547 548 assignment_list_opt : source_attr_list { $$ = $1; } 549 | /* empty */ { $$ = NULL; } 550 ; 551 552 call_stmt : call_or_jump call_target call_arg_opt 553 { 554 CallStatementASTNode * stmt = new CallStatementASTNode(); 555 switch ($1) 556 { 557 case 1: 558 stmt->setCallType(CallStatementASTNode::kCallType); 559 break; 560 case 2: 561 stmt->setCallType(CallStatementASTNode::kJumpType); 562 break; 563 default: 564 yyerror(&yylloc, lexer, resultAST, "invalid call_or_jump value"); 565 YYABORT; 566 break; 567 } 568 stmt->setTarget($2); 569 stmt->setArgument($3); 570 stmt->setIsHAB(false); 571 if ($3) 572 { 573 stmt->setLocation(@1, @3); 574 } 575 else 576 { 577 stmt->setLocation(@1, @2); 578 } 579 $$ = stmt; 580 } 581 | "hab" call_or_jump address_or_range call_arg_opt 582 { 583 if (!elftosb::g_enableHABSupport) 584 { 585 yyerror(&yylloc, lexer, resultAST, "HAB features not supported with the selected family"); 586 YYABORT; 587 } 588 589 CallStatementASTNode * stmt = new CallStatementASTNode(); 590 switch ($2) 591 { 592 case 1: 593 stmt->setCallType(CallStatementASTNode::kCallType); 594 break; 595 case 2: 596 stmt->setCallType(CallStatementASTNode::kJumpType); 597 break; 598 default: 599 yyerror(&yylloc, lexer, resultAST, "invalid call_or_jump value"); 600 YYABORT; 601 break; 602 } 603 stmt->setTarget($3); 604 stmt->setArgument($4); 605 stmt->setIsHAB(true); 606 if ($4) 607 { 608 stmt->setLocation(@1, @4); 609 } 610 else 611 { 612 stmt->setLocation(@1, @3); 613 } 614 $$ = stmt; 615 } 616 ; 617 618 call_or_jump : "call" { $$ = 1; } 619 | "jump" { $$ = 2; } 620 ; 621 622 call_target : TOK_SOURCE_NAME 623 { 624 $$ = new SymbolASTNode(NULL, $1); 625 $$->setLocation(@1); 626 } 627 | int_const_expr 628 { 629 $$ = new AddressRangeASTNode($1, NULL); 630 $$->setLocation($1); 631 } 632 ; 633 634 call_arg_opt : '(' int_const_expr ')' { $$ = $2; } 635 | '(' ')' { $$ = NULL; } 636 | /* empty */ { $$ = NULL; } 637 ; 638 639 from_stmt : "from" TOK_SOURCE_NAME '{' basic_stmt_list '}' 640 { 641 $$ = new FromStatementASTNode($2, dynamic_cast<ListASTNode*>($4)); 642 $$->setLocation(@1, @5); 643 } 644 ; 645 646 mode_stmt : "mode" int_const_expr 647 { 648 $$ = new ModeStatementASTNode(dynamic_cast<ExprASTNode*>($2)); 649 $$->setLocation(@1, @2); 650 } 651 ; 652 653 message_stmt : "info" TOK_STRING_LITERAL 654 { 655 $$ = new MessageStatementASTNode(MessageStatementASTNode::kInfo, $2); 656 $$->setLocation(@1, @2); 657 } 658 | "warning" TOK_STRING_LITERAL 659 { 660 $$ = new MessageStatementASTNode(MessageStatementASTNode::kWarning, $2); 661 $$->setLocation(@1, @2); 662 } 663 | "error" TOK_STRING_LITERAL 664 { 665 $$ = new MessageStatementASTNode(MessageStatementASTNode::kError, $2); 666 $$->setLocation(@1, @2); 667 } 668 ; 669 670 if_stmt : "if" bool_expr '{' full_stmt_list '}' else_opt 671 { 672 IfStatementASTNode * ifStmt = new IfStatementASTNode(); 673 ifStmt->setConditionExpr(dynamic_cast<ExprASTNode*>($2)); 674 ifStmt->setIfStatements(dynamic_cast<ListASTNode*>($4)); 675 ifStmt->setElseStatements(dynamic_cast<ListASTNode*>($6)); 676 ifStmt->setLocation(@1, @6); 677 $$ = ifStmt; 678 } 679 ; 680 681 else_opt : "else" '{' full_stmt_list '}' 682 { 683 $$ = $3; 684 } 685 | "else" if_stmt 686 { 687 ListASTNode * list = new ListASTNode(); 688 list->appendNode($2); 689 $$ = list; 690 $$->setLocation(@1, @2); 691 } 692 | /* empty */ { $$ = NULL; } 693 ; 694 695 address_or_range : int_const_expr 696 { 697 $$ = new AddressRangeASTNode($1, NULL); 698 $$->setLocation($1); 699 } 700 | int_const_expr ".." int_const_expr 701 { 702 $$ = new AddressRangeASTNode($1, $3); 703 $$->setLocation(@1, @3); 704 } 705 ; 706 707 const_expr : bool_expr 708 { 709 $$ = $1; 710 } 711 | TOK_STRING_LITERAL 712 { 713 $$ = new StringConstASTNode($1); 714 $$->setLocation(@1); 715 } 716 ; 717 718 bool_expr : int_const_expr 719 { 720 $$ = $1; 721 } 722 | bool_expr '<' bool_expr 723 { 724 ExprASTNode * left = dynamic_cast<ExprASTNode*>($1); 725 ExprASTNode * right = dynamic_cast<ExprASTNode*>($3); 726 $$ = new BinaryOpExprASTNode(left, BinaryOpExprASTNode::kLessThan, right); 727 $$->setLocation(@1, @3); 728 } 729 | bool_expr '>' bool_expr 730 { 731 ExprASTNode * left = dynamic_cast<ExprASTNode*>($1); 732 ExprASTNode * right = dynamic_cast<ExprASTNode*>($3); 733 $$ = new BinaryOpExprASTNode(left, BinaryOpExprASTNode::kGreaterThan, right); 734 $$->setLocation(@1, @3); 735 } 736 | bool_expr ">=" bool_expr 737 { 738 ExprASTNode * left = dynamic_cast<ExprASTNode*>($1); 739 ExprASTNode * right = dynamic_cast<ExprASTNode*>($3); 740 $$ = new BinaryOpExprASTNode(left, BinaryOpExprASTNode::kGreaterThanEqual, right); 741 $$->setLocation(@1, @3); 742 } 743 | bool_expr "<=" bool_expr 744 { 745 ExprASTNode * left = dynamic_cast<ExprASTNode*>($1); 746 ExprASTNode * right = dynamic_cast<ExprASTNode*>($3); 747 $$ = new BinaryOpExprASTNode(left, BinaryOpExprASTNode::kLessThanEqual, right); 748 $$->setLocation(@1, @3); 749 } 750 | bool_expr "==" bool_expr 751 { 752 ExprASTNode * left = dynamic_cast<ExprASTNode*>($1); 753 ExprASTNode * right = dynamic_cast<ExprASTNode*>($3); 754 $$ = new BinaryOpExprASTNode(left, BinaryOpExprASTNode::kEqual, right); 755 $$->setLocation(@1, @3); 756 } 757 | bool_expr "!=" bool_expr 758 { 759 ExprASTNode * left = dynamic_cast<ExprASTNode*>($1); 760 ExprASTNode * right = dynamic_cast<ExprASTNode*>($3); 761 $$ = new BinaryOpExprASTNode(left, BinaryOpExprASTNode::kNotEqual, right); 762 $$->setLocation(@1, @3); 763 } 764 | bool_expr "&&" bool_expr 765 { 766 ExprASTNode * left = dynamic_cast<ExprASTNode*>($1); 767 ExprASTNode * right = dynamic_cast<ExprASTNode*>($3); 768 $$ = new BinaryOpExprASTNode(left, BinaryOpExprASTNode::kBooleanAnd, right); 769 $$->setLocation(@1, @3); 770 } 771 | bool_expr "||" bool_expr 772 { 773 ExprASTNode * left = dynamic_cast<ExprASTNode*>($1); 774 ExprASTNode * right = dynamic_cast<ExprASTNode*>($3); 775 $$ = new BinaryOpExprASTNode(left, BinaryOpExprASTNode::kBooleanOr, right); 776 $$->setLocation(@1, @3); 777 } 778 | '!' bool_expr %prec UNARY_OP 779 { 780 $$ = new BooleanNotExprASTNode(dynamic_cast<ExprASTNode*>($2)); 781 $$->setLocation(@1, @2); 782 } 783 | TOK_IDENT '(' TOK_SOURCE_NAME ')' 784 { 785 $$ = new SourceFileFunctionASTNode($1, $3); 786 $$->setLocation(@1, @4); 787 } 788 | '(' bool_expr ')' 789 { 790 $$ = $2; 791 $$->setLocation(@1, @3); 792 } 793 | "defined" '(' TOK_IDENT ')' 794 { 795 $$ = new DefinedOperatorASTNode($3); 796 $$->setLocation(@1, @4); 797 } 798 ; 799 800 int_const_expr : expr { $$ = $1; } 801 ; 802 803 symbol_ref : TOK_SOURCE_NAME ':' TOK_IDENT 804 { 805 $$ = new SymbolASTNode($3, $1); 806 $$->setLocation(@1, @3); 807 } 808 | ':' TOK_IDENT 809 { 810 $$ = new SymbolASTNode($2); 811 $$->setLocation(@1, @2); 812 } 813 ; 814 815 816 expr : int_value 817 { 818 $$ = $1; 819 } 820 | TOK_IDENT 821 { 822 $$ = new VariableExprASTNode($1); 823 $$->setLocation(@1); 824 } 825 | symbol_ref 826 { 827 $$ = new SymbolRefExprASTNode(dynamic_cast<SymbolASTNode*>($1)); 828 $$->setLocation(@1); 829 } 830 /* | expr '..' expr 831 { 832 ExprASTNode * left = dynamic_cast<ExprASTNode*>($1); 833 ExprASTNode * right = dynamic_cast<ExprASTNode*>($3); 834 $$ = new RangeExprASTNode(left, right); 835 } 836 */ | expr '+' expr 837 { 838 ExprASTNode * left = dynamic_cast<ExprASTNode*>($1); 839 ExprASTNode * right = dynamic_cast<ExprASTNode*>($3); 840 $$ = new BinaryOpExprASTNode(left, BinaryOpExprASTNode::kAdd, right); 841 $$->setLocation(@1, @3); 842 } 843 | expr '-' expr 844 { 845 ExprASTNode * left = dynamic_cast<ExprASTNode*>($1); 846 ExprASTNode * right = dynamic_cast<ExprASTNode*>($3); 847 $$ = new BinaryOpExprASTNode(left, BinaryOpExprASTNode::kSubtract, right); 848 $$->setLocation(@1, @3); 849 } 850 | expr '*' expr 851 { 852 ExprASTNode * left = dynamic_cast<ExprASTNode*>($1); 853 ExprASTNode * right = dynamic_cast<ExprASTNode*>($3); 854 $$ = new BinaryOpExprASTNode(left, BinaryOpExprASTNode::kMultiply, right); 855 $$->setLocation(@1, @3); 856 } 857 | expr '/' expr 858 { 859 ExprASTNode * left = dynamic_cast<ExprASTNode*>($1); 860 ExprASTNode * right = dynamic_cast<ExprASTNode*>($3); 861 $$ = new BinaryOpExprASTNode(left, BinaryOpExprASTNode::kDivide, right); 862 $$->setLocation(@1, @3); 863 } 864 | expr '%' expr 865 { 866 ExprASTNode * left = dynamic_cast<ExprASTNode*>($1); 867 ExprASTNode * right = dynamic_cast<ExprASTNode*>($3); 868 $$ = new BinaryOpExprASTNode(left, BinaryOpExprASTNode::kModulus, right); 869 $$->setLocation(@1, @3); 870 } 871 | expr "**" expr 872 { 873 ExprASTNode * left = dynamic_cast<ExprASTNode*>($1); 874 ExprASTNode * right = dynamic_cast<ExprASTNode*>($3); 875 $$ = new BinaryOpExprASTNode(left, BinaryOpExprASTNode::kPower, right); 876 $$->setLocation(@1, @3); 877 } 878 | expr '&' expr 879 { 880 ExprASTNode * left = dynamic_cast<ExprASTNode*>($1); 881 ExprASTNode * right = dynamic_cast<ExprASTNode*>($3); 882 $$ = new BinaryOpExprASTNode(left, BinaryOpExprASTNode::kBitwiseAnd, right); 883 $$->setLocation(@1, @3); 884 } 885 | expr '|' expr 886 { 887 ExprASTNode * left = dynamic_cast<ExprASTNode*>($1); 888 ExprASTNode * right = dynamic_cast<ExprASTNode*>($3); 889 $$ = new BinaryOpExprASTNode(left, BinaryOpExprASTNode::kBitwiseOr, right); 890 $$->setLocation(@1, @3); 891 } 892 | expr '^' expr 893 { 894 ExprASTNode * left = dynamic_cast<ExprASTNode*>($1); 895 ExprASTNode * right = dynamic_cast<ExprASTNode*>($3); 896 $$ = new BinaryOpExprASTNode(left, BinaryOpExprASTNode::kBitwiseXor, right); 897 $$->setLocation(@1, @3); 898 } 899 | expr "<<" expr 900 { 901 ExprASTNode * left = dynamic_cast<ExprASTNode*>($1); 902 ExprASTNode * right = dynamic_cast<ExprASTNode*>($3); 903 $$ = new BinaryOpExprASTNode(left, BinaryOpExprASTNode::kShiftLeft, right); 904 $$->setLocation(@1, @3); 905 } 906 | expr ">>" expr 907 { 908 ExprASTNode * left = dynamic_cast<ExprASTNode*>($1); 909 ExprASTNode * right = dynamic_cast<ExprASTNode*>($3); 910 $$ = new BinaryOpExprASTNode(left, BinaryOpExprASTNode::kShiftRight, right); 911 $$->setLocation(@1, @3); 912 } 913 | unary_expr 914 { 915 $$ = $1; 916 } 917 | expr '.' TOK_INT_SIZE 918 { 919 $$ = new IntSizeExprASTNode(dynamic_cast<ExprASTNode*>($1), $3->getWordSize()); 920 $$->setLocation(@1, @3); 921 } 922 | '(' expr ')' 923 { 924 $$ = $2; 925 $$->setLocation(@1, @3); 926 } 927 | "sizeof" '(' symbol_ref ')' 928 { 929 $$ = new SizeofOperatorASTNode(dynamic_cast<SymbolASTNode*>($3)); 930 $$->setLocation(@1, @4); 931 } 932 | "sizeof" '(' TOK_IDENT ')' 933 { 934 $$ = new SizeofOperatorASTNode($3); 935 $$->setLocation(@1, @4); 936 } 937 | "sizeof" '(' TOK_SOURCE_NAME ')' 938 { 939 $$ = new SizeofOperatorASTNode($3); 940 $$->setLocation(@1, @4); 941 } 942 ; 943 944 unary_expr : '+' expr %prec UNARY_OP 945 { 946 $$ = $2; 947 } 948 | '-' expr %prec UNARY_OP 949 { 950 $$ = new NegativeExprASTNode(dynamic_cast<ExprASTNode*>($2)); 951 $$->setLocation(@1, @2); 952 } 953 ; 954 955 int_value : TOK_INT_LITERAL 956 { 957 $$ = new IntConstExprASTNode($1->getValue(), $1->getWordSize()); 958 $$->setLocation(@1); 959 } 960 ; 961 962 %% 963 964 /* code goes here */ 965 966 static int yylex(YYSTYPE * lvalp, YYLTYPE * yylloc, ElftosbLexer * lexer) 967 { 968 int token = lexer->yylex(); 969 *yylloc = lexer->getLocation(); 970 lexer->getSymbolValue(lvalp); 971 return token; 972 } 973 974 static void yyerror(YYLTYPE * yylloc, ElftosbLexer * lexer, CommandFileASTNode ** resultAST, const char * error) 975 { 976 throw syntax_error(format_string("line %d: %s\n", yylloc->m_firstLine, error)); 977 } 978 979
Indexes created Wed Sep 16 00:24:39 UTC 2026