Namespace

Included Modules

Files

Class Index [+]

Quicksearch

Treetop::Compiler::Metagrammar

Public Instance Methods

_nt_alpha_char() click to toggle source
      # File lib/treetop/compiler/metagrammar.rb, line 3334
3334:       def _nt_alpha_char
3335:         start_index = index
3336:         if node_cache[:alpha_char].has_key?(index)
3337:           cached = node_cache[:alpha_char][index]
3338:           if cached
3339:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
3340:             @index = cached.interval.end
3341:           end
3342:           return cached
3343:         end
3344: 
3345:         if has_terminal?('\G[A-Za-z_]', true, index)
3346:           r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
3347:           @index += 1
3348:         else
3349:           r0 = nil
3350:         end
3351: 
3352:         node_cache[:alpha_char][start_index] = r0
3353: 
3354:         r0
3355:       end
_nt_alphanumeric_char() click to toggle source
      # File lib/treetop/compiler/metagrammar.rb, line 3357
3357:       def _nt_alphanumeric_char
3358:         start_index = index
3359:         if node_cache[:alphanumeric_char].has_key?(index)
3360:           cached = node_cache[:alphanumeric_char][index]
3361:           if cached
3362:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
3363:             @index = cached.interval.end
3364:           end
3365:           return cached
3366:         end
3367: 
3368:         i0 = index
3369:         r1 = _nt_alpha_char
3370:         if r1
3371:           r0 = r1
3372:         else
3373:           if has_terminal?('\G[0-9]', true, index)
3374:             r2 = true
3375:             @index += 1
3376:           else
3377:             r2 = nil
3378:           end
3379:           if r2
3380:             r0 = r2
3381:           else
3382:             @index = i0
3383:             r0 = nil
3384:           end
3385:         end
3386: 
3387:         node_cache[:alphanumeric_char][start_index] = r0
3388: 
3389:         r0
3390:       end
_nt_alternative() click to toggle source
      # File lib/treetop/compiler/metagrammar.rb, line 1249
1249:       def _nt_alternative
1250:         start_index = index
1251:         if node_cache[:alternative].has_key?(index)
1252:           cached = node_cache[:alternative][index]
1253:           if cached
1254:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
1255:             @index = cached.interval.end
1256:           end
1257:           return cached
1258:         end
1259: 
1260:         i0 = index
1261:         r1 = _nt_sequence
1262:         if r1
1263:           r0 = r1
1264:         else
1265:           r2 = _nt_primary
1266:           if r2
1267:             r0 = r2
1268:           else
1269:             @index = i0
1270:             r0 = nil
1271:           end
1272:         end
1273: 
1274:         node_cache[:alternative][start_index] = r0
1275: 
1276:         r0
1277:       end
_nt_anything_symbol() click to toggle source
      # File lib/treetop/compiler/metagrammar.rb, line 2826
2826:       def _nt_anything_symbol
2827:         start_index = index
2828:         if node_cache[:anything_symbol].has_key?(index)
2829:           cached = node_cache[:anything_symbol][index]
2830:           if cached
2831:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
2832:             @index = cached.interval.end
2833:           end
2834:           return cached
2835:         end
2836: 
2837:         if has_terminal?('.', false, index)
2838:           r0 = instantiate_node(AnythingSymbol,input, index...(index + 1))
2839:           @index += 1
2840:         else
2841:           terminal_parse_failure('.')
2842:           r0 = nil
2843:         end
2844: 
2845:         node_cache[:anything_symbol][start_index] = r0
2846: 
2847:         r0
2848:       end
_nt_atomic() click to toggle source
      # File lib/treetop/compiler/metagrammar.rb, line 2136
2136:       def _nt_atomic
2137:         start_index = index
2138:         if node_cache[:atomic].has_key?(index)
2139:           cached = node_cache[:atomic][index]
2140:           if cached
2141:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
2142:             @index = cached.interval.end
2143:           end
2144:           return cached
2145:         end
2146: 
2147:         i0 = index
2148:         r1 = _nt_terminal
2149:         if r1
2150:           r0 = r1
2151:         else
2152:           r2 = _nt_nonterminal
2153:           if r2
2154:             r0 = r2
2155:           else
2156:             r3 = _nt_parenthesized_expression
2157:             if r3
2158:               r0 = r3
2159:             else
2160:               @index = i0
2161:               r0 = nil
2162:             end
2163:           end
2164:         end
2165: 
2166:         node_cache[:atomic][start_index] = r0
2167: 
2168:         r0
2169:       end
_nt_character_class() click to toggle source
      # File lib/treetop/compiler/metagrammar.rb, line 2669
