Commit 93083be80018fdba00b610a6a4ca68db7364d4f3
- Diff rendering mode:
- inline
- side by side
runtime/stackdgrammar.rb
(93 / 93)
| 24 | 24 | if r3 | |
| 25 | 25 | r1 = r3 | |
| 26 | 26 | else | |
| 27 | @index = i1 | ||
| 27 | self.index = i1 | ||
| 28 | 28 | r1 = nil | |
| 29 | 29 | end | |
| 30 | 30 | end | |
| … | … | ||
| 38 | 38 | ||
| 39 | 39 | node_cache[:program][start_index] = r0 | |
| 40 | 40 | ||
| 41 | r0 | ||
| 41 | return r0 | ||
| 42 | 42 | end | |
| 43 | 43 | ||
| 44 | 44 | module Expression0 | |
| … | … | ||
| 80 | 80 | if r6 | |
| 81 | 81 | r4 = r6 | |
| 82 | 82 | else | |
| 83 | @index = i4 | ||
| 83 | self.index = i4 | ||
| 84 | 84 | r4 = nil | |
| 85 | 85 | end | |
| 86 | 86 | end | |
| … | … | ||
| 91 | 91 | end | |
| 92 | 92 | end | |
| 93 | 93 | if s3.empty? | |
| 94 | @index = i3 | ||
| 94 | self.index = i3 | ||
| 95 | 95 | r3 = nil | |
| 96 | 96 | else | |
| 97 | 97 | r3 = instantiate_node(SyntaxNode,input, i3...index, s3) | |
| … | … | ||
| 119 | 119 | r0 = instantiate_node(Expression,input, i0...index, s0) | |
| 120 | 120 | r0.extend(Expression0) | |
| 121 | 121 | else | |
| 122 | @index = i0 | ||
| 122 | self.index = i0 | ||
| 123 | 123 | r0 = nil | |
| 124 | 124 | end | |
| 125 | 125 | ||
| 126 | 126 | node_cache[:expression][start_index] = r0 | |
| 127 | 127 | ||
| 128 | r0 | ||
| 128 | return r0 | ||
| 129 | 129 | end | |
| 130 | 130 | ||
| 131 | 131 | module Comment0 | |
| … | … | ||
| 155 | 155 | r1 = instantiate_node(SyntaxNode,input, i1...index, s1) | |
| 156 | 156 | s0 << r1 | |
| 157 | 157 | if r1 | |
| 158 | if has_terminal?("!", false, index) | ||
| 158 | if input.index("!", index) == index | ||
| 159 | 159 | r3 = instantiate_node(SyntaxNode,input, index...(index + 1)) | |
| 160 | 160 | @index += 1 | |
| 161 | 161 | else | |
| … | … | ||
| 168 | 168 | loop do | |
| 169 | 169 | i5, s5 = index, [] | |
| 170 | 170 | i6 = index | |
| 171 | if has_terminal?('\G[\\n]', true, index) | ||
| 171 | if input.index(Regexp.new('[\\n]'), index) == index | ||
| 172 | 172 | r7 = instantiate_node(SyntaxNode,input, index...(index + 1)) | |
| 173 | 173 | @index += 1 | |
| 174 | 174 | else | |
| … | … | ||
| 177 | 177 | if r7 | |
| 178 | 178 | r6 = nil | |
| 179 | 179 | else | |
| 180 | @index = i6 | ||
| 180 | self.index = i6 | ||
| 181 | 181 | r6 = instantiate_node(SyntaxNode,input, index...index) | |
| 182 | 182 | end | |
| 183 | 183 | s5 << r6 | |
| … | … | ||
| 195 | 195 | r5 = instantiate_node(SyntaxNode,input, i5...index, s5) | |
| 196 | 196 | r5.extend(Comment0) | |
| 197 | 197 | else | |
| 198 | @index = i5 | ||
| 198 | self.index = i5 | ||
| 199 | 199 | r5 = nil | |
| 200 | 200 | end | |
| 201 | 201 | if r5 | |
| … | … | ||
| 207 | 207 | r4 = instantiate_node(SyntaxNode,input, i4...index, s4) | |
| 208 | 208 | s0 << r4 | |
| 209 | 209 | if r4 | |
| 210 | if has_terminal?('\G[\\n]', true, index) | ||
| 210 | if input.index(Regexp.new('[\\n]'), index) == index | ||
| 211 | 211 | r10 = instantiate_node(SyntaxNode,input, index...(index + 1)) | |
| 212 | 212 | @index += 1 | |
| 213 | 213 | else | |
| … | … | ||
| 226 | 226 | r0 = instantiate_node(Comment,input, i0...index, s0) | |
| 227 | 227 | r0.extend(Comment1) | |
| 228 | 228 | else | |
| 229 | @index = i0 | ||
| 229 | self.index = i0 | ||
| 230 | 230 | r0 = nil | |
| 231 | 231 | end | |
| 232 | 232 | ||
| 233 | 233 | node_cache[:comment][start_index] = r0 | |
| 234 | 234 | ||
| 235 | r0 | ||
| 235 | return r0 | ||
| 236 | 236 | end | |
| 237 | 237 | ||
| 238 | 238 | module Atom0 | |
| … | … | ||
| 272 | 272 | if r5 | |
| 273 | 273 | r3 = r5 | |
| 274 | 274 | else | |
| 275 | @index = i3 | ||
| 275 | self.index = i3 | ||
| 276 | 276 | r3 = nil | |
| 277 | 277 | end | |
| 278 | 278 | end | |
| … | … | ||
| 295 | 295 | r0 = instantiate_node(Atom,input, i0...index, s0) | |
| 296 | 296 | r0.extend(Atom0) | |
| 297 | 297 | else | |
| 298 | @index = i0 | ||
| 298 | self.index = i0 | ||
| 299 | 299 | r0 = nil | |
| 300 | 300 | end | |
| 301 | 301 | ||
| 302 | 302 | node_cache[:atom][start_index] = r0 | |
| 303 | 303 | ||
| 304 | r0 | ||
| 304 | return r0 | ||
| 305 | 305 | end | |
| 306 | 306 | ||
| 307 | 307 | def _nt_datum | |
| … | … | ||
| 349 | 349 | if r9 | |
| 350 | 350 | r0 = r9 | |
| 351 | 351 | else | |
| 352 | @index = i0 | ||
| 352 | self.index = i0 | ||
| 353 | 353 | r0 = nil | |
| 354 | 354 | end | |
| 355 | 355 | end | |
| … | … | ||
| 363 | 363 | ||
| 364 | 364 | node_cache[:datum][start_index] = r0 | |
| 365 | 365 | ||
| 366 | r0 | ||
| 366 | return r0 | ||
| 367 | 367 | end | |
| 368 | 368 | ||
| 369 | 369 | module Boolean0 | |
| … | … | ||
| 379 | 379 | ||
| 380 | 380 | i0, s0 = index, [] | |
| 381 | 381 | i1 = index | |
| 382 | if has_terminal?("t", false, index) | ||
| 382 | if input.index("t", index) == index | ||
| 383 | 383 | r2 = instantiate_node(SyntaxNode,input, index...(index + 1)) | |
| 384 | 384 | @index += 1 | |
| 385 | 385 | else | |
| … | … | ||
| 389 | 389 | if r2 | |
| 390 | 390 | r1 = r2 | |
| 391 | 391 | else | |
| 392 | if has_terminal?("f", false, index) | ||
| 392 | if input.index("f", index) == index | ||
| 393 | 393 | r3 = instantiate_node(SyntaxNode,input, index...(index + 1)) | |
| 394 | 394 | @index += 1 | |
| 395 | 395 | else | |
| … | … | ||
| 399 | 399 | if r3 | |
| 400 | 400 | r1 = r3 | |
| 401 | 401 | else | |
| 402 | @index = i1 | ||
| 402 | self.index = i1 | ||
| 403 | 403 | r1 = nil | |
| 404 | 404 | end | |
| 405 | 405 | end | |
| … | … | ||
| 410 | 410 | if r5 | |
| 411 | 411 | r4 = nil | |
| 412 | 412 | else | |
| 413 | @index = i4 | ||
| 413 | self.index = i4 | ||
| 414 | 414 | r4 = instantiate_node(SyntaxNode,input, index...index) | |
| 415 | 415 | end | |
| 416 | 416 | s0 << r4 | |
| … | … | ||
| 419 | 419 | r0 = instantiate_node(Boolean,input, i0...index, s0) | |
| 420 | 420 | r0.extend(Boolean0) | |
| 421 | 421 | else | |
| 422 | @index = i0 | ||
| 422 | self.index = i0 | ||
| 423 | 423 | r0 = nil | |
| 424 | 424 | end | |
| 425 | 425 | ||
| 426 | 426 | node_cache[:boolean][start_index] = r0 | |
| 427 | 427 | ||
| 428 | r0 | ||
| 428 | return r0 | ||
| 429 | 429 | end | |
| 430 | 430 | ||
| 431 | 431 | module Integer0 | |
| … | … | ||
| 448 | 448 | i0, s0 = index, [] | |
| 449 | 449 | i1 = index | |
| 450 | 450 | i2, s2 = index, [] | |
| 451 | if has_terminal?("-", false, index) | ||
| 451 | if input.index("-", index) == index | ||
| 452 | 452 | r4 = instantiate_node(SyntaxNode,input, index...(index + 1)) | |
| 453 | 453 | @index += 1 | |
| 454 | 454 | else | |
| … | … | ||
| 462 | 462 | end | |
| 463 | 463 | s2 << r3 | |
| 464 | 464 | if r3 | |
| 465 | if has_terminal?("0", false, index) | ||
| 465 | if input.index("0", index) == index | ||
| 466 | 466 | r5 = instantiate_node(SyntaxNode,input, index...(index + 1)) | |
| 467 | 467 | @index += 1 | |
| 468 | 468 | else | |
| … | … | ||
| 475 | 475 | r2 = instantiate_node(SyntaxNode,input, i2...index, s2) | |
| 476 | 476 | r2.extend(Integer0) | |
| 477 | 477 | else | |
| 478 | @index = i2 | ||
| 478 | self.index = i2 | ||
| 479 | 479 | r2 = nil | |
| 480 | 480 | end | |
| 481 | 481 | if r2 | |
| 482 | 482 | r1 = r2 | |
| 483 | 483 | else | |
| 484 | 484 | i6, s6 = index, [] | |
| 485 | if has_terminal?("-", false, index) | ||
| 485 | if input.index("-", index) == index | ||
| 486 | 486 | r8 = instantiate_node(SyntaxNode,input, index...(index + 1)) | |
| 487 | 487 | @index += 1 | |
| 488 | 488 | else | |
| … | … | ||
| 496 | 496 | end | |
| 497 | 497 | s6 << r7 | |
| 498 | 498 | if r7 | |
| 499 | if has_terminal?('\G[1-9]', true, index) | ||
| 499 | if input.index(Regexp.new('[1-9]'), index) == index | ||
| 500 | 500 | r9 = instantiate_node(SyntaxNode,input, index...(index + 1)) | |
| 501 | 501 | @index += 1 | |
| 502 | 502 | else | |
| … | … | ||
| 506 | 506 | if r9 | |
| 507 | 507 | s10, i10 = [], index | |
| 508 | 508 | loop do | |
| 509 | if has_terminal?('\G[0-9]', true, index) | ||
| 509 | if input.index(Regexp.new('[0-9]'), index) == index | ||
| 510 | 510 | r11 = instantiate_node(SyntaxNode,input, index...(index + 1)) | |
| 511 | 511 | @index += 1 | |
| 512 | 512 | else | |
| … | … | ||
| 526 | 526 | r6 = instantiate_node(SyntaxNode,input, i6...index, s6) | |
| 527 | 527 | r6.extend(Integer1) | |
| 528 | 528 | else | |
| 529 | @index = i6 | ||
| 529 | self.index = i6 | ||
| 530 | 530 | r6 = nil | |
| 531 | 531 | end | |
| 532 | 532 | if r6 | |
| 533 | 533 | r1 = r6 | |
| 534 | 534 | else | |
| 535 | @index = i1 | ||
| 535 | self.index = i1 | ||
| 536 | 536 | r1 = nil | |
| 537 | 537 | end | |
| 538 | 538 | end | |
| … | … | ||
| 541 | 541 | i12 = index | |
| 542 | 542 | r13 = _nt_delimiter | |
| 543 | 543 | if r13 | |
| 544 | @index = i12 | ||
| 544 | self.index = i12 | ||
| 545 | 545 | r12 = instantiate_node(SyntaxNode,input, index...index) | |
| 546 | 546 | else | |
| 547 | 547 | r12 = nil | |
| … | … | ||
| 552 | 552 | r0 = instantiate_node(Integer,input, i0...index, s0) | |
| 553 | 553 | r0.extend(Integer2) | |
| 554 | 554 | else | |
| 555 | @index = i0 | ||
| 555 | self.index = i0 | ||
| 556 | 556 | r0 = nil | |
| 557 | 557 | end | |
| 558 | 558 | ||
| 559 | 559 | node_cache[:integer][start_index] = r0 | |
| 560 | 560 | ||
| 561 | r0 | ||
| 561 | return r0 | ||
| 562 | 562 | end | |
| 563 | 563 | ||
| 564 | 564 | module Float0 | |
| … | … | ||
| 573 | 573 | end | |
| 574 | 574 | ||
| 575 | 575 | i0, s0 = index, [] | |
| 576 | if has_terminal?("-", false, index) | ||
| 576 | if input.index("-", index) == index | ||
| 577 | 577 | r2 = instantiate_node(SyntaxNode,input, index...(index + 1)) | |
| 578 | 578 | @index += 1 | |
| 579 | 579 | else | |
| … | … | ||
| 589 | 589 | if r1 | |
| 590 | 590 | s3, i3 = [], index | |
| 591 | 591 | loop do | |
| 592 | if has_terminal?('\G[0-9]', true, index) | ||
| 592 | if input.index(Regexp.new('[0-9]'), index) == index | ||
| 593 | 593 | r4 = instantiate_node(SyntaxNode,input, index...(index + 1)) | |
| 594 | 594 | @index += 1 | |
| 595 | 595 | else | |
| … | … | ||
| 602 | 602 | end | |
| 603 | 603 | end | |
| 604 | 604 | if s3.empty? | |
| 605 | @index = i3 | ||
| 605 | self.index = i3 | ||
| 606 | 606 | r3 = nil | |
| 607 | 607 | else | |
| 608 | 608 | r3 = instantiate_node(SyntaxNode,input, i3...index, s3) | |
| 609 | 609 | end | |
| 610 | 610 | s0 << r3 | |
| 611 | 611 | if r3 | |
| 612 | if has_terminal?(".", false, index) | ||
| 612 | if input.index(".", index) == index | ||
| 613 | 613 | r5 = instantiate_node(SyntaxNode,input, index...(index + 1)) | |
| 614 | 614 | @index += 1 | |
| 615 | 615 | else | |
| … | … | ||
| 620 | 620 | if r5 | |
| 621 | 621 | s6, i6 = [], index | |
| 622 | 622 | loop do | |
| 623 | if has_terminal?('\G[0-9]', true, index) | ||
| 623 | if input.index(Regexp.new('[0-9]'), index) == index | ||
| 624 | 624 | r7 = instantiate_node(SyntaxNode,input, index...(index + 1)) | |
| 625 | 625 | @index += 1 | |
| 626 | 626 | else | |
| … | … | ||
| 633 | 633 | end | |
| 634 | 634 | end | |
| 635 | 635 | if s6.empty? | |
| 636 | @index = i6 | ||
| 636 | self.index = i6 | ||
| 637 | 637 | r6 = nil | |
| 638 | 638 | else | |
| 639 | 639 | r6 = instantiate_node(SyntaxNode,input, i6...index, s6) | |
| … | … | ||
| 646 | 646 | r0 = instantiate_node(SyntaxNode,input, i0...index, s0) | |
| 647 | 647 | r0.extend(Float0) | |
| 648 | 648 | else | |
| 649 | @index = i0 | ||
| 649 | self.index = i0 | ||
| 650 | 650 | r0 = nil | |
| 651 | 651 | end | |
| 652 | 652 | ||
| 653 | 653 | node_cache[:float][start_index] = r0 | |
| 654 | 654 | ||
| 655 | r0 | ||
| 655 | return r0 | ||
| 656 | 656 | end | |
| 657 | 657 | ||
| 658 | 658 | module String0 | |
| … | … | ||
| 671 | 671 | end | |
| 672 | 672 | ||
| 673 | 673 | i0, s0 = index, [] | |
| 674 | if has_terminal?('"', false, index) | ||
| 674 | if input.index('"', index) == index | ||
| 675 | 675 | r1 = instantiate_node(SyntaxNode,input, index...(index + 1)) | |
| 676 | 676 | @index += 1 | |
| 677 | 677 | else | |
| … | … | ||
| 692 | 692 | r2 = instantiate_node(SyntaxNode,input, i2...index, s2) | |
| 693 | 693 | s0 << r2 | |
| 694 | 694 | if r2 | |
| 695 | if has_terminal?('"', false, index) | ||
| 695 | if input.index('"', index) == index | ||
| 696 | 696 | r4 = instantiate_node(SyntaxNode,input, index...(index + 1)) | |
| 697 | 697 | @index += 1 | |
| 698 | 698 | else | |
| … | … | ||
| 706 | 706 | r0 = instantiate_node(StackdString,input, i0...index, s0) | |
| 707 | 707 | r0.extend(String0) | |
| 708 | 708 | else | |
| 709 | @index = i0 | ||
| 709 | self.index = i0 | ||
| 710 | 710 | r0 = nil | |
| 711 | 711 | end | |
| 712 | 712 | ||
| 713 | 713 | node_cache[:string][start_index] = r0 | |
| 714 | 714 | ||
| 715 | r0 | ||
| 715 | return r0 | ||
| 716 | 716 | end | |
| 717 | 717 | ||
| 718 | 718 | module StringChar0 | |
| … | … | ||
| 737 | 737 | ||
| 738 | 738 | i0, s0 = index, [] | |
| 739 | 739 | i1 = index | |
| 740 | if has_terminal?('"', false, index) | ||
| 740 | if input.index('"', index) == index | ||
| 741 | 741 | r2 = instantiate_node(SyntaxNode,input, index...(index + 1)) | |
| 742 | 742 | @index += 1 | |
| 743 | 743 | else | |
| … | … | ||
| 747 | 747 | if r2 | |
| 748 | 748 | r1 = nil | |
| 749 | 749 | else | |
| 750 | @index = i1 | ||
| 750 | self.index = i1 | ||
| 751 | 751 | r1 = instantiate_node(SyntaxNode,input, index...index) | |
| 752 | 752 | end | |
| 753 | 753 | s0 << r1 | |
| … | … | ||
| 766 | 766 | r0.extend(StringChar0) | |
| 767 | 767 | r0.extend(StringChar1) | |
| 768 | 768 | else | |
| 769 | @index = i0 | ||
| 769 | self.index = i0 | ||
| 770 | 770 | r0 = nil | |
| 771 | 771 | end | |
| 772 | 772 | ||
| 773 | 773 | node_cache[:string_char][start_index] = r0 | |
| 774 | 774 | ||
| 775 | r0 | ||
| 775 | return r0 | ||
| 776 | 776 | end | |
| 777 | 777 | ||
| 778 | 778 | module Quotation0 | |
| … | … | ||
| 791 | 791 | end | |
| 792 | 792 | ||
| 793 | 793 | i0, s0 = index, [] | |
| 794 | if has_terminal?("[", false, index) | ||
| 794 | if input.index("[", index) == index | ||
| 795 | 795 | r1 = instantiate_node(SyntaxNode,input, index...(index + 1)) | |
| 796 | 796 | @index += 1 | |
| 797 | 797 | else | |
| … | … | ||
| 810 | 810 | end | |
| 811 | 811 | end | |
| 812 | 812 | if s2.empty? | |
| 813 | @index = i2 | ||
| 813 | self.index = i2 | ||
| 814 | 814 | r2 = nil | |
| 815 | 815 | else | |
| 816 | 816 | r2 = instantiate_node(SyntaxNode,input, i2...index, s2) | |
| 817 | 817 | end | |
| 818 | 818 | s0 << r2 | |
| 819 | 819 | if r2 | |
| 820 | if has_terminal?("]", false, index) | ||
| 820 | if input.index("]", index) == index | ||
| 821 | 821 | r4 = instantiate_node(SyntaxNode,input, index...(index + 1)) | |
| 822 | 822 | @index += 1 | |
| 823 | 823 | else | |
| … | … | ||
| 831 | 831 | r0 = instantiate_node(Quotation,input, i0...index, s0) | |
| 832 | 832 | r0.extend(Quotation0) | |
| 833 | 833 | else | |
| 834 | @index = i0 | ||
| 834 | self.index = i0 | ||
| 835 | 835 | r0 = nil | |
| 836 | 836 | end | |
| 837 | 837 | ||
| 838 | 838 | node_cache[:quotation][start_index] = r0 | |
| 839 | 839 | ||
| 840 | r0 | ||
| 840 | return r0 | ||
| 841 | 841 | end | |
| 842 | 842 | ||
| 843 | 843 | module Regex0 | |
| … | … | ||
| 859 | 859 | end | |
| 860 | 860 | ||
| 861 | 861 | i0, s0 = index, [] | |
| 862 | if has_terminal?('/', false, index) | ||
| 862 | if input.index('/', index) == index | ||
| 863 | 863 | r1 = instantiate_node(SyntaxNode,input, index...(index + 1)) | |
| 864 | 864 | @index += 1 | |
| 865 | 865 | else | |
| … | … | ||
| 872 | 872 | loop do | |
| 873 | 873 | i3, s3 = index, [] | |
| 874 | 874 | i4 = index | |
| 875 | if has_terminal?('/', false, index) | ||
| 875 | if input.index('/', index) == index | ||
| 876 | 876 | r5 = instantiate_node(SyntaxNode,input, index...(index + 1)) | |
| 877 | 877 | @index += 1 | |
| 878 | 878 | else | |
| … | … | ||
| 882 | 882 | if r5 | |
| 883 | 883 | r4 = nil | |
| 884 | 884 | else | |
| 885 | @index = i4 | ||
| 885 | self.index = i4 | ||
| 886 | 886 | r4 = instantiate_node(SyntaxNode,input, index...index) | |
| 887 | 887 | end | |
| 888 | 888 | s3 << r4 | |
| … | … | ||
| 900 | 900 | r3 = instantiate_node(SyntaxNode,input, i3...index, s3) | |
| 901 | 901 | r3.extend(Regex0) | |
| 902 | 902 | else | |
| 903 | @index = i3 | ||
| 903 | self.index = i3 | ||
| 904 | 904 | r3 = nil | |
| 905 | 905 | end | |
| 906 | 906 | if r3 | |
| … | … | ||
| 912 | 912 | r2 = instantiate_node(SyntaxNode,input, i2...index, s2) | |
| 913 | 913 | s0 << r2 | |
| 914 | 914 | if r2 | |
| 915 | if has_terminal?('/', false, index) | ||
| 915 | if input.index('/', index) == index | ||
| 916 | 916 | r7 = instantiate_node(SyntaxNode,input, index...(index + 1)) | |
| 917 | 917 | @index += 1 | |
| 918 | 918 | else | |
| … | … | ||
| 926 | 926 | r0 = instantiate_node(Regex,input, i0...index, s0) | |
| 927 | 927 | r0.extend(Regex1) | |
| 928 | 928 | else | |
| 929 | @index = i0 | ||
| 929 | self.index = i0 | ||
| 930 | 930 | r0 = nil | |
| 931 | 931 | end | |
| 932 | 932 | ||
| 933 | 933 | node_cache[:regex][start_index] = r0 | |
| 934 | 934 | ||
| 935 | r0 | ||
| 935 | return r0 | ||
| 936 | 936 | end | |
| 937 | 937 | ||
| 938 | 938 | module Array0 | |
| … | … | ||
| 951 | 951 | end | |
| 952 | 952 | ||
| 953 | 953 | i0, s0 = index, [] | |
| 954 | if has_terminal?('#(', false, index) | ||
| 954 | if input.index('#(', index) == index | ||
| 955 | 955 | r1 = instantiate_node(SyntaxNode,input, index...(index + 2)) | |
| 956 | 956 | @index += 2 | |
| 957 | 957 | else | |
| … | … | ||
| 996 | 996 | r6 = instantiate_node(SyntaxNode,input, i6...index, s6) | |
| 997 | 997 | s0 << r6 | |
| 998 | 998 | if r6 | |
| 999 | if has_terminal?(')', false, index) | ||
| 999 | if input.index(')', index) == index | ||
| 1000 | 1000 | r8 = instantiate_node(SyntaxNode,input, index...(index + 1)) | |
| 1001 | 1001 | @index += 1 | |
| 1002 | 1002 | else | |
| … | … | ||
| 1012 | 1012 | r0 = instantiate_node(Array,input, i0...index, s0) | |
| 1013 | 1013 | r0.extend(Array0) | |
| 1014 | 1014 | else | |
| 1015 | @index = i0 | ||
| 1015 | self.index = i0 | ||
| 1016 | 1016 | r0 = nil | |
| 1017 | 1017 | end | |
| 1018 | 1018 | ||
| 1019 | 1019 | node_cache[:array][start_index] = r0 | |
| 1020 | 1020 | ||
| 1021 | r0 | ||
| 1021 | return r0 | ||
| 1022 | 1022 | end | |
| 1023 | 1023 | ||
| 1024 | 1024 | module Hash0 | |
| … | … | ||
| 1043 | 1043 | end | |
| 1044 | 1044 | ||
| 1045 | 1045 | i0, s0 = index, [] | |
| 1046 | if has_terminal?('{{', false, index) | ||
| 1046 | if input.index('{{', index) == index | ||
| 1047 | 1047 | r1 = instantiate_node(SyntaxNode,input, index...(index + 2)) | |
| 1048 | 1048 | @index += 2 | |
| 1049 | 1049 | else | |
| … | … | ||
| 1082 | 1082 | r5 = instantiate_node(SyntaxNode,input, i5...index, s5) | |
| 1083 | 1083 | r5.extend(Hash0) | |
| 1084 | 1084 | else | |
| 1085 | @index = i5 | ||
| 1085 | self.index = i5 | ||
| 1086 | 1086 | r5 = nil | |
| 1087 | 1087 | end | |
| 1088 | 1088 | if r5 | |
| … | … | ||
| 1106 | 1106 | r9 = instantiate_node(SyntaxNode,input, i9...index, s9) | |
| 1107 | 1107 | s0 << r9 | |
| 1108 | 1108 | if r9 | |
| 1109 | if has_terminal?('}}', false, index) | ||
| 1109 | if input.index('}}', index) == index | ||
| 1110 | 1110 | r11 = instantiate_node(SyntaxNode,input, index...(index + 2)) | |
| 1111 | 1111 | @index += 2 | |
| 1112 | 1112 | else | |
| … | … | ||
| 1122 | 1122 | r0 = instantiate_node(Hashtable,input, i0...index, s0) | |
| 1123 | 1123 | r0.extend(Hash1) | |
| 1124 | 1124 | else | |
| 1125 | @index = i0 | ||
| 1125 | self.index = i0 | ||
| 1126 | 1126 | r0 = nil | |
| 1127 | 1127 | end | |
| 1128 | 1128 | ||
| 1129 | 1129 | node_cache[:hash][start_index] = r0 | |
| 1130 | 1130 | ||
| 1131 | r0 | ||
| 1131 | return r0 | ||
| 1132 | 1132 | end | |
| 1133 | 1133 | ||
| 1134 | 1134 | module HashEntry0 | |
| … | … | ||
| 1153 | 1153 | r1 = _nt_atom | |
| 1154 | 1154 | s0 << r1 | |
| 1155 | 1155 | if r1 | |
| 1156 | if has_terminal?('=>', false, index) | ||
| 1156 | if input.index('=>', index) == index | ||
| 1157 | 1157 | r2 = instantiate_node(SyntaxNode,input, index...(index + 2)) | |
| 1158 | 1158 | @index += 2 | |
| 1159 | 1159 | else | |
| … | … | ||
| 1170 | 1170 | r0 = instantiate_node(HashEntry,input, i0...index, s0) | |
| 1171 | 1171 | r0.extend(HashEntry0) | |
| 1172 | 1172 | else | |
| 1173 | @index = i0 | ||
| 1173 | self.index = i0 | ||
| 1174 | 1174 | r0 = nil | |
| 1175 | 1175 | end | |
| 1176 | 1176 | ||
| 1177 | 1177 | node_cache[:hash_entry][start_index] = r0 | |
| 1178 | 1178 | ||
| 1179 | r0 | ||
| 1179 | return r0 | ||
| 1180 | 1180 | end | |
| 1181 | 1181 | ||
| 1182 | 1182 | module Symbol0 | |
| … | … | ||
| 1200 | 1200 | end | |
| 1201 | 1201 | ||
| 1202 | 1202 | i0, s0 = index, [] | |
| 1203 | if has_terminal?(':', false, index) | ||
| 1203 | if input.index(':', index) == index | ||
| 1204 | 1204 | r1 = instantiate_node(SyntaxNode,input, index...(index + 1)) | |
| 1205 | 1205 | @index += 1 | |
| 1206 | 1206 | else | |
| … | … | ||
| 1211 | 1211 | if r1 | |
| 1212 | 1212 | i2, s2 = index, [] | |
| 1213 | 1213 | i3 = index | |
| 1214 | if has_terminal?(':', false, index) | ||
| 1214 | if input.index(':', index) == index | ||
| 1215 | 1215 | r4 = instantiate_node(SyntaxNode,input, index...(index + 1)) | |
| 1216 | 1216 | @index += 1 | |
| 1217 | 1217 | else | |
| … | … | ||
| 1221 | 1221 | if r4 | |
| 1222 | 1222 | r3 = nil | |
| 1223 | 1223 | else | |
| 1224 | @index = i3 | ||
| 1224 | self.index = i3 | ||
| 1225 | 1225 | r3 = instantiate_node(SyntaxNode,input, index...index) | |
| 1226 | 1226 | end | |
| 1227 | 1227 | s2 << r3 | |
| … | … | ||
| 1233 | 1233 | r2 = instantiate_node(SyntaxNode,input, i2...index, s2) | |
| 1234 | 1234 | r2.extend(Symbol0) | |
| 1235 | 1235 | else | |
| 1236 | @index = i2 | ||
| 1236 | self.index = i2 | ||
| 1237 | 1237 | r2 = nil | |
| 1238 | 1238 | end | |
| 1239 | 1239 | s0 << r2 | |
| … | … | ||
| 1242 | 1242 | r0 = instantiate_node(Symbol,input, i0...index, s0) | |
| 1243 | 1243 | r0.extend(Symbol1) | |
| 1244 | 1244 | else | |
| 1245 | @index = i0 | ||
| 1245 | self.index = i0 | ||
| 1246 | 1246 | r0 = nil | |
| 1247 | 1247 | end | |
| 1248 | 1248 | ||
| 1249 | 1249 | node_cache[:symbol][start_index] = r0 | |
| 1250 | 1250 | ||
| 1251 | r0 | ||
| 1251 | return r0 | ||
| 1252 | 1252 | end | |
| 1253 | 1253 | ||
| 1254 | 1254 | module Identifier0 | |
| … | … | ||
| 1270 | 1270 | if r3 | |
| 1271 | 1271 | r2 = nil | |
| 1272 | 1272 | else | |
| 1273 | @index = i2 | ||
| 1273 | self.index = i2 | ||
| 1274 | 1274 | r2 = instantiate_node(SyntaxNode,input, index...index) | |
| 1275 | 1275 | end | |
| 1276 | 1276 | s1 << r2 | |
| … | … | ||
| 1288 | 1288 | r1 = instantiate_node(SyntaxNode,input, i1...index, s1) | |
| 1289 | 1289 | r1.extend(Identifier0) | |
| 1290 | 1290 | else | |
| 1291 | @index = i1 | ||
| 1291 | self.index = i1 | ||
| 1292 | 1292 | r1 = nil | |
| 1293 | 1293 | end | |
| 1294 | 1294 | if r1 | |
| … | … | ||
| 1298 | 1298 | end | |
| 1299 | 1299 | end | |
| 1300 | 1300 | if s0.empty? | |
| 1301 | @index = i0 | ||
| 1301 | self.index = i0 | ||
| 1302 | 1302 | r0 = nil | |
| 1303 | 1303 | else | |
| 1304 | 1304 | r0 = instantiate_node(Identifier,input, i0...index, s0) | |
| … | … | ||
| 1306 | 1306 | ||
| 1307 | 1307 | node_cache[:identifier][start_index] = r0 | |
| 1308 | 1308 | ||
| 1309 | r0 | ||
| 1309 | return r0 | ||
| 1310 | 1310 | end | |
| 1311 | 1311 | ||
| 1312 | 1312 | def _nt_space | |
| … | … | ||
| 1317 | 1317 | return cached | |
| 1318 | 1318 | end | |
| 1319 | 1319 | ||
| 1320 | if has_terminal?('\G[\\s\\n\\r\\t]', true, index) | ||
| 1320 | if input.index(Regexp.new('[\\s\\n\\r\\t]'), index) == index | ||
| 1321 | 1321 | r0 = instantiate_node(SyntaxNode,input, index...(index + 1)) | |
| 1322 | 1322 | @index += 1 | |
| 1323 | 1323 | else | |
| … | … | ||
| 1326 | 1326 | ||
| 1327 | 1327 | node_cache[:space][start_index] = r0 | |
| 1328 | 1328 | ||
| 1329 | r0 | ||
| 1329 | return r0 | ||
| 1330 | 1330 | end | |
| 1331 | 1331 | ||
| 1332 | 1332 | def _nt_paren | |
| … | … | ||
| 1337 | 1337 | return cached | |
| 1338 | 1338 | end | |
| 1339 | 1339 | ||
| 1340 | if has_terminal?('\G[\\(\\)\\[\\]]', true, index) | ||
| 1340 | if input.index(Regexp.new('[\\(\\)\\[\\]]'), index) == index | ||
| 1341 | 1341 | r0 = instantiate_node(SyntaxNode,input, index...(index + 1)) | |
| 1342 | 1342 | @index += 1 | |
| 1343 | 1343 | else | |
| … | … | ||
| 1346 | 1346 | ||
| 1347 | 1347 | node_cache[:paren][start_index] = r0 | |
| 1348 | 1348 | ||
| 1349 | r0 | ||
| 1349 | return r0 | ||
| 1350 | 1350 | end | |
| 1351 | 1351 | ||
| 1352 | 1352 | def _nt_delimiter | |
| … | … | ||
| 1370 | 1370 | if r3 | |
| 1371 | 1371 | r0 = r3 | |
| 1372 | 1372 | else | |
| 1373 | @index = i0 | ||
| 1373 | self.index = i0 | ||
| 1374 | 1374 | r0 = nil | |
| 1375 | 1375 | end | |
| 1376 | 1376 | end | |
| … | … | ||
| 1378 | 1378 | ||
| 1379 | 1379 | node_cache[:delimiter][start_index] = r0 | |
| 1380 | 1380 | ||
| 1381 | r0 | ||
| 1381 | return r0 | ||
| 1382 | 1382 | end | |
| 1383 | 1383 | ||
| 1384 | 1384 | def _nt_terminal | |
| … | … | ||
| 1389 | 1389 | return cached | |
| 1390 | 1390 | end | |
| 1391 | 1391 | ||
| 1392 | if has_terminal?(';', false, index) | ||
| 1392 | if input.index(';', index) == index | ||
| 1393 | 1393 | r0 = instantiate_node(SyntaxNode,input, index...(index + 1)) | |
| 1394 | 1394 | @index += 1 | |
| 1395 | 1395 | else | |
| … | … | ||
| 1399 | 1399 | ||
| 1400 | 1400 | node_cache[:terminal][start_index] = r0 | |
| 1401 | 1401 | ||
| 1402 | r0 | ||
| 1402 | return r0 | ||
| 1403 | 1403 | end | |
| 1404 | 1404 | ||
| 1405 | 1405 | end |