2669:       def _nt_character_class
2670:         start_index = index
2671:         if node_cache[:character_class].has_key?(index)
2672:           cached = node_cache[:character_class][index]
2673:           if cached
2674:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
2675:             @index = cached.interval.end
2676:           end
2677:           return cached
2678:         end
2679: 
2680:         i0, s0 = index, []
2681:         if has_terminal?('[', false, index)
2682:           r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
2683:           @index += 1
2684:         else
2685:           terminal_parse_failure('[')
2686:           r1 = nil
2687:         end
2688:         s0 << r1
2689:         if r1
2690:           s2, i2 = [], index
2691:           loop do
2692:             i3, s3 = index, []
2693:             i4 = index
2694:             if has_terminal?(']', false, index)
2695:               r5 = instantiate_node(SyntaxNode,input, index...(index + 1))
2696:               @index += 1
2697:             else
2698:               terminal_parse_failure(']')
2699:               r5 = nil
2700:             end
2701:             if r5
2702:               r4 = nil
2703:             else
2704:               @index = i4
2705:               r4 = instantiate_node(SyntaxNode,input, index...index)
2706:             end
2707:             s3 << r4
2708:             if r4
2709:               i6 = index
2710:               i7, s7 = index, []
2711:               if has_terminal?('\', false, index)
2712:                 r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
2713:                 @index += 1
2714:               else
2715:                 terminal_parse_failure('\')
2716:                 r8 = nil
2717:               end
2718:               s7 << r8
2719:               if r8
2720:                 if index < input_length
2721:                   r9 = instantiate_node(SyntaxNode,input, index...(index + 1))
2722:                   @index += 1
2723:                 else
2724:                   terminal_parse_failure("any character")
2725:                   r9 = nil
2726:                 end
2727:                 s7 << r9
2728:               end
2729:               if s7.last
2730:                 r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
2731:                 r7.extend(CharacterClass0)
2732:               else
2733:                 @index = i7
2734:                 r7 = nil
2735:               end
2736:               if r7
2737:                 r6 = r7
2738:               else
2739:                 i10, s10 = index, []
2740:                 i11 = index
2741:                 if has_terminal?('\', false, index)
2742:                   r12 = instantiate_node(SyntaxNode,input, index...(index + 1))
2743:                   @index += 1
2744:                 else
2745:                   terminal_parse_failure('\')
2746:                   r12 = nil
2747:                 end
2748:                 if r12
2749:                   r11 = nil
2750:                 else
2751:                   @index = i11
2752:                   r11 = instantiate_node(SyntaxNode,input, index...index)
2753:                 end
2754:                 s10 << r11
2755:                 if r11
2756:                   if index < input_length
2757:                     r13 = instantiate_node(SyntaxNode,input, index...(index + 1))
2758:                     @index += 1
2759:                   else
2760:                     terminal_parse_failure("any character")
2761:                     r13 = nil
2762:                   end
2763:                   s10 << r13
2764:                 end
2765:                 if s10.last
2766:                   r10 = instantiate_node(SyntaxNode,input, i10...index, s10)
2767:                   r10.extend(CharacterClass1)
2768:                 else
2769:                   @index = i10
2770:                   r10 = nil
2771:                 end
2772:                 if r10
2773:                   r6 = r10
2774:                 else
2775:                   @index = i6
2776:                   r6 = nil
2777:                 end
2778:               end
2779:               s3 << r6
2780:             end
2781:             if s3.last
2782:               r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
2783:               r3.extend(CharacterClass2)
2784:             else
2785:               @index = i3
2786:               r3 = nil
2787:             end
2788:             if r3
2789:               s2 << r3
2790:             else
2791:               break
2792:             end
2793:           end
2794:           if s2.empty?
2795:             @index = i2
2796:             r2 = nil
2797:           else
2798:             r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
2799:           end
2800:           s0 << r2
2801:           if r2
2802:             if has_terminal?(']', false, index)
2803:               r14 = instantiate_node(SyntaxNode,input, index...(index + 1))
2804:               @index += 1
2805:             else
2806:               terminal_parse_failure(']')
2807:               r14 = nil
2808:             end
2809:             s0 << r14
2810:           end
2811:         end
2812:         if s0.last
2813:           r0 = instantiate_node(CharacterClass,input, i0...index, s0)
2814:           r0.extend(CharacterClass3)
2815:           r0.extend(CharacterClass4)
2816:         else
2817:           @index = i0
2818:           r0 = nil
2819:         end
2820: 
2821:         node_cache[:character_class][start_index] = r0
2822: 
2823:         r0
2824:       end
_nt_choice() click to toggle source
      # File lib/treetop/compiler/metagrammar.rb, line 1059
1059:       def _nt_choice
1060:         start_index = index
1061:         if node_cache[:choice].has_key?(index)
1062:           cached = node_cache[:choice][index]
1063:           if cached
1064:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
1065:             @index = cached.interval.end
1066:           end
1067:           return cached
1068:         end
1069: 
1070:         i0, s0 = index, []
1071:         r1 = _nt_alternative
1072:         s0 << r1
1073:         if r1
1074:           s2, i2 = [], index
1075:           loop do
1076:             i3, s3 = index, []
1077:             r5 = _nt_space
1078:             if r5
1079:               r4 = r5
1080:             else
1081:               r4 = instantiate_node(SyntaxNode,input, index...index)
1082:             end
1083:             s3 << r4
1084:             if r4
1085:               if has_terminal?('/', false, index)
1086:                 r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
1087:                 @index += 1
1088:               else
1089:                 terminal_parse_failure('/')
1090:                 r6 = nil
1091:               end
1092:               s3 << r6
1093:               if r6
1094:                 r8 = _nt_space
1095:                 if r8
1096:                   r7 = r8
1097:                 else
1098:                   r7 = instantiate_node(SyntaxNode,input, index...index)
1099:                 end
1100:                 s3 << r7
1101:                 if r7
1102:                   r9 = _nt_alternative
1103:                   s3 << r9
1104:                 end
1105:               end
1106:             end
1107:             if s3.last
1108:               r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
1109:               r3.extend(Choice0)
1110:             else
1111:               @index = i3
1112:               r3 = nil
1113:             end
1114:             if r3
1115:               s2 << r3
1116:             else
1117:               break
1118:             end
1119:           end
1120:           if s2.empty?
1121:             @index = i2
1122:             r2 = nil
1123:           else
1124:             r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
1125:           end
1126:           s0 << r2
1127:         end
1128:         if s0.last
1129:           r0 = instantiate_node(Choice,input, i0...index, s0)
1130:           r0.extend(Choice1)
1131:           r0.extend(Choice2)
1132:         else
1133:           @index = i0
1134:           r0 = nil
1135:         end
1136: 
1137:         node_cache[:choice][start_index] = r0
1138: 
1139:         r0
1140:       end
_nt_comment_to_eol() click to toggle source
      # File lib/treetop/compiler/metagrammar.rb, line 3442
3442:       def _nt_comment_to_eol
3443:         start_index = index
3444:         if node_cache[:comment_to_eol].has_key?(index)
3445:           cached = node_cache[:comment_to_eol][index]
3446:           if cached
3447:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
3448:             @index = cached.interval.end
3449:           end
3450:           return cached
3451:         end
3452: 
3453:         i0, s0 = index, []
3454:         if has_terminal?('#', false, index)
3455:           r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
3456:           @index += 1
3457:         else
3458:           terminal_parse_failure('#')
3459:           r1 = nil
3460:         end
3461:         s0 << r1
3462:         if r1
3463:           s2, i2 = [], index
3464:           loop do
3465:             i3, s3 = index, []
3466:             i4 = index
3467:             if has_terminal?("\n", false, index)
3468:               r5 = instantiate_node(SyntaxNode,input, index...(index + 1))
3469:               @index += 1
3470:             else
3471:               terminal_parse_failure("\n")
3472:               r5 = nil
3473:             end
3474:             if r5
3475:               r4 = nil
3476:             else
3477:               @index = i4
3478:               r4 = instantiate_node(SyntaxNode,input, index...index)
3479:             end
3480:             s3 << r4
3481:             if r4
3482:               if index < input_length
3483:                 r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
3484:                 @index += 1
3485:               else
3486:                 terminal_parse_failure("any character")
3487:                 r6 = nil
3488:               end
3489:               s3 << r6
3490:             end
3491:             if s3.last
3492:               r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
3493:               r3.extend(CommentToEol0)
3494:             else
3495:               @index = i3
3496:               r3 = nil
3497:             end
3498:             if r3
3499:               s2 << r3
3500:             else
3501:               break
3502:             end
3503:           end
3504:           r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
3505:           s0 << r2
3506:         end
3507:         if s0.last
3508:           r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
3509:           r0.extend(CommentToEol1)
3510:         else
3511:           @index = i0
3512:           r0 = nil
3513:         end
3514: 
3515:         node_cache[:comment_to_eol][start_index] = r0
3516: 
3517:         r0
3518:       end
_nt_declaration() click to toggle source
     # File lib/treetop/compiler/metagrammar.rb, line 753
753:       def _nt_declaration
754:         start_index = index
755:         if node_cache[:declaration].has_key?(index)
756:           cached = node_cache[:declaration][index]
757:           if cached
758:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
759:             @index = cached.interval.end
760:           end
761:           return cached
762:         end
763: 
764:         i0 = index
765:         r1 = _nt_parsing_rule
766:         if r1
767:           r0 = r1
768:         else
769:           r2 = _nt_include_declaration
770:           if r2
771:             r0 = r2
772:           else
773:             @index = i0
774:             r0 = nil
775:           end
776:         end
777: 
778:         node_cache[:declaration][start_index] = r0
779: 
780:         r0
781:       end
_nt_declaration_sequence() click to toggle source
     # File lib/treetop/compiler/metagrammar.rb, line 680
680:       def _nt_declaration_sequence
681:         start_index = index
682:         if node_cache[:declaration_sequence].has_key?(index)
683:           cached = node_cache[:declaration_sequence][index]
684:           if cached
685:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
686:             @index = cached.interval.end
687:           end
688:           return cached
689:         end
690: 
691:         i0 = index
692:         i1, s1 = index, []
693:         r2 = _nt_declaration
694:         s1 << r2
695:         if r2
696:           s3, i3 = [], index
697:           loop do
698:             i4, s4 = index, []
699:             r5 = _nt_space
700:             s4 << r5
701:             if r5
702:               r6 = _nt_declaration
703:               s4 << r6
704:             end
705:             if s4.last
706:               r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
707:               r4.extend(DeclarationSequence0)
708:             else
709:               @index = i4
710:               r4 = nil
711:             end
712:             if r4
713:               s3 << r4
714:             else
715:               break
716:             end
717:           end
718:           r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
719:           s1 << r3
720:         end
721:         if s1.last
722:           r1 = instantiate_node(DeclarationSequence,input, i1...index, s1)
723:           r1.extend(DeclarationSequence1)
724:           r1.extend(DeclarationSequence2)
725:         else
726:           @index = i1
727:           r1 = nil
728:         end
729:         if r1
730:           r0 = r1
731:         else
732:           if has_terminal?('', false, index)
733:             r7 = instantiate_node(SyntaxNode,input, index...(index + 0))
734:             r7.extend(DeclarationSequence3)
735:             @index += 0
736:           else
737:             terminal_parse_failure('')
738:             r7 = nil
739:           end
740:           if r7
741:             r0 = r7
742:           else
743:             @index = i0
744:             r0 = nil
745:           end
746:         end
747: 
748:         node_cache[:declaration_sequence][start_index] = r0
749: 
750:         r0
751:       end
_nt_double_quoted_string() click to toggle source
      # File lib/treetop/compiler/metagrammar.rb, line 2403
2403:       def _nt_double_quoted_string
2404:         start_index = index
2405:         if node_cache[:double_quoted_string].has_key?(index)
2406:           cached = node_cache[:double_quoted_string][index]
2407:           if cached
2408:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
2409:             @index = cached.interval.end
2410:           end
2411:           return cached
2412:         end
2413: 
2414:         i0, s0 = index, []
2415:         if has_terminal?('"', false, index)
2416:           r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
2417:           @index += 1
2418:         else
2419:           terminal_parse_failure('"')
2420:           r1 = nil
2421:         end
2422:         s0 << r1
2423:         if r1
2424:           s2, i2 = [], index
2425:           loop do
2426:             i3, s3 = index, []
2427:             i4 = index
2428:             if has_terminal?('"', false, index)
2429:               r5 = instantiate_node(SyntaxNode,input, index...(index + 1))
2430:               @index += 1
2431:             else
2432:               terminal_parse_failure('"')
2433:               r5 = nil
2434:             end
2435:             if r5
2436:               r4 = nil
2437:             else
2438:               @index = i4
2439:               r4 = instantiate_node(SyntaxNode,input, index...index)
2440:             end
2441:             s3 << r4
2442:             if r4
2443:               i6 = index
2444:               if has_terminal?("\\\\", false, index)
2445:                 r7 = instantiate_node(SyntaxNode,input, index...(index + 2))
2446:                 @index += 2
2447:               else
2448:                 terminal_parse_failure("\\\\")
2449:                 r7 = nil
2450:               end
2451:               if r7
2452:                 r6 = r7
2453:               else
2454:                 if has_terminal?('\"', false, index)
2455:                   r8 = instantiate_node(SyntaxNode,input, index...(index + 2))
2456:                   @index += 2
2457:                 else
2458:                   terminal_parse_failure('\"')
2459:                   r8 = nil
2460:                 end
2461:                 if r8
2462:                   r6 = r8
2463:                 else
2464:                   if index < input_length
2465:                     r9 = instantiate_node(SyntaxNode,input, index...(index + 1))
2466:                     @index += 1
2467:                   else
2468:                     terminal_parse_failure("any character")
2469:                     r9 = nil
2470:                   end
2471:                   if r9
2472:                     r6 = r9
2473:                   else
2474:                     @index = i6
2475:                     r6 = nil
2476:                   end
2477:                 end
2478:               end
2479:               s3 << r6
2480:             end
2481:             if s3.last
2482:               r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
2483:               r3.extend(DoubleQuotedString0)
2484:             else
2485:               @index = i3
2486:               r3 = nil
2487:             end
2488:             if r3
2489:               s2 << r3
2490:             else
2491:               break
2492:             end
2493:           end
2494:           r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
2495:           s0 << r2
2496:           if r2
2497:             if has_terminal?('"', false, index)
2498:               r10 = instantiate_node(SyntaxNode,input, index...(index + 1))
2499:               @index += 1
2500:             else
2501:               terminal_parse_failure('"')
2502:               r10 = nil
2503:             end
2504:             s0 << r10
2505:           end
2506:         end
2507:         if s0.last
2508:           r0 = instantiate_node(Terminal,input, i0...index, s0)
2509:           r0.extend(DoubleQuotedString1)
2510:         else
2511:           @index = i0
2512:           r0 = nil
2513:         end
2514: 
2515:         node_cache[:double_quoted_string][start_index] = r0
2516: 
2517:         r0
2518:       end
_nt_grammar() click to toggle source
     # File lib/treetop/compiler/metagrammar.rb, line 501
501:       def _nt_grammar
502:         start_index = index
503:         if node_cache[:grammar].has_key?(index)
504:           cached = node_cache[:grammar][index]
505:           if cached
506:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
507:             @index = cached.interval.end
508:           end
509:           return cached
510:         end
511: 
512:         i0, s0 = index, []
513:         if has_terminal?('grammar', false, index)
514:           r1 = instantiate_node(SyntaxNode,input, index...(index + 7))
515:           @index += 7
516:         else
517:           terminal_parse_failure('grammar')
518:           r1 = nil
519:         end
520:         s0 << r1
521:         if r1
522:           r2 = _nt_space
523:           s0 << r2
524:           if r2
525:             r3 = _nt_grammar_name
526:             s0 << r3
527:             if r3
528:               r4 = _nt_space
529:               s0 << r4
530:               if r4
531:                 i6, s6 = index, []
532:                 if has_terminal?('do', false, index)
533:                   r7 = instantiate_node(SyntaxNode,input, index...(index + 2))
534:                   @index += 2
535:                 else
536:                   terminal_parse_failure('do')
537:                   r7 = nil
538:                 end
539:                 s6 << r7
540:                 if r7
541:                   r8 = _nt_space
542:                   s6 << r8
543:                 end
544:                 if s6.last
545:                   r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
546:                   r6.extend(Grammar0)
547:                 else
548:                   @index = i6
549:                   r6 = nil
550:                 end
551:                 if r6
552:                   r5 = r6
553:                 else
554:                   r5 = instantiate_node(SyntaxNode,input, index...index)
555:                 end
556:                 s0 << r5
557:                 if r5
558:                   r9 = _nt_declaration_sequence
559:                   s0 << r9
560:                   if r9
561:                     r11 = _nt_space
562:                     if r11
563:                       r10 = r11
564:                     else
565:                       r10 = instantiate_node(SyntaxNode,input, index...index)
566:                     end
567:                     s0 << r10
568:                     if r10
569:                       if has_terminal?('end', false, index)
570:                         r12 = instantiate_node(SyntaxNode,input, index...(index + 3))
571:                         @index += 3
572:                       else
573:                         terminal_parse_failure('end')
574:                         r12 = nil
575:                       end
576:                       s0 << r12
577:                     end
578:                   end
579:                 end
580:               end
581:             end
582:           end
583:         end
584:         if s0.last
585:           r0 = instantiate_node(Grammar,input, i0...index, s0)
586:           r0.extend(Grammar1)
587:         else
588:           @index = i0
589:           r0 = nil
590:         end
591: 
592:         node_cache[:grammar][start_index] = r0
593: 
594:         r0
595:       end
_nt_grammar_name() click to toggle source
     # File lib/treetop/compiler/metagrammar.rb, line 600
600:       def _nt_grammar_name
601:         start_index = index
602:         if node_cache[:grammar_name].has_key?(index)
603:           cached = node_cache[:grammar_name][index]
604:           if cached
605:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
606:             @index = cached.interval.end
607:           end
608:           return cached
609:         end
610: 
611:         i0, s0 = index, []
612:         if has_terminal?('\G[A-Z]', true, index)
613:           r1 = true
614:           @index += 1
615:         else
616:           r1 = nil
617:         end
618:         s0 << r1
619:         if r1
620:           s2, i2 = [], index
621:           loop do
622:             r3 = _nt_alphanumeric_char
623:             if r3
624:               s2 << r3
625:             else
626:               break
627:             end
628:           end
629:           r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
630:           s0 << r2
631:         end
632:         if s0.last
633:           r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
634:           r0.extend(GrammarName0)
635:         else
636:           @index = i0
637:           r0 = nil
638:         end
639: 
640:         node_cache[:grammar_name][start_index] = r0
641: 
642:         r0
643:       end
_nt_include_declaration() click to toggle source
     # File lib/treetop/compiler/metagrammar.rb, line 796
796:       def _nt_include_declaration
797:         start_index = index
798:         if node_cache[:include_declaration].has_key?(index)
799:           cached = node_cache[:include_declaration][index]
800:           if cached
801:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
802:             @index = cached.interval.end
803:           end
804:           return cached
805:         end
806: 
807:         i0, s0 = index, []
808:         if has_terminal?('include', false, index)
809:           r1 = instantiate_node(SyntaxNode,input, index...(index + 7))
810:           @index += 7
811:         else
812:           terminal_parse_failure('include')
813:           r1 = nil
814:         end
815:         s0 << r1
816:         if r1
817:           r2 = _nt_space
818:           s0 << r2
819:           if r2
820:             if has_terminal?('\G[A-Z]', true, index)
821:               r3 = true
822:               @index += 1
823:             else
824:               r3 = nil
825:             end
826:             s0 << r3
827:             if r3
828:               s4, i4 = [], index
829:               loop do
830:                 i5 = index
831:                 r6 = _nt_alphanumeric_char
832:                 if r6
833:                   r5 = r6
834:                 else
835:                   if has_terminal?('::', false, index)
836:                     r7 = instantiate_node(SyntaxNode,input, index...(index + 2))
837:                     @index += 2
838:                   else
839:                     terminal_parse_failure('::')
840:                     r7 = nil
841:                   end
842:                   if r7
843:                     r5 = r7
844:                   else
845:                     @index = i5
846:                     r5 = nil
847:                   end
848:                 end
849:                 if r5
850:                   s4 << r5
851:                 else
852:                   break
853:                 end
854:               end
855:               r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
856:               s0 << r4
857:             end
858:           end
859:         end
860:         if s0.last
861:           r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
862:           r0.extend(IncludeDeclaration0)
863:           r0.extend(IncludeDeclaration1)
864:         else
865:           @index = i0
866:           r0 = nil
867:         end
868: 
869:         node_cache[:include_declaration][start_index] = r0
870: 
871:         r0
872:       end
_nt_inline_module() click to toggle source
      # File lib/treetop/compiler/metagrammar.rb, line 3123
3123:       def _nt_inline_module
3124:         start_index = index
3125:         if node_cache[:inline_module].has_key?(index)
3126:           cached = node_cache[:inline_module][index]
3127:           if cached
3128:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
3129:             @index = cached.interval.end
3130:           end
3131:           return cached
3132:         end
3133: 
3134:         i0, s0 = index, []
3135:         if has_terminal?('{', false, index)
3136:           r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
3137:           @index += 1
3138:         else
3139:           terminal_parse_failure('{')
3140:           r1 = nil
3141:         end
3142:         s0 << r1
3143:         if r1
3144:           s2, i2 = [], index
3145:           loop do
3146:             i3 = index
3147:             r4 = _nt_inline_module
3148:             if r4
3149:               r3 = r4
3150:             else
3151:               i5, s5 = index, []
3152:               i6 = index
3153:               if has_terminal?('\G[{}]', true, index)
3154:                 r7 = true
3155:                 @index += 1
3156:               else
3157:                 r7 = nil
3158:               end
3159:               if r7
3160:                 r6 = nil
3161:               else
3162:                 @index = i6
3163:                 r6 = instantiate_node(SyntaxNode,input, index...index)
3164:               end
3165:               s5 << r6
3166:               if r6
3167:                 if index < input_length
3168:                   r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
3169:                   @index += 1
3170:                 else
3171:                   terminal_parse_failure("any character")
3172:                   r8 = nil
3173:                 end
3174:                 s5 << r8
3175:               end
3176:               if s5.last
3177:                 r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
3178:                 r5.extend(InlineModule0)
3179:               else
3180:                 @index = i5
3181:                 r5 = nil
3182:               end
3183:               if r5
3184:                 r3 = r5
3185:               else
3186:                 @index = i3
3187:                 r3 = nil
3188:               end
3189:             end
3190:             if r3
3191:               s2 << r3
3192:             else
3193:               break
3194:             end
3195:           end
3196:           r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
3197:           s0 << r2
3198:           if r2
3199:             if has_terminal?('}', false, index)
3200:               r9 = instantiate_node(SyntaxNode,input, index...(index + 1))
3201:               @index += 1
3202:             else
3203:               terminal_parse_failure('}')
3204:               r9 = nil
3205:             end
3206:             s0 << r9
3207:           end
3208:         end
3209:         if s0.last
3210:           r0 = instantiate_node(InlineModule,input, i0...index, s0)
3211:           r0.extend(InlineModule1)
3212:         else
3213:           @index = i0
3214:           r0 = nil
3215:         end
3216: 
3217:         node_cache[:inline_module][start_index] = r0
3218: 
3219:         r0
3220:       end
_nt_keyword_inside_grammar() click to toggle source
      # File lib/treetop/compiler/metagrammar.rb, line 3225
3225:       def _nt_keyword_inside_grammar
3226:         start_index = index
3227:         if node_cache[:keyword_inside_grammar].has_key?(index)
3228:           cached = node_cache[:keyword_inside_grammar][index]
3229:           if cached
3230:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
3231:             @index = cached.interval.end
3232:           end
3233:           return cached
3234:         end
3235: 
3236:         i0, s0 = index, []
3237:         i1 = index
3238:         if has_terminal?('rule', false, index)
3239:           r2 = instantiate_node(SyntaxNode,input, index...(index + 4))
3240:           @index += 4
3241:         else
3242:           terminal_parse_failure('rule')
3243:           r2 = nil
3244:         end
3245:         if r2
3246:           r1 = r2
3247:         else
3248:           if has_terminal?('end', false, index)
3249:             r3 = instantiate_node(SyntaxNode,input, index...(index + 3))
3250:             @index += 3
3251:           else
3252:             terminal_parse_failure('end')
3253:             r3 = nil
3254:           end
3255:           if r3
3256:             r1 = r3
3257:           else
3258:             @index = i1
3259:             r1 = nil
3260:           end
3261:         end
3262:         s0 << r1
3263:         if r1
3264:           i4 = index
3265:           r5 = _nt_non_space_char
3266:           if r5
3267:             r4 = nil
3268:           else
3269:             @index = i4
3270:             r4 = instantiate_node(SyntaxNode,input, index...index)
3271:           end
3272:           s0 << r4
3273:         end
3274:         if s0.last
3275:           r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
3276:           r0.extend(KeywordInsideGrammar0)
3277:         else
3278:           @index = i0
3279:           r0 = nil
3280:         end
3281: 
3282:         node_cache[:keyword_inside_grammar][start_index] = r0
3283: 
3284:         r0
3285:       end
_nt_label() click to toggle source
      # File lib/treetop/compiler/metagrammar.rb, line 1586
1586:       def _nt_label
1587:         start_index = index
1588:         if node_cache[:label].has_key?(index)
1589:           cached = node_cache[:label][index]
1590:           if cached
1591:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
1592:             @index = cached.interval.end
1593:           end
1594:           return cached
1595:         end
1596: 
1597:         i0 = index
1598:         i1, s1 = index, []
1599:         i2, s2 = index, []
1600:         r3 = _nt_alpha_char
1601:         s2 << r3
1602:         if r3
1603:           s4, i4 = [], index
1604:           loop do
1605:             r5 = _nt_alphanumeric_char
1606:             if r5
1607:               s4 << r5
1608:             else
1609:               break
1610:             end
1611:           end
1612:           r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
1613:           s2 << r4
1614:         end
1615:         if s2.last
1616:           r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
1617:           r2.extend(Label0)
1618:         else
1619:           @index = i2
1620:           r2 = nil
1621:         end
1622:         s1 << r2
1623:         if r2
1624:           if has_terminal?(':', false, index)
1625:             r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
1626:             @index += 1
1627:           else
1628:             terminal_parse_failure(':')
1629:             r6 = nil
1630:           end
1631:           s1 << r6
1632:         end
1633:         if s1.last
1634:           r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
1635:           r1.extend(Label1)
1636:           r1.extend(Label2)
1637:         else
1638:           @index = i1
1639:           r1 = nil
1640:         end
1641:         if r1
1642:           r0 = r1
1643:         else
1644:           if has_terminal?('', false, index)
1645:             r7 = instantiate_node(SyntaxNode,input, index...(index + 0))
1646:             r7.extend(Label3)
1647:             @index += 0
1648:           else
1649:             terminal_parse_failure('')
1650:             r7 = nil
1651:           end
1652:           if r7
1653:             r0 = r7
1654:           else
1655:             @index = i0
1656:             r0 = nil
1657:           end
1658:         end
1659: 
1660:         node_cache[:label][start_index] = r0
1661: 
1662:         r0
1663:       end
_nt_labeled_sequence_primary() click to toggle source
      # File lib/treetop/compiler/metagrammar.rb, line 1532
1532:       def _nt_labeled_sequence_primary
1533:         start_index = index
1534:         if node_cache[:labeled_sequence_primary].has_key?(index)
1535:           cached = node_cache[:labeled_sequence_primary][index]
1536:           if cached
1537:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
1538:             @index = cached.interval.end
1539:           end
1540:           return cached
1541:         end
1542: 
1543:         i0, s0 = index, []
1544:         r1 = _nt_label
1545:         s0 << r1
1546:         if r1
1547:           r2 = _nt_sequence_primary
1548:           s0 << r2
1549:         end
1550:         if s0.last
1551:           r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
1552:           r0.extend(LabeledSequencePrimary0)
1553:           r0.extend(LabeledSequencePrimary1)
1554:         else
1555:           @index = i0
1556:           r0 = nil
1557:         end
1558: 
1559:         node_cache[:labeled_sequence_primary][start_index] = r0
1560: 
1561:         r0
1562:       end
_nt_module_declaration() click to toggle source
     # File lib/treetop/compiler/metagrammar.rb, line 305
305:       def _nt_module_declaration
306:         start_index = index
307:         if node_cache[:module_declaration].has_key?(index)
308:           cached = node_cache[:module_declaration][index]
309:           if cached
310:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
311:             @index = cached.interval.end
312:           end
313:           return cached
314:         end
315: 
316:         i0, s0 = index, []
317:         i1, s1 = index, []
318:         if has_terminal?('module', false, index)
319:           r2 = instantiate_node(SyntaxNode,input, index...(index + 6))
320:           @index += 6
321:         else
322:           terminal_parse_failure('module')
323:           r2 = nil
324:         end
325:         s1 << r2
326:         if r2
327:           r3 = _nt_space
328:           s1 << r3
329:           if r3
330:             i4, s4 = index, []
331:             if has_terminal?('\G[A-Z]', true, index)
332:               r5 = true
333:               @index += 1
334:             else
335:               r5 = nil
336:             end
337:             s4 << r5
338:             if r5
339:               s6, i6 = [], index
340:               loop do
341:                 r7 = _nt_alphanumeric_char
342:                 if r7
343:                   s6 << r7
344:                 else
345:                   break
346:                 end
347:               end
348:               r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
349:               s4 << r6
350:               if r6
351:                 s8, i8 = [], index
352:                 loop do
353:                   i9, s9 = index, []
354:                   if has_terminal?('::', false, index)
355:                     r10 = instantiate_node(SyntaxNode,input, index...(index + 2))
356:                     @index += 2
357:                   else
358:                     terminal_parse_failure('::')
359:                     r10 = nil
360:                   end
361:                   s9 << r10
362:                   if r10
363:                     if has_terminal?('\G[A-Z]', true, index)
364:                       r11 = true
365:                       @index += 1
366:                     else
367:                       r11 = nil
368:                     end
369:                     s9 << r11
370:                     if r11
371:                       s12, i12 = [], index
372:                       loop do
373:                         r13 = _nt_alphanumeric_char
374:                         if r13
375:                           s12 << r13
376:                         else
377:                           break
378:                         end
379:                       end
380:                       r12 = instantiate_node(SyntaxNode,input, i12...index, s12)
381:                       s9 << r12
382:                     end
383:                   end
384:                   if s9.last
385:                     r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
386:                     r9.extend(ModuleDeclaration0)
387:                   else
388:                     @index = i9
389:                     r9 = nil
390:                   end
391:                   if r9
392:                     s8 << r9
393:                   else
394:                     break
395:                   end
396:                 end
397:                 r8 = instantiate_node(SyntaxNode,input, i8...index, s8)
398:                 s4 << r8
399:               end
400:             end
401:             if s4.last
402:               r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
403:               r4.extend(ModuleDeclaration1)
404:             else
405:               @index = i4
406:               r4 = nil
407:             end
408:             s1 << r4
409:             if r4
410:               r14 = _nt_space
411:               s1 << r14
412:             end
413:           end
414:         end
415:         if s1.last
416:           r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
417:           r1.extend(ModuleDeclaration2)
418:         else
419:           @index = i1
420:           r1 = nil
421:         end
422:         s0 << r1
423:         if r1
424:           i15 = index
425:           r16 = _nt_module_declaration
426:           if r16
427:             r15 = r16
428:           else
429:             r17 = _nt_grammar
430:             if r17
431:               r15 = r17
432:             else
433:               @index = i15
434:               r15 = nil
435:             end
436:           end
437:           s0 << r15
438:           if r15
439:             i18, s18 = index, []
440:             r19 = _nt_space
441:             s18 << r19
442:             if r19
443:               if has_terminal?('end', false, index)
444:                 r20 = instantiate_node(SyntaxNode,input, index...(index + 3))
445:                 @index += 3
446:               else
447:                 terminal_parse_failure('end')
448:                 r20 = nil
449:               end
450:               s18 << r20
451:             end
452:             if s18.last
453:               r18 = instantiate_node(SyntaxNode,input, i18...index, s18)
454:               r18.extend(ModuleDeclaration3)
455:             else
456:               @index = i18
457:               r18 = nil
458:             end
459:             s0 << r18
460:           end
461:         end
462:         if s0.last
463:           r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
464:           r0.extend(ModuleDeclaration4)
465:           r0.extend(ModuleDeclaration5)
466:         else
467:           @index = i0
468:           r0 = nil
469:         end
470: 
471:         node_cache[:module_declaration][start_index] = r0
472: 
473:         r0
474:       end
_nt_module_or_grammar() click to toggle source
     # File lib/treetop/compiler/metagrammar.rb, line 224
224:       def _nt_module_or_grammar
225:         start_index = index
226:         if node_cache[:module_or_grammar].has_key?(index)
227:           cached = node_cache[:module_or_grammar][index]
228:           if cached
229:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
230:             @index = cached.interval.end
231:           end
232:           return cached
233:         end
234: 
235:         i0 = index
236:         r1 = _nt_module_declaration
237:         if r1
238:           r0 = r1
239:         else
240:           r2 = _nt_grammar
241:           if r2
242:             r0 = r2
243:           else
244:             @index = i0
245:             r0 = nil
246:           end
247:         end
248: 
249:         node_cache[:module_or_grammar][start_index] = r0
250: 
251:         r0
252:       end
_nt_node_class_declarations() click to toggle source
      # File lib/treetop/compiler/metagrammar.rb, line 1916
1916:       def _nt_node_class_declarations
1917:         start_index = index
1918:         if node_cache[:node_class_declarations].has_key?(index)
1919:           cached = node_cache[:node_class_declarations][index]
1920:           if cached
1921:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
1922:             @index = cached.interval.end
1923:           end
1924:           return cached
1925:         end
1926: 
1927:         i0, s0 = index, []
1928:         r1 = _nt_node_class_expression
1929:         s0 << r1
1930:         if r1
1931:           r2 = _nt_trailing_inline_module
1932:           s0 << r2
1933:         end
1934:         if s0.last
1935:           r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
1936:           r0.extend(NodeClassDeclarations0)
1937:           r0.extend(NodeClassDeclarations1)
1938:         else
1939:           @index = i0
1940:           r0 = nil
1941:         end
1942: 
1943:         node_cache[:node_class_declarations][start_index] = r0
1944: 
1945:         r0
1946:       end
_nt_node_class_expression() click to toggle source
      # File lib/treetop/compiler/metagrammar.rb, line 2872
2872:       def _nt_node_class_expression
2873:         start_index = index
2874:         if node_cache[:node_class_expression].has_key?(index)
2875:           cached = node_cache[:node_class_expression][index]
2876:           if cached
2877:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
2878:             @index = cached.interval.end
2879:           end
2880:           return cached
2881:         end
2882: 
2883:         i0 = index
2884:         i1, s1 = index, []
2885:         r2 = _nt_space
2886:         s1 << r2
2887:         if r2
2888:           if has_terminal?('<', false, index)
2889:             r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
2890:             @index += 1
2891:           else
2892:             terminal_parse_failure('<')
2893:             r3 = nil
2894:           end
2895:           s1 << r3
2896:           if r3
2897:             s4, i4 = [], index
2898:             loop do
2899:               i5, s5 = index, []
2900:               i6 = index
2901:               if has_terminal?('>', false, index)
2902:                 r7 = instantiate_node(SyntaxNode,input, index...(index + 1))
2903:                 @index += 1
2904:               else
2905:                 terminal_parse_failure('>')
2906:                 r7 = nil
2907:               end
2908:               if r7
2909:                 r6 = nil
2910:               else
2911:                 @index = i6
2912:                 r6 = instantiate_node(SyntaxNode,input, index...index)
2913:               end
2914:               s5 << r6
2915:               if r6
2916:                 if index < input_length
2917:                   r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
2918:                   @index += 1
2919:                 else
2920:                   terminal_parse_failure("any character")
2921:                   r8 = nil
2922:                 end
2923:                 s5 << r8
2924:               end
2925:               if s5.last
2926:                 r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
2927:                 r5.extend(NodeClassExpression0)
2928:               else
2929:                 @index = i5
2930:                 r5 = nil
2931:               end
2932:               if r5
2933:                 s4 << r5
2934:               else
2935:                 break
2936:               end
2937:             end
2938:             if s4.empty?
2939:               @index = i4
2940:               r4 = nil
2941:             else
2942:               r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
2943:             end
2944:             s1 << r4
2945:             if r4
2946:               if has_terminal?('>', false, index)
2947:                 r9 = instantiate_node(SyntaxNode,input, index...(index + 1))
2948:                 @index += 1
2949:               else
2950:                 terminal_parse_failure('>')
2951:                 r9 = nil
2952:               end
2953:               s1 << r9
2954:             end
2955:           end
2956:         end
2957:         if s1.last
2958:           r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
2959:           r1.extend(NodeClassExpression1)
2960:           r1.extend(NodeClassExpression2)
2961:         else
2962:           @index = i1
2963:           r1 = nil
2964:         end
2965:         if r1
2966:           r0 = r1
2967:         else
2968:           if has_terminal?('', false, index)
2969:             r10 = instantiate_node(SyntaxNode,input, index...(index + 0))
2970:             r10.extend(NodeClassExpression3)
2971:             @index += 0
2972:           else
2973:             terminal_parse_failure('')
2974:             r10 = nil
2975:           end
2976:           if r10
2977:             r0 = r10
2978:           else
2979:             @index = i0
2980:             r0 = nil
2981:           end
2982:         end
2983: 
2984:         node_cache[:node_class_expression][start_index] = r0
2985: 
2986:         r0
2987:       end
_nt_non_space_char() click to toggle source
      # File lib/treetop/compiler/metagrammar.rb, line 3290
3290:       def _nt_non_space_char
3291:         start_index = index
3292:         if node_cache[:non_space_char].has_key?(index)
3293:           cached = node_cache[:non_space_char][index]
3294:           if cached
3295:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
3296:             @index = cached.interval.end
3297:           end
3298:           return cached
3299:         end
3300: 
3301:         i0, s0 = index, []
3302:         i1 = index
3303:         r2 = _nt_space
3304:         if r2
3305:           r1 = nil
3306:         else
3307:           @index = i1
3308:           r1 = instantiate_node(SyntaxNode,input, index...index)
3309:         end
3310:         s0 << r1
3311:         if r1
3312:           if index < input_length
3313:             r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
3314:             @index += 1
3315:           else
3316:             terminal_parse_failure("any character")
3317:             r3 = nil
3318:           end
3319:           s0 << r3
3320:         end
3321:         if s0.last
3322:           r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
3323:           r0.extend(NonSpaceChar0)
3324:         else
3325:           @index = i0
3326:           r0 = nil
3327:         end
3328: 
3329:         node_cache[:non_space_char][start_index] = r0
3330: 
3331:         r0
3332:       end
_nt_nonterminal() click to toggle source
      # File lib/treetop/compiler/metagrammar.rb, line 2260
2260:       def _nt_nonterminal
2261:         start_index = index
2262:         if node_cache[:nonterminal].has_key?(index)
2263:           cached = node_cache[:nonterminal][index]
2264:           if cached
2265:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
2266:             @index = cached.interval.end
2267:           end
2268:           return cached
2269:         end
2270: 
2271:         i0, s0 = index, []
2272:         i1 = index
2273:         r2 = _nt_keyword_inside_grammar
2274:         if r2
2275:           r1 = nil
2276:         else
2277:           @index = i1
2278:           r1 = instantiate_node(SyntaxNode,input, index...index)
2279:         end
2280:         s0 << r1
2281:         if r1
2282:           i3, s3 = index, []
2283:           r4 = _nt_alpha_char
2284:           s3 << r4
2285:           if r4
2286:             s5, i5 = [], index
2287:             loop do
2288:               r6 = _nt_alphanumeric_char
2289:               if r6
2290:                 s5 << r6
2291:               else
2292:                 break
2293:               end
2294:             end
2295:             r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
2296:             s3 << r5
2297:           end
2298:           if s3.last
2299:             r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
2300:             r3.extend(Nonterminal0)
2301:           else
2302:             @index = i3
2303:             r3 = nil
2304:           end
2305:           s0 << r3
2306:         end
2307:         if s0.last
2308:           r0 = instantiate_node(Nonterminal,input, i0...index, s0)
2309:           r0.extend(Nonterminal1)
2310:         else
2311:           @index = i0
2312:           r0 = nil
2313:         end
2314: 
2315:         node_cache[:nonterminal][start_index] = r0
2316: 
2317:         r0
2318:       end
_nt_occurrence_range() click to toggle source
      # File lib/treetop/compiler/metagrammar.rb, line 2005
2005:       def _nt_occurrence_range
2006:         start_index = index
2007:         if node_cache[:occurrence_range].has_key?(index)
2008:           cached = node_cache[:occurrence_range][index]
2009:           if cached
2010:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
2011:             @index = cached.interval.end
2012:           end
2013:           return cached
2014:         end
2015: 
2016:         i0, s0 = index, []
2017:         r2 = _nt_space
2018:         if r2
2019:           r1 = r2
2020:         else
2021:           r1 = instantiate_node(SyntaxNode,input, index...index)
2022:         end
2023:         s0 << r1
2024:         if r1
2025:           s3, i3 = [], index
2026:           loop do
2027:             if has_terminal?('\G[0-9]', true, index)
2028:               r4 = true
2029:               @index += 1
2030:             else
2031:               r4 = nil
2032:             end
2033:             if r4
2034:               s3 << r4
2035:             else
2036:               break
2037:             end
2038:           end
2039:           r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
2040:           s0 << r3
2041:           if r3
2042:             if has_terminal?('..', false, index)
2043:               r5 = instantiate_node(SyntaxNode,input, index...(index + 2))
2044:               @index += 2
2045:             else
2046:               terminal_parse_failure('..')
2047:               r5 = nil
2048:             end
2049:             s0 << r5
2050:             if r5
2051:               s6, i6 = [], index
2052:               loop do
2053:                 if has_terminal?('\G[0-9]', true, index)
2054:                   r7 = true
2055:                   @index += 1
2056:                 else
2057:                   r7 = nil
2058:                 end
2059:                 if r7
2060:                   s6 << r7
2061:                 else
2062:                   break
2063:                 end
2064:               end
2065:               r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
2066:               s0 << r6
2067:             end
2068:           end
2069:         end
2070:         if s0.last
2071:           r0 = instantiate_node(OccurrenceRange,input, i0...index, s0)
2072:           r0.extend(OccurrenceRange0)
2073:         else
2074:           @index = i0
2075:           r0 = nil
2076:         end
2077: 
2078:         node_cache[:occurrence_range][start_index] = r0
2079: 
2080:         r0
2081:       end
_nt_optional_suffix() click to toggle source
      # File lib/treetop/compiler/metagrammar.rb, line 1864
1864:       def _nt_optional_suffix
1865:         start_index = index
1866:         if node_cache[:optional_suffix].has_key?(index)
1867:           cached = node_cache[:optional_suffix][index]
1868:           if cached
1869:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
1870:             @index = cached.interval.end
1871:           end
1872:           return cached
1873:         end
1874: 
1875:         if has_terminal?('?', false, index)
1876:           r0 = instantiate_node(Optional,input, index...(index + 1))
1877:           @index += 1
1878:         else
1879:           terminal_parse_failure('?')
1880:           r0 = nil
1881:         end
1882: 
1883:         node_cache[:optional_suffix][start_index] = r0
1884: 
1885:         r0
1886:       end
_nt_parenthesized_expression() click to toggle source
      # File lib/treetop/compiler/metagrammar.rb, line 2184
2184:       def _nt_parenthesized_expression
2185:         start_index = index
2186:         if node_cache[:parenthesized_expression].has_key?(index)
2187:           cached = node_cache[:parenthesized_expression][index]
2188:           if cached
2189:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
2190:             @index = cached.interval.end
2191:           end
2192:           return cached
2193:         end
2194: 
2195:         i0, s0 = index, []
2196:         if has_terminal?('(', false, index)
2197:           r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
2198:           @index += 1
2199:         else
2200:           terminal_parse_failure('(')
2201:           r1 = nil
2202:         end
2203:         s0 << r1
2204:         if r1
2205:           r3 = _nt_space
2206:           if r3
2207:             r2 = r3
2208:           else
2209:             r2 = instantiate_node(SyntaxNode,input, index...index)
2210:           end
2211:           s0 << r2
2212:           if r2
2213:             r4 = _nt_parsing_expression
2214:             s0 << r4
2215:             if r4
2216:               r6 = _nt_space
2217:               if r6
2218:                 r5 = r6
2219:               else
2220:                 r5 = instantiate_node(SyntaxNode,input, index...index)
2221:               end
2222:               s0 << r5
2223:               if r5
2224:                 if has_terminal?(')', false, index)
2225:                   r7 = instantiate_node(SyntaxNode,input, index...(index + 1))
2226:                   @index += 1
2227:                 else
2228:                   terminal_parse_failure(')')
2229:                   r7 = nil
2230:                 end
2231:                 s0 << r7
2232:               end
2233:             end
2234:           end
2235:         end
2236:         if s0.last
2237:           r0 = instantiate_node(ParenthesizedExpression,input, i0...index, s0)
2238:           r0.extend(ParenthesizedExpression0)
2239:           r0.extend(ParenthesizedExpression1)
2240:         else
2241:           @index = i0
2242:           r0 = nil
2243:         end
2244: 
2245:         node_cache[:parenthesized_expression][start_index] = r0
2246: 
2247:         r0
2248:       end
_nt_parsing_expression() click to toggle source
      # File lib/treetop/compiler/metagrammar.rb, line 994
 994:       def _nt_parsing_expression
 995:         start_index = index
 996:         if node_cache[:parsing_expression].has_key?(index)
 997:           cached = node_cache[:parsing_expression][index]
 998:           if cached
 999:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
1000:             @index = cached.interval.end
1001:           end
1002:           return cached
1003:         end
1004: 
1005:         i0 = index
1006:         r1 = _nt_choice
1007:         if r1
1008:           r0 = r1
1009:         else
1010:           r2 = _nt_sequence
1011:           if r2
1012:             r0 = r2
1013:           else
1014:             r3 = _nt_primary
1015:             if r3
1016:               r0 = r3
1017:             else
1018:               @index = i0
1019:               r0 = nil
1020:             end
1021:           end
1022:         end
1023: 
1024:         node_cache[:parsing_expression][start_index] = r0
1025: 
1026:         r0
1027:       end
_nt_parsing_rule() click to toggle source
     # File lib/treetop/compiler/metagrammar.rb, line 903
903:       def _nt_parsing_rule
904:         start_index = index
905:         if node_cache[:parsing_rule].has_key?(index)
906:           cached = node_cache[:parsing_rule][index]
907:           if cached
908:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
909:             @index = cached.interval.end
910:           end
911:           return cached
912:         end
913: 
914:         i0, s0 = index, []
915:         if has_terminal?('rule', false, index)
916:           r1 = instantiate_node(SyntaxNode,input, index...(index + 4))
917:           @index += 4
918:         else
919:           terminal_parse_failure('rule')
920:           r1 = nil
921:         end
922:         s0 << r1
923:         if r1
924:           r2 = _nt_space
925:           s0 << r2
926:           if r2
927:             r3 = _nt_nonterminal
928:             s0 << r3
929:             if r3
930:               r4 = _nt_space
931:               s0 << r4
932:               if r4
933:                 i6, s6 = index, []
934:                 if has_terminal?('do', false, index)
935:                   r7 = instantiate_node(SyntaxNode,input, index...(index + 2))
936:                   @index += 2
937:                 else
938:                   terminal_parse_failure('do')
939:                   r7 = nil
940:                 end
941:                 s6 << r7
942:                 if r7
943:                   r8 = _nt_space
944:                   s6 << r8
945:                 end
946:                 if s6.last
947:                   r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
948:                   r6.extend(ParsingRule0)
949:                 else
950:                   @index = i6
951:                   r6 = nil
952:                 end
953:                 if r6
954:                   r5 = r6
955:                 else
956:                   r5 = instantiate_node(SyntaxNode,input, index...index)
957:                 end
958:                 s0 << r5
959:                 if r5
960:                   r9 = _nt_parsing_expression
961:                   s0 << r9
962:                   if r9
963:                     r10 = _nt_space
964:                     s0 << r10
965:                     if r10
966:                       if has_terminal?('end', false, index)
967:                         r11 = instantiate_node(SyntaxNode,input, index...(index + 3))
968:                         @index += 3
969:                       else
970:                         terminal_parse_failure('end')
971:                         r11 = nil
972:                       end
973:                       s0 << r11
974:                     end
975:                   end
976:                 end
977:               end
978:             end
979:           end
980:         end
981:         if s0.last
982:           r0 = instantiate_node(ParsingRule,input, i0...index, s0)
983:           r0.extend(ParsingRule1)
984:         else
985:           @index = i0
986:           r0 = nil
987:         end
988: 
989:         node_cache[:parsing_rule][start_index] = r0
990: 
991:         r0
992:       end
_nt_predicate_block() click to toggle source
      # File lib/treetop/compiler/metagrammar.rb, line 3080
3080:       def _nt_predicate_block
3081:         start_index = index
3082:         if node_cache[:predicate_block].has_key?(index)
3083:           cached = node_cache[:predicate_block][index]
3084:           if cached
3085:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
3086:             @index = cached.interval.end
3087:           end
3088:           return cached
3089:         end
3090: 
3091:         i0, s0 = index, []
3092:         if has_terminal?('', false, index)
3093:           r1 = instantiate_node(SyntaxNode,input, index...(index + 0))
3094:           @index += 0
3095:         else
3096:           terminal_parse_failure('')
3097:           r1 = nil
3098:         end
3099:         s0 << r1
3100:         if r1
3101:           r2 = _nt_inline_module
3102:           s0 << r2
3103:         end
3104:         if s0.last
3105:           r0 = instantiate_node(PredicateBlock,input, i0...index, s0)
3106:           r0.extend(PredicateBlock0)
3107:         else
3108:           @index = i0
3109:           r0 = nil
3110:         end
3111: 
3112:         node_cache[:predicate_block][start_index] = r0
3113: 
3114:         r0
3115:       end
_nt_prefix() click to toggle source
      # File lib/treetop/compiler/metagrammar.rb, line 2083
2083:       def _nt_prefix
2084:         start_index = index
2085:         if node_cache[:prefix].has_key?(index)
2086:           cached = node_cache[:prefix][index]
2087:           if cached
2088:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
2089:             @index = cached.interval.end
2090:           end
2091:           return cached
2092:         end
2093: 
2094:         i0 = index
2095:         if has_terminal?('&', false, index)
2096:           r1 = instantiate_node(AndPredicate,input, index...(index + 1))
2097:           @index += 1
2098:         else
2099:           terminal_parse_failure('&')
2100:           r1 = nil
2101:         end
2102:         if r1
2103:           r0 = r1
2104:         else
2105:           if has_terminal?('!', false, index)
2106:             r2 = instantiate_node(NotPredicate,input, index...(index + 1))
2107:             @index += 1
2108:           else
2109:             terminal_parse_failure('!')
2110:             r2 = nil
2111:           end
2112:           if r2
2113:             r0 = r2
2114:           else
2115:             if has_terminal?('~', false, index)
2116:               r3 = instantiate_node(TransientPrefix,input, index...(index + 1))
2117:               @index += 1
2118:             else
2119:               terminal_parse_failure('~')
2120:               r3 = nil
2121:             end
2122:             if r3
2123:               r0 = r3
2124:             else
2125:               @index = i0
2126:               r0 = nil
2127:             end
2128:           end
2129:         end
2130: 
2131:         node_cache[:prefix][start_index] = r0
2132: 
2133:         r0
2134:       end
_nt_primary() click to toggle source
      # File lib/treetop/compiler/metagrammar.rb, line 1393
1393:       def _nt_primary
1394:         start_index = index
1395:         if node_cache[:primary].has_key?(index)
1396:           cached = node_cache[:primary][index]
1397:           if cached
1398:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
1399:             @index = cached.interval.end
1400:           end
1401:           return cached
1402:         end
1403: 
1404:         i0 = index
1405:         i1, s1 = index, []
1406:         r2 = _nt_prefix
1407:         s1 << r2
1408:         if r2
1409:           r3 = _nt_atomic
1410:           s1 << r3
1411:         end
1412:         if s1.last
1413:           r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
1414:           r1.extend(Primary0)
1415:           r1.extend(Primary1)
1416:         else
1417:           @index = i1
1418:           r1 = nil
1419:         end
1420:         if r1
1421:           r0 = r1
1422:         else
1423:           i4, s4 = index, []
1424:           r5 = _nt_prefix
1425:           s4 << r5
1426:           if r5
1427:             r7 = _nt_space
1428:             if r7
1429:               r6 = r7
1430:             else
1431:               r6 = instantiate_node(SyntaxNode,input, index...index)
1432:             end
1433:             s4 << r6
1434:             if r6
1435:               r8 = _nt_predicate_block
1436:               s4 << r8
1437:             end
1438:           end
1439:           if s4.last
1440:             r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
1441:             r4.extend(Primary2)
1442:             r4.extend(Primary3)
1443:           else
1444:             @index = i4
1445:             r4 = nil
1446:           end
1447:           if r4
1448:             r0 = r4
1449:           else
1450:             i9, s9 = index, []
1451:             r10 = _nt_atomic
1452:             s9 << r10
1453:             if r10
1454:               r11 = _nt_suffix
1455:               s9 << r11
1456:               if r11
1457:                 r12 = _nt_node_class_declarations
1458:                 s9 << r12
1459:               end
1460:             end
1461:             if s9.last
1462:               r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
1463:               r9.extend(Primary4)
1464:               r9.extend(Primary5)
1465:             else
1466:               @index = i9
1467:               r9 = nil
1468:             end
1469:             if r9
1470:               r0 = r9
1471:             else
1472:               i13, s13 = index, []
1473:               r14 = _nt_atomic
1474:               s13 << r14
1475:               if r14
1476:                 r15 = _nt_node_class_declarations
1477:                 s13 << r15
1478:               end
1479:               if s13.last
1480:                 r13 = instantiate_node(SyntaxNode,input, i13...index, s13)
1481:                 r13.extend(Primary6)
1482:                 r13.extend(Primary7)
1483:               else
1484:                 @index = i13
1485:                 r13 = nil
1486:               end
1487:               if r13
1488:                 r0 = r13
1489:               else
1490:                 @index = i0
1491:                 r0 = nil
1492:               end
1493:             end
1494:           end
1495:         end
1496: 
1497:         node_cache[:primary][start_index] = r0
1498: 
1499:         r0
1500:       end
_nt_quoted_string() click to toggle source
      # File lib/treetop/compiler/metagrammar.rb, line 2361
2361:       def _nt_quoted_string
2362:         start_index = index
2363:         if node_cache[:quoted_string].has_key?(index)
2364:           cached = node_cache[:quoted_string][index]
2365:           if cached
2366:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
2367:             @index = cached.interval.end
2368:           end
2369:           return cached
2370:         end
2371: 
2372:         i0 = index
2373:         r1 = _nt_single_quoted_string
2374:         if r1
2375:           r0 = r1
2376:           r0.extend(QuotedString0)
2377:         else
2378:           r2 = _nt_double_quoted_string
2379:           if r2
2380:             r0 = r2
2381:             r0.extend(QuotedString0)
2382:           else
2383:             @index = i0
2384:             r0 = nil
2385:           end
2386:         end
2387: 
2388:         node_cache[:quoted_string][start_index] = r0
2389: 
2390:         r0
2391:       end
_nt_repetition_suffix() click to toggle source
      # File lib/treetop/compiler/metagrammar.rb, line 1948
1948:       def _nt_repetition_suffix
1949:         start_index = index
1950:         if node_cache[:repetition_suffix].has_key?(index)
1951:           cached = node_cache[:repetition_suffix][index]
1952:           if cached
1953:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
1954:             @index = cached.interval.end
1955:           end
1956:           return cached
1957:         end
1958: 
1959:         i0 = index
1960:         if has_terminal?('+', false, index)
1961:           r1 = instantiate_node(OneOrMore,input, index...(index + 1))
1962:           @index += 1
1963:         else
1964:           terminal_parse_failure('+')
1965:           r1 = nil
1966:         end
1967:         if r1
1968:           r0 = r1
1969:         else
1970:           if has_terminal?('*', false, index)
1971:             r2 = instantiate_node(ZeroOrMore,input, index...(index + 1))
1972:             @index += 1
1973:           else
1974:             terminal_parse_failure('*')
1975:             r2 = nil
1976:           end
1977:           if r2
1978:             r0 = r2
1979:           else
1980:             r3 = _nt_occurrence_range
1981:             if r3
1982:               r0 = r3
1983:             else
1984:               @index = i0
1985:               r0 = nil
1986:             end
1987:           end
1988:         end
1989: 
1990:         node_cache[:repetition_suffix][start_index] = r0
1991: 
1992:         r0
1993:       end
_nt_require_statement() click to toggle source
     # File lib/treetop/compiler/metagrammar.rb, line 127
127:       def _nt_require_statement
128:         start_index = index
129:         if node_cache[:require_statement].has_key?(index)
130:           cached = node_cache[:require_statement][index]
131:           if cached
132:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
133:             @index = cached.interval.end
134:           end
135:           return cached
136:         end
137: 
138:         i0, s0 = index, []
139:         r2 = _nt_space
140:         if r2
141:           r1 = r2
142:         else
143:           r1 = instantiate_node(SyntaxNode,input, index...index)
144:         end
145:         s0 << r1
146:         if r1
147:           if has_terminal?("require", false, index)
148:             r3 = instantiate_node(SyntaxNode,input, index...(index + 7))
149:             @index += 7
150:           else
151:             terminal_parse_failure("require")
152:             r3 = nil
153:           end
154:           s0 << r3
155:           if r3
156:             s4, i4 = [], index
157:             loop do
158:               if has_terminal?('\G[ \t]', true, index)
159:                 r5 = true
160:                 @index += 1
161:               else
162:                 r5 = nil
163:               end
164:               if r5
165:                 s4 << r5
166:               else
167:                 break
168:               end
169:             end
170:             if s4.empty?
171:               @index = i4
172:               r4 = nil
173:             else
174:               r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
175:             end
176:             s0 << r4
177:             if r4
178:               s6, i6 = [], index
179:               loop do
180:                 if has_terminal?('\G[^\n\r]', true, index)
181:                   r7 = true
182:                   @index += 1
183:                 else
184:                   r7 = nil
185:                 end
186:                 if r7
187:                   s6 << r7
188:                 else
189:                   break
190:                 end
191:               end
192:               if s6.empty?
193:                 @index = i6
194:                 r6 = nil
195:               else
196:                 r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
197:               end
198:               s0 << r6
199:               if r6
200:                 if has_terminal?('\G[\n\r]', true, index)
201:                   r8 = true
202:                   @index += 1
203:                 else
204:                   r8 = nil
205:                 end
206:                 s0 << r8
207:               end
208:             end
209:           end
210:         end
211:         if s0.last
212:           r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
213:           r0.extend(RequireStatement0)
214:         else
215:           @index = i0
216:           r0 = nil
217:         end
218: 
219:         node_cache[:require_statement][start_index] = r0
220: 
221:         r0
222:       end
_nt_sequence() click to toggle source
      # File lib/treetop/compiler/metagrammar.rb, line 1186
1186:       def _nt_sequence
1187:         start_index = index
1188:         if node_cache[:sequence].has_key?(index)
1189:           cached = node_cache[:sequence][index]
1190:           if cached
1191:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
1192:             @index = cached.interval.end
1193:           end
1194:           return cached
1195:         end
1196: 
1197:         i0, s0 = index, []
1198:         r1 = _nt_labeled_sequence_primary
1199:         s0 << r1
1200:         if r1
1201:           s2, i2 = [], index
1202:           loop do
1203:             i3, s3 = index, []
1204:             r4 = _nt_space
1205:             s3 << r4
1206:             if r4
1207:               r5 = _nt_labeled_sequence_primary
1208:               s3 << r5
1209:             end
1210:             if s3.last
1211:               r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
1212:               r3.extend(Sequence0)
1213:             else
1214:               @index = i3
1215:               r3 = nil
1216:             end
1217:             if r3
1218:               s2 << r3
1219:             else
1220:               break
1221:             end
1222:           end
1223:           if s2.empty?
1224:             @index = i2
1225:             r2 = nil
1226:           else
1227:             r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
1228:           end
1229:           s0 << r2
1230:           if r2
1231:             r6 = _nt_node_class_declarations
1232:             s0 << r6
1233:           end
1234:         end
1235:         if s0.last
1236:           r0 = instantiate_node(Sequence,input, i0...index, s0)
1237:           r0.extend(Sequence1)
1238:           r0.extend(Sequence2)
1239:         else
1240:           @index = i0
1241:           r0 = nil
1242:         end
1243: 
1244:         node_cache[:sequence][start_index] = r0
1245: 
1246:         r0
1247:       end
_nt_sequence_primary() click to toggle source
      # File lib/treetop/compiler/metagrammar.rb, line 1743
1743:       def _nt_sequence_primary
1744:         start_index = index
1745:         if node_cache[:sequence_primary].has_key?(index)
1746:           cached = node_cache[:sequence_primary][index]
1747:           if cached
1748:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
1749:             @index = cached.interval.end
1750:           end
1751:           return cached
1752:         end
1753: 
1754:         i0 = index
1755:         i1, s1 = index, []
1756:         r2 = _nt_prefix
1757:         s1 << r2
1758:         if r2
1759:           r3 = _nt_atomic
1760:           s1 << r3
1761:         end
1762:         if s1.last
1763:           r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
1764:           r1.extend(SequencePrimary0)
1765:           r1.extend(SequencePrimary1)
1766:         else
1767:           @index = i1
1768:           r1 = nil
1769:         end
1770:         if r1
1771:           r0 = r1
1772:         else
1773:           i4, s4 = index, []
1774:           r5 = _nt_prefix
1775:           s4 << r5
1776:           if r5
1777:             r7 = _nt_space
1778:             if r7
1779:               r6 = r7
1780:             else
1781:               r6 = instantiate_node(SyntaxNode,input, index...index)
1782:             end
1783:             s4 << r6
1784:             if r6
1785:               r8 = _nt_predicate_block
1786:               s4 << r8
1787:             end
1788:           end
1789:           if s4.last
1790:             r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
1791:             r4.extend(SequencePrimary2)
1792:             r4.extend(SequencePrimary3)
1793:           else
1794:             @index = i4
1795:             r4 = nil
1796:           end
1797:           if r4
1798:             r0 = r4
1799:           else
1800:             i9, s9 = index, []
1801:             r10 = _nt_atomic
1802:             s9 << r10
1803:             if r10
1804:               r11 = _nt_suffix
1805:               s9 << r11
1806:             end
1807:             if s9.last
1808:               r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
1809:               r9.extend(SequencePrimary4)
1810:               r9.extend(SequencePrimary5)
1811:             else
1812:               @index = i9
1813:               r9 = nil
1814:             end
1815:             if r9
1816:               r0 = r9
1817:             else
1818:               r12 = _nt_atomic
1819:               if r12
1820:                 r0 = r12
1821:               else
1822:                 @index = i0
1823:                 r0 = nil
1824:               end
1825:             end
1826:           end
1827:         end
1828: 
1829:         node_cache[:sequence_primary][start_index] = r0
1830: 
1831:         r0
1832:       end
_nt_single_quoted_string() click to toggle source
      # File lib/treetop/compiler/metagrammar.rb, line 2530
2530:       def _nt_single_quoted_string
2531:         start_index = index
2532:         if node_cache[:single_quoted_string].has_key?(index)
2533:           cached = node_cache[:single_quoted_string][index]
2534:           if cached
2535:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
2536:             @index = cached.interval.end
2537:           end
2538:           return cached
2539:         end
2540: 
2541:         i0, s0 = index, []
2542:         if has_terminal?("'", false, index)
2543:           r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
2544:           @index += 1
2545:         else
2546:           terminal_parse_failure("'")
2547:           r1 = nil
2548:         end
2549:         s0 << r1
2550:         if r1
2551:           s2, i2 = [], index
2552:           loop do
2553:             i3, s3 = index, []
2554:             i4 = index
2555:             if has_terminal?("'", false, index)
2556:               r5 = instantiate_node(SyntaxNode,input, index...(index + 1))
2557:               @index += 1
2558:             else
2559:               terminal_parse_failure("'")
2560:               r5 = nil
2561:             end
2562:             if r5
2563:               r4 = nil
2564:             else
2565:               @index = i4
2566:               r4 = instantiate_node(SyntaxNode,input, index...index)
2567:             end
2568:             s3 << r4
2569:             if r4
2570:               i6 = index
2571:               if has_terminal?("\\\\", false, index)
2572:                 r7 = instantiate_node(SyntaxNode,input, index...(index + 2))
2573:                 @index += 2
2574:               else
2575:                 terminal_parse_failure("\\\\")
2576:                 r7 = nil
2577:               end
2578:               if r7
2579:                 r6 = r7
2580:               else
2581:                 if has_terminal?("\\'", false, index)
2582:                   r8 = instantiate_node(SyntaxNode,input, index...(index + 2))
2583:                   @index += 2
2584:                 else
2585:                   terminal_parse_failure("\\'")
2586:                   r8 = nil
2587:                 end
2588:                 if r8
2589:                   r6 = r8
2590:                 else
2591:                   if index < input_length
2592:                     r9 = instantiate_node(SyntaxNode,input, index...(index + 1))
2593:                     @index += 1
2594:                   else
2595:                     terminal_parse_failure("any character")
2596:                     r9 = nil
2597:                   end
2598:                   if r9
2599:                     r6 = r9
2600:                   else
2601:                     @index = i6
2602:                     r6 = nil
2603:                   end
2604:                 end
2605:               end
2606:               s3 << r6
2607:             end
2608:             if s3.last
2609:               r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
2610:               r3.extend(SingleQuotedString0)
2611:             else
2612:               @index = i3
2613:               r3 = nil
2614:             end
2615:             if r3
2616:               s2 << r3
2617:             else
2618:               break
2619:             end
2620:           end
2621:           r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
2622:           s0 << r2
2623:           if r2
2624:             if has_terminal?("'", false, index)
2625:               r10 = instantiate_node(SyntaxNode,input, index...(index + 1))
2626:               @index += 1
2627:             else
2628:               terminal_parse_failure("'")
2629:               r10 = nil
2630:             end
2631:             s0 << r10
2632:           end
2633:         end
2634:         if s0.last
2635:           r0 = instantiate_node(Terminal,input, i0...index, s0)
2636:           r0.extend(SingleQuotedString1)
2637:         else
2638:           @index = i0
2639:           r0 = nil
2640:         end
2641: 
2642:         node_cache[:single_quoted_string][start_index] = r0
2643: 
2644:         r0
2645:       end
_nt_space() click to toggle source
      # File lib/treetop/compiler/metagrammar.rb, line 3392
3392:       def _nt_space
3393:         start_index = index
3394:         if node_cache[:space].has_key?(index)
3395:           cached = node_cache[:space][index]
3396:           if cached
3397:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
3398:             @index = cached.interval.end
3399:           end
3400:           return cached
3401:         end
3402: 
3403:         s0, i0 = [], index
3404:         loop do
3405:           i1 = index
3406:           r2 = _nt_white
3407:           if r2
3408:             r1 = r2
3409:           else
3410:             r3 = _nt_comment_to_eol
3411:             if r3
3412:               r1 = r3
3413:             else
3414:               @index = i1
3415:               r1 = nil
3416:             end
3417:           end
3418:           if r1
3419:             s0 << r1
3420:           else
3421:             break
3422:           end
3423:         end
3424:         if s0.empty?
3425:           @index = i0
3426:           r0 = nil
3427:         else
3428:           r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
3429:         end
3430: 
3431:         node_cache[:space][start_index] = r0
3432: 
3433:         r0
3434:       end
_nt_suffix() click to toggle source
      # File lib/treetop/compiler/metagrammar.rb, line 1834
1834:       def _nt_suffix
1835:         start_index = index
1836:         if node_cache[:suffix].has_key?(index)
1837:           cached = node_cache[:suffix][index]
1838:           if cached
1839:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
1840:             @index = cached.interval.end
1841:           end
1842:           return cached
1843:         end
1844: 
1845:         i0 = index
1846:         r1 = _nt_repetition_suffix
1847:         if r1
1848:           r0 = r1
1849:         else
1850:           r2 = _nt_optional_suffix
1851:           if r2
1852:             r0 = r2
1853:           else
1854:             @index = i0
1855:             r0 = nil
1856:           end
1857:         end
1858: 
1859:         node_cache[:suffix][start_index] = r0
1860: 
1861:         r0
1862:       end
_nt_terminal() click to toggle source
      # File lib/treetop/compiler/metagrammar.rb, line 2320
2320:       def _nt_terminal
2321:         start_index = index
2322:         if node_cache[:terminal].has_key?(index)
2323:           cached = node_cache[:terminal][index]
2324:           if cached
2325:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
2326:             @index = cached.interval.end
2327:           end
2328:           return cached
2329:         end
2330: 
2331:         i0 = index
2332:         r1 = _nt_quoted_string
2333:         if r1
2334:           r0 = r1
2335:         else
2336:           r2 = _nt_character_class
2337:           if r2
2338:             r0 = r2
2339:           else
2340:             r3 = _nt_anything_symbol
2341:             if r3
2342:               r0 = r3
2343:             else
2344:               @index = i0
2345:               r0 = nil
2346:             end
2347:           end
2348:         end
2349: 
2350:         node_cache[:terminal][start_index] = r0
2351: 
2352:         r0
2353:       end
_nt_trailing_inline_module() click to toggle source
      # File lib/treetop/compiler/metagrammar.rb, line 3023
3023:       def _nt_trailing_inline_module
3024:         start_index = index
3025:         if node_cache[:trailing_inline_module].has_key?(index)
3026:           cached = node_cache[:trailing_inline_module][index]
3027:           if cached
3028:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
3029:             @index = cached.interval.end
3030:           end
3031:           return cached
3032:         end
3033: 
3034:         i0 = index
3035:         i1, s1 = index, []
3036:         r2 = _nt_space
3037:         s1 << r2
3038:         if r2
3039:           r3 = _nt_inline_module
3040:           s1 << r3
3041:         end
3042:         if s1.last
3043:           r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
3044:           r1.extend(TrailingInlineModule0)
3045:           r1.extend(TrailingInlineModule1)
3046:         else
3047:           @index = i1
3048:           r1 = nil
3049:         end
3050:         if r1
3051:           r0 = r1
3052:         else
3053:           if has_terminal?('', false, index)
3054:             r4 = instantiate_node(SyntaxNode,input, index...(index + 0))
3055:             r4.extend(TrailingInlineModule2)
3056:             @index += 0
3057:           else
3058:             terminal_parse_failure('')
3059:             r4 = nil
3060:           end
3061:           if r4
3062:             r0 = r4
3063:           else
3064:             @index = i0
3065:             r0 = nil
3066:           end
3067:         end
3068: 
3069:         node_cache[:trailing_inline_module][start_index] = r0
3070: 
3071:         r0
3072:       end
_nt_treetop_file() click to toggle source
     # File lib/treetop/compiler/metagrammar.rb, line 43
 43:       def _nt_treetop_file
 44:         start_index = index
 45:         if node_cache[:treetop_file].has_key?(index)
 46:           cached = node_cache[:treetop_file][index]
 47:           if cached
 48:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
 49:             @index = cached.interval.end
 50:           end
 51:           return cached
 52:         end
 53: 
 54:         i0, s0 = index, []
 55:         s1, i1 = [], index
 56:         loop do
 57:           i2, s2 = index, []
 58:           r4 = _nt_space
 59:           if r4
 60:             r3 = r4
 61:           else
 62:             r3 = instantiate_node(SyntaxNode,input, index...index)
 63:           end
 64:           s2 << r3
 65:           if r3
 66:             r5 = _nt_require_statement
 67:             s2 << r5
 68:           end
 69:           if s2.last
 70:             r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
 71:             r2.extend(TreetopFile0)
 72:           else
 73:             @index = i2
 74:             r2 = nil
 75:           end
 76:           if r2
 77:             s1 << r2
 78:           else
 79:             break
 80:           end
 81:         end
 82:         r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
 83:         s0 << r1
 84:         if r1
 85:           r7 = _nt_space
 86:           if r7
 87:             r6 = r7
 88:           else
 89:             r6 = instantiate_node(SyntaxNode,input, index...index)
 90:           end
 91:           s0 << r6
 92:           if r6
 93:             r8 = _nt_module_or_grammar
 94:             s0 << r8
 95:             if r8
 96:               r10 = _nt_space
 97:               if r10
 98:                 r9 = r10
 99:               else
100:                 r9 = instantiate_node(SyntaxNode,input, index...index)
101:               end
102:               s0 << r9
103:             end
104:           end
105:         end
106:         if s0.last
107:           r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
108:           r0.extend(TreetopFile1)
109:           r0.extend(TreetopFile2)
110:         else
111:           @index = i0
112:           r0 = nil
113:         end
114: 
115:         node_cache[:treetop_file][start_index] = r0
116: 
117:         r0
118:       end
_nt_white() click to toggle source
      # File lib/treetop/compiler/metagrammar.rb, line 3520
3520:       def _nt_white
3521:         start_index = index
3522:         if node_cache[:white].has_key?(index)
3523:           cached = node_cache[:white][index]
3524:           if cached
3525:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
3526:             @index = cached.interval.end
3527:           end
3528:           return cached
3529:         end
3530: 
3531:         if has_terminal?('\G[ \t\n\r]', true, index)
3532:           r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
3533:           @index += 1
3534:         else
3535:           r0 = nil
3536:         end
3537: 
3538:         node_cache[:white][start_index] = r0
3539: 
3540:         r0
3541:       end
root() click to toggle source
    # File lib/treetop/compiler/metagrammar.rb, line 9
 9:       def root
10:         @root ||= :treetop_file
11:       end

Disabled; run with --debug to generate this.

[Validate]

Generated with the Darkfish Rdoc Generator 1.1.6.