Treetop::Compiler::Metagrammar

      # File lib/treetop/compiler/metagrammar.rb, line 3243
3243:       def _nt_alpha_char
3244:         start_index = index
3245:         if node_cache[:alpha_char].has_key?(index)
3246:           cached = node_cache[:alpha_char][index]
3247:           if cached
3248:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
3249:             @index = cached.interval.end
3250:           end
3251:           return cached
3252:         end
3253: 
3254:         if has_terminal?('\G[A-Za-z_]', true, index)
3255:           r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
3256:           @index += 1
3257:         else
3258:           r0 = nil
3259:         end
3260: 
3261:         node_cache[:alpha_char][start_index] = r0
3262: 
3263:         r0
3264:       end

      # File lib/treetop/compiler/metagrammar.rb, line 3266
3266:       def _nt_alphanumeric_char
3267:         start_index = index
3268:         if node_cache[:alphanumeric_char].has_key?(index)
3269:           cached = node_cache[:alphanumeric_char][index]
3270:           if cached
3271:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
3272:             @index = cached.interval.end
3273:           end
3274:           return cached
3275:         end
3276: 
3277:         i0 = index
3278:         r1 = _nt_alpha_char
3279:         if r1
3280:           r0 = r1
3281:         else
3282:           if has_terminal?('\G[0-9]', true, index)
3283:             r2 = true
3284:             @index += 1
3285:           else
3286:             r2 = nil
3287:           end
3288:           if r2
3289:             r0 = r2
3290:           else
3291:             @index = i0
3292:             r0 = nil
3293:           end
3294:         end
3295: 
3296:         node_cache[:alphanumeric_char][start_index] = r0
3297: 
3298:         r0
3299:       end

      # File lib/treetop/compiler/metagrammar.rb, line 1158
1158:       def _nt_alternative
1159:         start_index = index
1160:         if node_cache[:alternative].has_key?(index)
1161:           cached = node_cache[:alternative][index]
1162:           if cached
1163:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
1164:             @index = cached.interval.end
1165:           end
1166:           return cached
1167:         end
1168: 
1169:         i0 = index
1170:         r1 = _nt_sequence
1171:         if r1
1172:           r0 = r1
1173:         else
1174:           r2 = _nt_primary
1175:           if r2
1176:             r0 = r2
1177:           else
1178:             @index = i0
1179:             r0 = nil
1180:           end
1181:         end
1182: 
1183:         node_cache[:alternative][start_index] = r0
1184: 
1185:         r0
1186:       end

      # File lib/treetop/compiler/metagrammar.rb, line 2735
2735:       def _nt_anything_symbol
2736:         start_index = index
2737:         if node_cache[:anything_symbol].has_key?(index)
2738:           cached = node_cache[:anything_symbol][index]
2739:           if cached
2740:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
2741:             @index = cached.interval.end
2742:           end
2743:           return cached
2744:         end
2745: 
2746:         if has_terminal?('.', false, index)
2747:           r0 = instantiate_node(AnythingSymbol,input, index...(index + 1))
2748:           @index += 1
2749:         else
2750:           terminal_parse_failure('.')
2751:           r0 = nil
2752:         end
2753: 
2754:         node_cache[:anything_symbol][start_index] = r0
2755: 
2756:         r0
2757:       end

      # File lib/treetop/compiler/metagrammar.rb, line 2045
2045:       def _nt_atomic
2046:         start_index = index
2047:         if node_cache[:atomic].has_key?(index)
2048:           cached = node_cache[:atomic][index]
2049:           if cached
2050:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
2051:             @index = cached.interval.end
2052:           end
2053:           return cached
2054:         end
2055: 
2056:         i0 = index
2057:         r1 = _nt_terminal
2058:         if r1
2059:           r0 = r1
2060:         else
2061:           r2 = _nt_nonterminal
2062:           if r2
2063:             r0 = r2
2064:           else
2065:             r3 = _nt_parenthesized_expression
2066:             if r3
2067:               r0 = r3
2068:             else
2069:               @index = i0
2070:               r0 = nil
2071:             end
2072:           end
2073:         end
2074: 
2075:         node_cache[:atomic][start_index] = r0
2076: 
2077:         r0
2078:       end

      # File lib/treetop/compiler/metagrammar.rb, line 2578
2578:       def _nt_character_class
2579:         start_index = index
2580:         if node_cache[:character_class].has_key?(index)
2581:           cached = node_cache[:character_class][index]
2582:           if cached
2583:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
2584:             @index = cached.interval.end
2585:           end
2586:           return cached
2587:         end
2588: 
2589:         i0, s0 = index, []
2590:         if has_terminal?('[', false, index)
2591:           r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
2592:           @index += 1
2593:         else
2594:           terminal_parse_failure('[')
2595:           r1 = nil
2596:         end
2597:         s0 << r1
2598:         if r1
2599:           s2, i2 = [], index
2600:           loop do
2601:             i3, s3 = index, []
2602:             i4 = index
2603:             if has_terminal?(']', false, index)
2604:               r5 = instantiate_node(SyntaxNode,input, index...(index + 1))
2605:               @index += 1
2606:             else
2607:               terminal_parse_failure(']')
2608:               r5 = nil
2609:             end
2610:             if r5
2611:               r4 = nil
2612:             else
2613:               @index = i4
2614:               r4 = instantiate_node(SyntaxNode,input, index...index)
2615:             end
2616:             s3 << r4
2617:             if r4
2618:               i6 = index
2619:               i7, s7 = index, []
2620:               if has_terminal?('\', false, index)
2621:                 r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
2622:                 @index += 1
2623:               else
2624:                 terminal_parse_failure('\')
2625:                 r8 = nil
2626:               end
2627:               s7 << r8
2628:               if r8
2629:                 if index < input_length
2630:                   r9 = instantiate_node(SyntaxNode,input, index...(index + 1))
2631:                   @index += 1
2632:                 else
2633:                   terminal_parse_failure("any character")
2634:                   r9 = nil
2635:                 end
2636:                 s7 << r9
2637:               end
2638:               if s7.last
2639:                 r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
2640:                 r7.extend(CharacterClass0)
2641:               else
2642:                 @index = i7
2643:                 r7 = nil
2644:               end
2645:               if r7
2646:                 r6 = r7
2647:               else
2648:                 i10, s10 = index, []
2649:                 i11 = index
2650:                 if has_terminal?('\', false, index)
2651:                   r12 = instantiate_node(SyntaxNode,input, index...(index + 1))
2652:                   @index += 1
2653:                 else
2654:                   terminal_parse_failure('\')
2655:                   r12 = nil
2656:                 end
2657:                 if r12
2658:                   r11 = nil
2659:                 else
2660:                   @index = i11
2661:                   r11 = instantiate_node(SyntaxNode,input, index...index)
2662:                 end
2663:                 s10 << r11
2664:                 if r11
2665:                   if index < input_length
2666:                     r13 = instantiate_node(SyntaxNode,input, index...(index + 1))
2667:                     @index += 1
2668:                   else
2669:                     terminal_parse_failure("any character")
2670:                     r13 = nil
2671:                   end
2672:                   s10 << r13
2673:                 end
2674:                 if s10.last
2675:                   r10 = instantiate_node(SyntaxNode,input, i10...index, s10)
2676:                   r10.extend(CharacterClass1)
2677:                 else
2678:                   @index = i10
2679:                   r10 = nil
2680:                 end
2681:                 if r10
2682:                   r6 = r10
2683:                 else
2684:                   @index = i6
2685:                   r6 = nil
2686:                 end
2687:               end
2688:               s3 << r6
2689:             end
2690:             if s3.last
2691:               r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
2692:               r3.extend(CharacterClass2)
2693:             else
2694:               @index = i3
2695:               r3 = nil
2696:             end
2697:             if r3
2698:               s2 << r3
2699:             else
2700:               break
2701:             end
2702:           end
2703:           if s2.empty?
2704:             @index = i2
2705:             r2 = nil
2706:           else
2707:             r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
2708:           end
2709:           s0 << r2
2710:           if r2
2711:             if has_terminal?(']', false, index)
2712:               r14 = instantiate_node(SyntaxNode,input, index...(index + 1))
2713:               @index += 1
2714:             else
2715:               terminal_parse_failure(']')
2716:               r14 = nil
2717:             end
2718:             s0 << r14
2719:           end
2720:         end
2721:         if s0.last
2722:           r0 = instantiate_node(CharacterClass,input, i0...index, s0)
2723:           r0.extend(CharacterClass3)
2724:           r0.extend(CharacterClass4)
2725:         else
2726:           @index = i0
2727:           r0 = nil
2728:         end
2729: 
2730:         node_cache[:character_class][start_index] = r0
2731: 
2732:         r0
2733:       end

      # File lib/treetop/compiler/metagrammar.rb, line 968
 968:       def _nt_choice
 969:         start_index = index
 970:         if node_cache[:choice].has_key?(index)
 971:           cached = node_cache[:choice][index]
 972:           if cached
 973:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
 974:             @index = cached.interval.end
 975:           end
 976:           return cached
 977:         end
 978: 
 979:         i0, s0 = index, []
 980:         r1 = _nt_alternative
 981:         s0 << r1
 982:         if r1
 983:           s2, i2 = [], index
 984:           loop do
 985:             i3, s3 = index, []
 986:             r5 = _nt_space
 987:             if r5
 988:               r4 = r5
 989:             else
 990:               r4 = instantiate_node(SyntaxNode,input, index...index)
 991:             end
 992:             s3 << r4
 993:             if r4
 994:               if has_terminal?('/', false, index)
 995:                 r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
 996:                 @index += 1
 997:               else
 998:                 terminal_parse_failure('/')
 999:                 r6 = nil
1000:               end
1001:               s3 << r6
1002:               if r6
1003:                 r8 = _nt_space
1004:                 if r8
1005:                   r7 = r8
1006:                 else
1007:                   r7 = instantiate_node(SyntaxNode,input, index...index)
1008:                 end
1009:                 s3 << r7
1010:                 if r7
1011:                   r9 = _nt_alternative
1012:                   s3 << r9
1013:                 end
1014:               end
1015:             end
1016:             if s3.last
1017:               r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
1018:               r3.extend(Choice0)
1019:             else
1020:               @index = i3
1021:               r3 = nil
1022:             end
1023:             if r3
1024:               s2 << r3
1025:             else
1026:               break
1027:             end
1028:           end
1029:           if s2.empty?
1030:             @index = i2
1031:             r2 = nil
1032:           else
1033:             r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
1034:           end
1035:           s0 << r2
1036:         end
1037:         if s0.last
1038:           r0 = instantiate_node(Choice,input, i0...index, s0)
1039:           r0.extend(Choice1)
1040:           r0.extend(Choice2)
1041:         else
1042:           @index = i0
1043:           r0 = nil
1044:         end
1045: 
1046:         node_cache[:choice][start_index] = r0
1047: 
1048:         r0
1049:       end

      # File lib/treetop/compiler/metagrammar.rb, line 3351
3351:       def _nt_comment_to_eol
3352:         start_index = index
3353:         if node_cache[:comment_to_eol].has_key?(index)
3354:           cached = node_cache[:comment_to_eol][index]
3355:           if cached
3356:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
3357:             @index = cached.interval.end
3358:           end
3359:           return cached
3360:         end
3361: 
3362:         i0, s0 = index, []
3363:         if has_terminal?('#', false, index)
3364:           r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
3365:           @index += 1
3366:         else
3367:           terminal_parse_failure('#')
3368:           r1 = nil
3369:         end
3370:         s0 << r1
3371:         if r1
3372:           s2, i2 = [], index
3373:           loop do
3374:             i3, s3 = index, []
3375:             i4 = index
3376:             if has_terminal?("\n", false, index)
3377:               r5 = instantiate_node(SyntaxNode,input, index...(index + 1))
3378:               @index += 1
3379:             else
3380:               terminal_parse_failure("\n")
3381:               r5 = nil
3382:             end
3383:             if r5
3384:               r4 = nil
3385:             else
3386:               @index = i4
3387:               r4 = instantiate_node(SyntaxNode,input, index...index)
3388:             end
3389:             s3 << r4
3390:             if r4
3391:               if index < input_length
3392:                 r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
3393:                 @index += 1
3394:               else
3395:                 terminal_parse_failure("any character")
3396:                 r6 = nil
3397:               end
3398:               s3 << r6
3399:             end
3400:             if s3.last
3401:               r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
3402:               r3.extend(CommentToEol0)
3403:             else
3404:               @index = i3
3405:               r3 = nil
3406:             end
3407:             if r3
3408:               s2 << r3
3409:             else
3410:               break
3411:             end
3412:           end
3413:           r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
3414:           s0 << r2
3415:         end
3416:         if s0.last
3417:           r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
3418:           r0.extend(CommentToEol1)
3419:         else
3420:           @index = i0
3421:           r0 = nil
3422:         end
3423: 
3424:         node_cache[:comment_to_eol][start_index] = r0
3425: 
3426:         r0
3427:       end

     # File lib/treetop/compiler/metagrammar.rb, line 662
662:       def _nt_declaration
663:         start_index = index
664:         if node_cache[:declaration].has_key?(index)
665:           cached = node_cache[:declaration][index]
666:           if cached
667:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
668:             @index = cached.interval.end
669:           end
670:           return cached
671:         end
672: 
673:         i0 = index
674:         r1 = _nt_parsing_rule
675:         if r1
676:           r0 = r1
677:         else
678:           r2 = _nt_include_declaration
679:           if r2
680:             r0 = r2
681:           else
682:             @index = i0
683:             r0 = nil
684:           end
685:         end
686: 
687:         node_cache[:declaration][start_index] = r0
688: 
689:         r0
690:       end

     # File lib/treetop/compiler/metagrammar.rb, line 589
589:       def _nt_declaration_sequence
590:         start_index = index
591:         if node_cache[:declaration_sequence].has_key?(index)
592:           cached = node_cache[:declaration_sequence][index]
593:           if cached
594:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
595:             @index = cached.interval.end
596:           end
597:           return cached
598:         end
599: 
600:         i0 = index
601:         i1, s1 = index, []
602:         r2 = _nt_declaration
603:         s1 << r2
604:         if r2
605:           s3, i3 = [], index
606:           loop do
607:             i4, s4 = index, []
608:             r5 = _nt_space
609:             s4 << r5
610:             if r5
611:               r6 = _nt_declaration
612:               s4 << r6
613:             end
614:             if s4.last
615:               r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
616:               r4.extend(DeclarationSequence0)
617:             else
618:               @index = i4
619:               r4 = nil
620:             end
621:             if r4
622:               s3 << r4
623:             else
624:               break
625:             end
626:           end
627:           r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
628:           s1 << r3
629:         end
630:         if s1.last
631:           r1 = instantiate_node(DeclarationSequence,input, i1...index, s1)
632:           r1.extend(DeclarationSequence1)
633:           r1.extend(DeclarationSequence2)
634:         else
635:           @index = i1
636:           r1 = nil
637:         end
638:         if r1
639:           r0 = r1
640:         else
641:           if has_terminal?('', false, index)
642:             r7 = instantiate_node(SyntaxNode,input, index...(index + 0))
643:             r7.extend(DeclarationSequence3)
644:             @index += 0
645:           else
646:             terminal_parse_failure('')
647:             r7 = nil
648:           end
649:           if r7
650:             r0 = r7
651:           else
652:             @index = i0
653:             r0 = nil
654:           end
655:         end
656: 
657:         node_cache[:declaration_sequence][start_index] = r0
658: 
659:         r0
660:       end

      # File lib/treetop/compiler/metagrammar.rb, line 2312
2312:       def _nt_double_quoted_string
2313:         start_index = index
2314:         if node_cache[:double_quoted_string].has_key?(index)
2315:           cached = node_cache[:double_quoted_string][index]
2316:           if cached
2317:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
2318:             @index = cached.interval.end
2319:           end
2320:           return cached
2321:         end
2322: 
2323:         i0, s0 = index, []
2324:         if has_terminal?('"', false, index)
2325:           r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
2326:           @index += 1
2327:         else
2328:           terminal_parse_failure('"')
2329:           r1 = nil
2330:         end
2331:         s0 << r1
2332:         if r1
2333:           s2, i2 = [], index
2334:           loop do
2335:             i3, s3 = index, []
2336:             i4 = index
2337:             if has_terminal?('"', false, index)
2338:               r5 = instantiate_node(SyntaxNode,input, index...(index + 1))
2339:               @index += 1
2340:             else
2341:               terminal_parse_failure('"')
2342:               r5 = nil
2343:             end
2344:             if r5
2345:               r4 = nil
2346:             else
2347:               @index = i4
2348:               r4 = instantiate_node(SyntaxNode,input, index...index)
2349:             end
2350:             s3 << r4
2351:             if r4
2352:               i6 = index
2353:               if has_terminal?("\\\\", false, index)
2354:                 r7 = instantiate_node(SyntaxNode,input, index...(index + 2))
2355:                 @index += 2
2356:               else
2357:                 terminal_parse_failure("\\\\")
2358:                 r7 = nil
2359:               end
2360:               if r7
2361:                 r6 = r7
2362:               else
2363:                 if has_terminal?('\"', false, index)
2364:                   r8 = instantiate_node(SyntaxNode,input, index...(index + 2))
2365:                   @index += 2
2366:                 else
2367:                   terminal_parse_failure('\"')
2368:                   r8 = nil
2369:                 end
2370:                 if r8
2371:                   r6 = r8
2372:                 else
2373:                   if index < input_length
2374:                     r9 = instantiate_node(SyntaxNode,input, index...(index + 1))
2375:                     @index += 1
2376:                   else
2377:                     terminal_parse_failure("any character")
2378:                     r9 = nil
2379:                   end
2380:                   if r9
2381:                     r6 = r9
2382:                   else
2383:                     @index = i6
2384:                     r6 = nil
2385:                   end
2386:                 end
2387:               end
2388:               s3 << r6
2389:             end
2390:             if s3.last
2391:               r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
2392:               r3.extend(DoubleQuotedString0)
2393:             else
2394:               @index = i3
2395:               r3 = nil
2396:             end
2397:             if r3
2398:               s2 << r3
2399:             else
2400:               break
2401:             end
2402:           end
2403:           r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
2404:           s0 << r2
2405:           if r2
2406:             if has_terminal?('"', false, index)
2407:               r10 = instantiate_node(SyntaxNode,input, index...(index + 1))
2408:               @index += 1
2409:             else
2410:               terminal_parse_failure('"')
2411:               r10 = nil
2412:             end
2413:             s0 << r10
2414:           end
2415:         end
2416:         if s0.last
2417:           r0 = instantiate_node(Terminal,input, i0...index, s0)
2418:           r0.extend(DoubleQuotedString1)
2419:         else
2420:           @index = i0
2421:           r0 = nil
2422:         end
2423: 
2424:         node_cache[:double_quoted_string][start_index] = r0
2425: 
2426:         r0
2427:       end

     # File lib/treetop/compiler/metagrammar.rb, line 410
410:       def _nt_grammar
411:         start_index = index
412:         if node_cache[:grammar].has_key?(index)
413:           cached = node_cache[:grammar][index]
414:           if cached
415:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
416:             @index = cached.interval.end
417:           end
418:           return cached
419:         end
420: 
421:         i0, s0 = index, []
422:         if has_terminal?('grammar', false, index)
423:           r1 = instantiate_node(SyntaxNode,input, index...(index + 7))
424:           @index += 7
425:         else
426:           terminal_parse_failure('grammar')
427:           r1 = nil
428:         end
429:         s0 << r1
430:         if r1
431:           r2 = _nt_space
432:           s0 << r2
433:           if r2
434:             r3 = _nt_grammar_name
435:             s0 << r3
436:             if r3
437:               r4 = _nt_space
438:               s0 << r4
439:               if r4
440:                 i6, s6 = index, []
441:                 if has_terminal?('do', false, index)
442:                   r7 = instantiate_node(SyntaxNode,input, index...(index + 2))
443:                   @index += 2
444:                 else
445:                   terminal_parse_failure('do')
446:                   r7 = nil
447:                 end
448:                 s6 << r7
449:                 if r7
450:                   r8 = _nt_space
451:                   s6 << r8
452:                 end
453:                 if s6.last
454:                   r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
455:                   r6.extend(Grammar0)
456:                 else
457:                   @index = i6
458:                   r6 = nil
459:                 end
460:                 if r6
461:                   r5 = r6
462:                 else
463:                   r5 = instantiate_node(SyntaxNode,input, index...index)
464:                 end
465:                 s0 << r5
466:                 if r5
467:                   r9 = _nt_declaration_sequence
468:                   s0 << r9
469:                   if r9
470:                     r11 = _nt_space
471:                     if r11
472:                       r10 = r11
473:                     else
474:                       r10 = instantiate_node(SyntaxNode,input, index...index)
475:                     end
476:                     s0 << r10
477:                     if r10
478:                       if has_terminal?('end', false, index)
479:                         r12 = instantiate_node(SyntaxNode,input, index...(index + 3))
480:                         @index += 3
481:                       else
482:                         terminal_parse_failure('end')
483:                         r12 = nil
484:                       end
485:                       s0 << r12
486:                     end
487:                   end
488:                 end
489:               end
490:             end
491:           end
492:         end
493:         if s0.last
494:           r0 = instantiate_node(Grammar,input, i0...index, s0)
495:           r0.extend(Grammar1)
496:         else
497:           @index = i0
498:           r0 = nil
499:         end
500: 
501:         node_cache[:grammar][start_index] = r0
502: 
503:         r0
504:       end

     # File lib/treetop/compiler/metagrammar.rb, line 509
509:       def _nt_grammar_name
510:         start_index = index
511:         if node_cache[:grammar_name].has_key?(index)
512:           cached = node_cache[:grammar_name][index]
513:           if cached
514:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
515:             @index = cached.interval.end
516:           end
517:           return cached
518:         end
519: 
520:         i0, s0 = index, []
521:         if has_terminal?('\G[A-Z]', true, index)
522:           r1 = true
523:           @index += 1
524:         else
525:           r1 = nil
526:         end
527:         s0 << r1
528:         if r1
529:           s2, i2 = [], index
530:           loop do
531:             r3 = _nt_alphanumeric_char
532:             if r3
533:               s2 << r3
534:             else
535:               break
536:             end
537:           end
538:           r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
539:           s0 << r2
540:         end
541:         if s0.last
542:           r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
543:           r0.extend(GrammarName0)
544:         else
545:           @index = i0
546:           r0 = nil
547:         end
548: 
549:         node_cache[:grammar_name][start_index] = r0
550: 
551:         r0
552:       end

     # File lib/treetop/compiler/metagrammar.rb, line 705
705:       def _nt_include_declaration
706:         start_index = index
707:         if node_cache[:include_declaration].has_key?(index)
708:           cached = node_cache[:include_declaration][index]
709:           if cached
710:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
711:             @index = cached.interval.end
712:           end
713:           return cached
714:         end
715: 
716:         i0, s0 = index, []
717:         if has_terminal?('include', false, index)
718:           r1 = instantiate_node(SyntaxNode,input, index...(index + 7))
719:           @index += 7
720:         else
721:           terminal_parse_failure('include')
722:           r1 = nil
723:         end
724:         s0 << r1
725:         if r1
726:           r2 = _nt_space
727:           s0 << r2
728:           if r2
729:             if has_terminal?('\G[A-Z]', true, index)
730:               r3 = true
731:               @index += 1
732:             else
733:               r3 = nil
734:             end
735:             s0 << r3
736:             if r3
737:               s4, i4 = [], index
738:               loop do
739:                 i5 = index
740:                 r6 = _nt_alphanumeric_char
741:                 if r6
742:                   r5 = r6
743:                 else
744:                   if has_terminal?('::', false, index)
745:                     r7 = instantiate_node(SyntaxNode,input, index...(index + 2))
746:                     @index += 2
747:                   else
748:                     terminal_parse_failure('::')
749:                     r7 = nil
750:                   end
751:                   if r7
752:                     r5 = r7
753:                   else
754:                     @index = i5
755:                     r5 = nil
756:                   end
757:                 end
758:                 if r5
759:                   s4 << r5
760:                 else
761:                   break
762:                 end
763:               end
764:               r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
765:               s0 << r4
766:             end
767:           end
768:         end
769:         if s0.last
770:           r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
771:           r0.extend(IncludeDeclaration0)
772:           r0.extend(IncludeDeclaration1)
773:         else
774:           @index = i0
775:           r0 = nil
776:         end
777: 
778:         node_cache[:include_declaration][start_index] = r0
779: 
780:         r0
781:       end

      # File lib/treetop/compiler/metagrammar.rb, line 3032
3032:       def _nt_inline_module
3033:         start_index = index
3034:         if node_cache[:inline_module].has_key?(index)
3035:           cached = node_cache[:inline_module][index]
3036:           if cached
3037:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
3038:             @index = cached.interval.end
3039:           end
3040:           return cached
3041:         end
3042: 
3043:         i0, s0 = index, []
3044:         if has_terminal?('{', false, index)
3045:           r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
3046:           @index += 1
3047:         else
3048:           terminal_parse_failure('{')
3049:           r1 = nil
3050:         end
3051:         s0 << r1
3052:         if r1
3053:           s2, i2 = [], index
3054:           loop do
3055:             i3 = index
3056:             r4 = _nt_inline_module
3057:             if r4
3058:               r3 = r4
3059:             else
3060:               i5, s5 = index, []
3061:               i6 = index
3062:               if has_terminal?('\G[{}]', true, index)
3063:                 r7 = true
3064:                 @index += 1
3065:               else
3066:                 r7 = nil
3067:               end
3068:               if r7
3069:                 r6 = nil
3070:               else
3071:                 @index = i6
3072:                 r6 = instantiate_node(SyntaxNode,input, index...index)
3073:               end
3074:               s5 << r6
3075:               if r6
3076:                 if index < input_length
3077:                   r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
3078:                   @index += 1
3079:                 else
3080:                   terminal_parse_failure("any character")
3081:                   r8 = nil
3082:                 end
3083:                 s5 << r8
3084:               end
3085:               if s5.last
3086:                 r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
3087:                 r5.extend(InlineModule0)
3088:               else
3089:                 @index = i5
3090:                 r5 = nil
3091:               end
3092:               if r5
3093:                 r3 = r5
3094:               else
3095:                 @index = i3
3096:                 r3 = nil
3097:               end
3098:             end
3099:             if r3
3100:               s2 << r3
3101:             else
3102:               break
3103:             end
3104:           end
3105:           r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
3106:           s0 << r2
3107:           if r2
3108:             if has_terminal?('}', false, index)
3109:               r9 = instantiate_node(SyntaxNode,input, index...(index + 1))
3110:               @index += 1
3111:             else
3112:               terminal_parse_failure('}')
3113:               r9 = nil
3114:             end
3115:             s0 << r9
3116:           end
3117:         end
3118:         if s0.last
3119:           r0 = instantiate_node(InlineModule,input, i0...index, s0)
3120:           r0.extend(InlineModule1)
3121:         else
3122:           @index = i0
3123:           r0 = nil
3124:         end
3125: 
3126:         node_cache[:inline_module][start_index] = r0
3127: 
3128:         r0
3129:       end

      # File lib/treetop/compiler/metagrammar.rb, line 3134
3134:       def _nt_keyword_inside_grammar
3135:         start_index = index
3136:         if node_cache[:keyword_inside_grammar].has_key?(index)
3137:           cached = node_cache[:keyword_inside_grammar][index]
3138:           if cached
3139:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
3140:             @index = cached.interval.end
3141:           end
3142:           return cached
3143:         end
3144: 
3145:         i0, s0 = index, []
3146:         i1 = index
3147:         if has_terminal?('rule', false, index)
3148:           r2 = instantiate_node(SyntaxNode,input, index...(index + 4))
3149:           @index += 4
3150:         else
3151:           terminal_parse_failure('rule')
3152:           r2 = nil
3153:         end
3154:         if r2
3155:           r1 = r2
3156:         else
3157:           if has_terminal?('end', false, index)
3158:             r3 = instantiate_node(SyntaxNode,input, index...(index + 3))
3159:             @index += 3
3160:           else
3161:             terminal_parse_failure('end')
3162:             r3 = nil
3163:           end
3164:           if r3
3165:             r1 = r3
3166:           else
3167:             @index = i1
3168:             r1 = nil
3169:           end
3170:         end
3171:         s0 << r1
3172:         if r1
3173:           i4 = index
3174:           r5 = _nt_non_space_char
3175:           if r5
3176:             r4 = nil
3177:           else
3178:             @index = i4
3179:             r4 = instantiate_node(SyntaxNode,input, index...index)
3180:           end
3181:           s0 << r4
3182:         end
3183:         if s0.last
3184:           r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
3185:           r0.extend(KeywordInsideGrammar0)
3186:         else
3187:           @index = i0
3188:           r0 = nil
3189:         end
3190: 
3191:         node_cache[:keyword_inside_grammar][start_index] = r0
3192: 
3193:         r0
3194:       end

      # File lib/treetop/compiler/metagrammar.rb, line 1495
1495:       def _nt_label
1496:         start_index = index
1497:         if node_cache[:label].has_key?(index)
1498:           cached = node_cache[:label][index]
1499:           if cached
1500:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
1501:             @index = cached.interval.end
1502:           end
1503:           return cached
1504:         end
1505: 
1506:         i0 = index
1507:         i1, s1 = index, []
1508:         i2, s2 = index, []
1509:         r3 = _nt_alpha_char
1510:         s2 << r3
1511:         if r3
1512:           s4, i4 = [], index
1513:           loop do
1514:             r5 = _nt_alphanumeric_char
1515:             if r5
1516:               s4 << r5
1517:             else
1518:               break
1519:             end
1520:           end
1521:           r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
1522:           s2 << r4
1523:         end
1524:         if s2.last
1525:           r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
1526:           r2.extend(Label0)
1527:         else
1528:           @index = i2
1529:           r2 = nil
1530:         end
1531:         s1 << r2
1532:         if r2
1533:           if has_terminal?(':', false, index)
1534:             r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
1535:             @index += 1
1536:           else
1537:             terminal_parse_failure(':')
1538:             r6 = nil
1539:           end
1540:           s1 << r6
1541:         end
1542:         if s1.last
1543:           r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
1544:           r1.extend(Label1)
1545:           r1.extend(Label2)
1546:         else
1547:           @index = i1
1548:           r1 = nil
1549:         end
1550:         if r1
1551:           r0 = r1
1552:         else
1553:           if has_terminal?('', false, index)
1554:             r7 = instantiate_node(SyntaxNode,input, index...(index + 0))
1555:             r7.extend(Label3)
1556:             @index += 0
1557:           else
1558:             terminal_parse_failure('')
1559:             r7 = nil
1560:           end
1561:           if r7
1562:             r0 = r7
1563:           else
1564:             @index = i0
1565:             r0 = nil
1566:           end
1567:         end
1568: 
1569:         node_cache[:label][start_index] = r0
1570: 
1571:         r0
1572:       end

      # File lib/treetop/compiler/metagrammar.rb, line 1441
1441:       def _nt_labeled_sequence_primary
1442:         start_index = index
1443:         if node_cache[:labeled_sequence_primary].has_key?(index)
1444:           cached = node_cache[:labeled_sequence_primary][index]
1445:           if cached
1446:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
1447:             @index = cached.interval.end
1448:           end
1449:           return cached
1450:         end
1451: 
1452:         i0, s0 = index, []
1453:         r1 = _nt_label
1454:         s0 << r1
1455:         if r1
1456:           r2 = _nt_sequence_primary
1457:           s0 << r2
1458:         end
1459:         if s0.last
1460:           r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
1461:           r0.extend(LabeledSequencePrimary0)
1462:           r0.extend(LabeledSequencePrimary1)
1463:         else
1464:           @index = i0
1465:           r0 = nil
1466:         end
1467: 
1468:         node_cache[:labeled_sequence_primary][start_index] = r0
1469: 
1470:         r0
1471:       end

     # File lib/treetop/compiler/metagrammar.rb, line 273
273:       def _nt_module_declaration
274:         start_index = index
275:         if node_cache[:module_declaration].has_key?(index)
276:           cached = node_cache[:module_declaration][index]
277:           if cached
278:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
279:             @index = cached.interval.end
280:           end
281:           return cached
282:         end
283: 
284:         i0, s0 = index, []
285:         i1, s1 = index, []
286:         if has_terminal?('module', false, index)
287:           r2 = instantiate_node(SyntaxNode,input, index...(index + 6))
288:           @index += 6
289:         else
290:           terminal_parse_failure('module')
291:           r2 = nil
292:         end
293:         s1 << r2
294:         if r2
295:           r3 = _nt_space
296:           s1 << r3
297:           if r3
298:             if has_terminal?('\G[A-Z]', true, index)
299:               r4 = true
300:               @index += 1
301:             else
302:               r4 = nil
303:             end
304:             s1 << r4
305:             if r4
306:               s5, i5 = [], index
307:               loop do
308:                 r6 = _nt_alphanumeric_char
309:                 if r6
310:                   s5 << r6
311:                 else
312:                   break
313:                 end
314:               end
315:               r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
316:               s1 << r5
317:               if r5
318:                 r7 = _nt_space
319:                 s1 << r7
320:               end
321:             end
322:           end
323:         end
324:         if s1.last
325:           r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
326:           r1.extend(ModuleDeclaration0)
327:         else
328:           @index = i1
329:           r1 = nil
330:         end
331:         s0 << r1
332:         if r1
333:           i8 = index
334:           r9 = _nt_module_declaration
335:           if r9
336:             r8 = r9
337:           else
338:             r10 = _nt_grammar
339:             if r10
340:               r8 = r10
341:             else
342:               @index = i8
343:               r8 = nil
344:             end
345:           end
346:           s0 << r8
347:           if r8
348:             i11, s11 = index, []
349:             r12 = _nt_space
350:             s11 << r12
351:             if r12
352:               if has_terminal?('end', false, index)
353:                 r13 = instantiate_node(SyntaxNode,input, index...(index + 3))
354:                 @index += 3
355:               else
356:                 terminal_parse_failure('end')
357:                 r13 = nil
358:               end
359:               s11 << r13
360:             end
361:             if s11.last
362:               r11 = instantiate_node(SyntaxNode,input, i11...index, s11)
363:               r11.extend(ModuleDeclaration1)
364:             else
365:               @index = i11
366:               r11 = nil
367:             end
368:             s0 << r11
369:           end
370:         end
371:         if s0.last
372:           r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
373:           r0.extend(ModuleDeclaration2)
374:           r0.extend(ModuleDeclaration3)
375:         else
376:           @index = i0
377:           r0 = nil
378:         end
379: 
380:         node_cache[:module_declaration][start_index] = r0
381: 
382:         r0
383:       end

      # File lib/treetop/compiler/metagrammar.rb, line 1825
1825:       def _nt_node_class_declarations
1826:         start_index = index
1827:         if node_cache[:node_class_declarations].has_key?(index)
1828:           cached = node_cache[:node_class_declarations][index]
1829:           if cached
1830:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
1831:             @index = cached.interval.end
1832:           end
1833:           return cached
1834:         end
1835: 
1836:         i0, s0 = index, []
1837:         r1 = _nt_node_class_expression
1838:         s0 << r1
1839:         if r1
1840:           r2 = _nt_trailing_inline_module
1841:           s0 << r2
1842:         end
1843:         if s0.last
1844:           r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
1845:           r0.extend(NodeClassDeclarations0)
1846:           r0.extend(NodeClassDeclarations1)
1847:         else
1848:           @index = i0
1849:           r0 = nil
1850:         end
1851: 
1852:         node_cache[:node_class_declarations][start_index] = r0
1853: 
1854:         r0
1855:       end

      # File lib/treetop/compiler/metagrammar.rb, line 2781
2781:       def _nt_node_class_expression
2782:         start_index = index
2783:         if node_cache[:node_class_expression].has_key?(index)
2784:           cached = node_cache[:node_class_expression][index]
2785:           if cached
2786:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
2787:             @index = cached.interval.end
2788:           end
2789:           return cached
2790:         end
2791: 
2792:         i0 = index
2793:         i1, s1 = index, []
2794:         r2 = _nt_space
2795:         s1 << r2
2796:         if r2
2797:           if has_terminal?('<', false, index)
2798:             r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
2799:             @index += 1
2800:           else
2801:             terminal_parse_failure('<')
2802:             r3 = nil
2803:           end
2804:           s1 << r3
2805:           if r3
2806:             s4, i4 = [], index
2807:             loop do
2808:               i5, s5 = index, []
2809:               i6 = index
2810:               if has_terminal?('>', false, index)
2811:                 r7 = instantiate_node(SyntaxNode,input, index...(index + 1))
2812:                 @index += 1
2813:               else
2814:                 terminal_parse_failure('>')
2815:                 r7 = nil
2816:               end
2817:               if r7
2818:                 r6 = nil
2819:               else
2820:                 @index = i6
2821:                 r6 = instantiate_node(SyntaxNode,input, index...index)
2822:               end
2823:               s5 << r6
2824:               if r6
2825:                 if index < input_length
2826:                   r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
2827:                   @index += 1
2828:                 else
2829:                   terminal_parse_failure("any character")
2830:                   r8 = nil
2831:                 end
2832:                 s5 << r8
2833:               end
2834:               if s5.last
2835:                 r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
2836:                 r5.extend(NodeClassExpression0)
2837:               else
2838:                 @index = i5
2839:                 r5 = nil
2840:               end
2841:               if r5
2842:                 s4 << r5
2843:               else
2844:                 break
2845:               end
2846:             end
2847:             if s4.empty?
2848:               @index = i4
2849:               r4 = nil
2850:             else
2851:               r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
2852:             end
2853:             s1 << r4
2854:             if r4
2855:               if has_terminal?('>', false, index)
2856:                 r9 = instantiate_node(SyntaxNode,input, index...(index + 1))
2857:                 @index += 1
2858:               else
2859:                 terminal_parse_failure('>')
2860:                 r9 = nil
2861:               end
2862:               s1 << r9
2863:             end
2864:           end
2865:         end
2866:         if s1.last
2867:           r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
2868:           r1.extend(NodeClassExpression1)
2869:           r1.extend(NodeClassExpression2)
2870:         else
2871:           @index = i1
2872:           r1 = nil
2873:         end
2874:         if r1
2875:           r0 = r1
2876:         else
2877:           if has_terminal?('', false, index)
2878:             r10 = instantiate_node(SyntaxNode,input, index...(index + 0))
2879:             r10.extend(NodeClassExpression3)
2880:             @index += 0
2881:           else
2882:             terminal_parse_failure('')
2883:             r10 = nil
2884:           end
2885:           if r10
2886:             r0 = r10
2887:           else
2888:             @index = i0
2889:             r0 = nil
2890:           end
2891:         end
2892: 
2893:         node_cache[:node_class_expression][start_index] = r0
2894: 
2895:         r0
2896:       end

      # File lib/treetop/compiler/metagrammar.rb, line 3199
3199:       def _nt_non_space_char
3200:         start_index = index
3201:         if node_cache[:non_space_char].has_key?(index)
3202:           cached = node_cache[:non_space_char][index]
3203:           if cached
3204:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
3205:             @index = cached.interval.end
3206:           end
3207:           return cached
3208:         end
3209: 
3210:         i0, s0 = index, []
3211:         i1 = index
3212:         r2 = _nt_space
3213:         if r2
3214:           r1 = nil
3215:         else
3216:           @index = i1
3217:           r1 = instantiate_node(SyntaxNode,input, index...index)
3218:         end
3219:         s0 << r1
3220:         if r1
3221:           if index < input_length
3222:             r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
3223:             @index += 1
3224:           else
3225:             terminal_parse_failure("any character")
3226:             r3 = nil
3227:           end
3228:           s0 << r3
3229:         end
3230:         if s0.last
3231:           r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
3232:           r0.extend(NonSpaceChar0)
3233:         else
3234:           @index = i0
3235:           r0 = nil
3236:         end
3237: 
3238:         node_cache[:non_space_char][start_index] = r0
3239: 
3240:         r0
3241:       end

      # File lib/treetop/compiler/metagrammar.rb, line 2169
2169:       def _nt_nonterminal
2170:         start_index = index
2171:         if node_cache[:nonterminal].has_key?(index)
2172:           cached = node_cache[:nonterminal][index]
2173:           if cached
2174:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
2175:             @index = cached.interval.end
2176:           end
2177:           return cached
2178:         end
2179: 
2180:         i0, s0 = index, []
2181:         i1 = index
2182:         r2 = _nt_keyword_inside_grammar
2183:         if r2
2184:           r1 = nil
2185:         else
2186:           @index = i1
2187:           r1 = instantiate_node(SyntaxNode,input, index...index)
2188:         end
2189:         s0 << r1
2190:         if r1
2191:           i3, s3 = index, []
2192:           r4 = _nt_alpha_char
2193:           s3 << r4
2194:           if r4
2195:             s5, i5 = [], index
2196:             loop do
2197:               r6 = _nt_alphanumeric_char
2198:               if r6
2199:                 s5 << r6
2200:               else
2201:                 break
2202:               end
2203:             end
2204:             r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
2205:             s3 << r5
2206:           end
2207:           if s3.last
2208:             r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
2209:             r3.extend(Nonterminal0)
2210:           else
2211:             @index = i3
2212:             r3 = nil
2213:           end
2214:           s0 << r3
2215:         end
2216:         if s0.last
2217:           r0 = instantiate_node(Nonterminal,input, i0...index, s0)
2218:           r0.extend(Nonterminal1)
2219:         else
2220:           @index = i0
2221:           r0 = nil
2222:         end
2223: 
2224:         node_cache[:nonterminal][start_index] = r0
2225: 
2226:         r0
2227:       end

      # File lib/treetop/compiler/metagrammar.rb, line 1914
1914:       def _nt_occurrence_range
1915:         start_index = index
1916:         if node_cache[:occurrence_range].has_key?(index)
1917:           cached = node_cache[:occurrence_range][index]
1918:           if cached
1919:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
1920:             @index = cached.interval.end
1921:           end
1922:           return cached
1923:         end
1924: 
1925:         i0, s0 = index, []
1926:         r2 = _nt_space
1927:         if r2
1928:           r1 = r2
1929:         else
1930:           r1 = instantiate_node(SyntaxNode,input, index...index)
1931:         end
1932:         s0 << r1
1933:         if r1
1934:           s3, i3 = [], index
1935:           loop do
1936:             if has_terminal?('\G[0-9]', true, index)
1937:               r4 = true
1938:               @index += 1
1939:             else
1940:               r4 = nil
1941:             end
1942:             if r4
1943:               s3 << r4
1944:             else
1945:               break
1946:             end
1947:           end
1948:           r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
1949:           s0 << r3
1950:           if r3
1951:             if has_terminal?('..', false, index)
1952:               r5 = instantiate_node(SyntaxNode,input, index...(index + 2))
1953:               @index += 2
1954:             else
1955:               terminal_parse_failure('..')
1956:               r5 = nil
1957:             end
1958:             s0 << r5
1959:             if r5
1960:               s6, i6 = [], index
1961:               loop do
1962:                 if has_terminal?('\G[0-9]', true, index)
1963:                   r7 = true
1964:                   @index += 1
1965:                 else
1966:                   r7 = nil
1967:                 end
1968:                 if r7
1969:                   s6 << r7
1970:                 else
1971:                   break
1972:                 end
1973:               end
1974:               r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
1975:               s0 << r6
1976:             end
1977:           end
1978:         end
1979:         if s0.last
1980:           r0 = instantiate_node(OccurrenceRange,input, i0...index, s0)
1981:           r0.extend(OccurrenceRange0)
1982:         else
1983:           @index = i0
1984:           r0 = nil
1985:         end
1986: 
1987:         node_cache[:occurrence_range][start_index] = r0
1988: 
1989:         r0
1990:       end

      # File lib/treetop/compiler/metagrammar.rb, line 1773
1773:       def _nt_optional_suffix
1774:         start_index = index
1775:         if node_cache[:optional_suffix].has_key?(index)
1776:           cached = node_cache[:optional_suffix][index]
1777:           if cached
1778:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
1779:             @index = cached.interval.end
1780:           end
1781:           return cached
1782:         end
1783: 
1784:         if has_terminal?('?', false, index)
1785:           r0 = instantiate_node(Optional,input, index...(index + 1))
1786:           @index += 1
1787:         else
1788:           terminal_parse_failure('?')
1789:           r0 = nil
1790:         end
1791: 
1792:         node_cache[:optional_suffix][start_index] = r0
1793: 
1794:         r0
1795:       end

      # File lib/treetop/compiler/metagrammar.rb, line 2093
2093:       def _nt_parenthesized_expression
2094:         start_index = index
2095:         if node_cache[:parenthesized_expression].has_key?(index)
2096:           cached = node_cache[:parenthesized_expression][index]
2097:           if cached
2098:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
2099:             @index = cached.interval.end
2100:           end
2101:           return cached
2102:         end
2103: 
2104:         i0, s0 = index, []
2105:         if has_terminal?('(', false, index)
2106:           r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
2107:           @index += 1
2108:         else
2109:           terminal_parse_failure('(')
2110:           r1 = nil
2111:         end
2112:         s0 << r1
2113:         if r1
2114:           r3 = _nt_space
2115:           if r3
2116:             r2 = r3
2117:           else
2118:             r2 = instantiate_node(SyntaxNode,input, index...index)
2119:           end
2120:           s0 << r2
2121:           if r2
2122:             r4 = _nt_parsing_expression
2123:             s0 << r4
2124:             if r4
2125:               r6 = _nt_space
2126:               if r6
2127:                 r5 = r6
2128:               else
2129:                 r5 = instantiate_node(SyntaxNode,input, index...index)
2130:               end
2131:               s0 << r5
2132:               if r5
2133:                 if has_terminal?(')', false, index)
2134:                   r7 = instantiate_node(SyntaxNode,input, index...(index + 1))
2135:                   @index += 1
2136:                 else
2137:                   terminal_parse_failure(')')
2138:                   r7 = nil
2139:                 end
2140:                 s0 << r7
2141:               end
2142:             end
2143:           end
2144:         end
2145:         if s0.last
2146:           r0 = instantiate_node(ParenthesizedExpression,input, i0...index, s0)
2147:           r0.extend(ParenthesizedExpression0)
2148:           r0.extend(ParenthesizedExpression1)
2149:         else
2150:           @index = i0
2151:           r0 = nil
2152:         end
2153: 
2154:         node_cache[:parenthesized_expression][start_index] = r0
2155: 
2156:         r0
2157:       end

     # File lib/treetop/compiler/metagrammar.rb, line 903
903:       def _nt_parsing_expression
904:         start_index = index
905:         if node_cache[:parsing_expression].has_key?(index)
906:           cached = node_cache[:parsing_expression][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 = index
915:         r1 = _nt_choice
916:         if r1
917:           r0 = r1
918:         else
919:           r2 = _nt_sequence
920:           if r2
921:             r0 = r2
922:           else
923:             r3 = _nt_primary
924:             if r3
925:               r0 = r3
926:             else
927:               @index = i0
928:               r0 = nil
929:             end
930:           end
931:         end
932: 
933:         node_cache[:parsing_expression][start_index] = r0
934: 
935:         r0
936:       end

     # File lib/treetop/compiler/metagrammar.rb, line 812
812:       def _nt_parsing_rule
813:         start_index = index
814:         if node_cache[:parsing_rule].has_key?(index)
815:           cached = node_cache[:parsing_rule][index]
816:           if cached
817:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
818:             @index = cached.interval.end
819:           end
820:           return cached
821:         end
822: 
823:         i0, s0 = index, []
824:         if has_terminal?('rule', false, index)
825:           r1 = instantiate_node(SyntaxNode,input, index...(index + 4))
826:           @index += 4
827:         else
828:           terminal_parse_failure('rule')
829:           r1 = nil
830:         end
831:         s0 << r1
832:         if r1
833:           r2 = _nt_space
834:           s0 << r2
835:           if r2
836:             r3 = _nt_nonterminal
837:             s0 << r3
838:             if r3
839:               r4 = _nt_space
840:               s0 << r4
841:               if r4
842:                 i6, s6 = index, []
843:                 if has_terminal?('do', false, index)
844:                   r7 = instantiate_node(SyntaxNode,input, index...(index + 2))
845:                   @index += 2
846:                 else
847:                   terminal_parse_failure('do')
848:                   r7 = nil
849:                 end
850:                 s6 << r7
851:                 if r7
852:                   r8 = _nt_space
853:                   s6 << r8
854:                 end
855:                 if s6.last
856:                   r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
857:                   r6.extend(ParsingRule0)
858:                 else
859:                   @index = i6
860:                   r6 = nil
861:                 end
862:                 if r6
863:                   r5 = r6
864:                 else
865:                   r5 = instantiate_node(SyntaxNode,input, index...index)
866:                 end
867:                 s0 << r5
868:                 if r5
869:                   r9 = _nt_parsing_expression
870:                   s0 << r9
871:                   if r9
872:                     r10 = _nt_space
873:                     s0 << r10
874:                     if r10
875:                       if has_terminal?('end', false, index)
876:                         r11 = instantiate_node(SyntaxNode,input, index...(index + 3))
877:                         @index += 3
878:                       else
879:                         terminal_parse_failure('end')
880:                         r11 = nil
881:                       end
882:                       s0 << r11
883:                     end
884:                   end
885:                 end
886:               end
887:             end
888:           end
889:         end
890:         if s0.last
891:           r0 = instantiate_node(ParsingRule,input, i0...index, s0)
892:           r0.extend(ParsingRule1)
893:         else
894:           @index = i0
895:           r0 = nil
896:         end
897: 
898:         node_cache[:parsing_rule][start_index] = r0
899: 
900:         r0
901:       end

      # File lib/treetop/compiler/metagrammar.rb, line 2989
2989:       def _nt_predicate_block
2990:         start_index = index
2991:         if node_cache[:predicate_block].has_key?(index)
2992:           cached = node_cache[:predicate_block][index]
2993:           if cached
2994:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
2995:             @index = cached.interval.end
2996:           end
2997:           return cached
2998:         end
2999: 
3000:         i0, s0 = index, []
3001:         if has_terminal?('', false, index)
3002:           r1 = instantiate_node(SyntaxNode,input, index...(index + 0))
3003:           @index += 0
3004:         else
3005:           terminal_parse_failure('')
3006:           r1 = nil
3007:         end
3008:         s0 << r1
3009:         if r1
3010:           r2 = _nt_inline_module
3011:           s0 << r2
3012:         end
3013:         if s0.last
3014:           r0 = instantiate_node(PredicateBlock,input, i0...index, s0)
3015:           r0.extend(PredicateBlock0)
3016:         else
3017:           @index = i0
3018:           r0 = nil
3019:         end
3020: 
3021:         node_cache[:predicate_block][start_index] = r0
3022: 
3023:         r0
3024:       end

      # File lib/treetop/compiler/metagrammar.rb, line 1992
1992:       def _nt_prefix
1993:         start_index = index
1994:         if node_cache[:prefix].has_key?(index)
1995:           cached = node_cache[:prefix][index]
1996:           if cached
1997:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
1998:             @index = cached.interval.end
1999:           end
2000:           return cached
2001:         end
2002: 
2003:         i0 = index
2004:         if has_terminal?('&', false, index)
2005:           r1 = instantiate_node(AndPredicate,input, index...(index + 1))
2006:           @index += 1
2007:         else
2008:           terminal_parse_failure('&')
2009:           r1 = nil
2010:         end
2011:         if r1
2012:           r0 = r1
2013:         else
2014:           if has_terminal?('!', false, index)
2015:             r2 = instantiate_node(NotPredicate,input, index...(index + 1))
2016:             @index += 1
2017:           else
2018:             terminal_parse_failure('!')
2019:             r2 = nil
2020:           end
2021:           if r2
2022:             r0 = r2
2023:           else
2024:             if has_terminal?('~', false, index)
2025:               r3 = instantiate_node(TransientPrefix,input, index...(index + 1))
2026:               @index += 1
2027:             else
2028:               terminal_parse_failure('~')
2029:               r3 = nil
2030:             end
2031:             if r3
2032:               r0 = r3
2033:             else
2034:               @index = i0
2035:               r0 = nil
2036:             end
2037:           end
2038:         end
2039: 
2040:         node_cache[:prefix][start_index] = r0
2041: 
2042:         r0
2043:       end

      # File lib/treetop/compiler/metagrammar.rb, line 1302
1302:       def _nt_primary
1303:         start_index = index
1304:         if node_cache[:primary].has_key?(index)
1305:           cached = node_cache[:primary][index]
1306:           if cached
1307:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
1308:             @index = cached.interval.end
1309:           end
1310:           return cached
1311:         end
1312: 
1313:         i0 = index
1314:         i1, s1 = index, []
1315:         r2 = _nt_prefix
1316:         s1 << r2
1317:         if r2
1318:           r3 = _nt_atomic
1319:           s1 << r3
1320:         end
1321:         if s1.last
1322:           r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
1323:           r1.extend(Primary0)
1324:           r1.extend(Primary1)
1325:         else
1326:           @index = i1
1327:           r1 = nil
1328:         end
1329:         if r1
1330:           r0 = r1
1331:         else
1332:           i4, s4 = index, []
1333:           r5 = _nt_prefix
1334:           s4 << r5
1335:           if r5
1336:             r7 = _nt_space
1337:             if r7
1338:               r6 = r7
1339:             else
1340:               r6 = instantiate_node(SyntaxNode,input, index...index)
1341:             end
1342:             s4 << r6
1343:             if r6
1344:               r8 = _nt_predicate_block
1345:               s4 << r8
1346:             end
1347:           end
1348:           if s4.last
1349:             r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
1350:             r4.extend(Primary2)
1351:             r4.extend(Primary3)
1352:           else
1353:             @index = i4
1354:             r4 = nil
1355:           end
1356:           if r4
1357:             r0 = r4
1358:           else
1359:             i9, s9 = index, []
1360:             r10 = _nt_atomic
1361:             s9 << r10
1362:             if r10
1363:               r11 = _nt_suffix
1364:               s9 << r11
1365:               if r11
1366:                 r12 = _nt_node_class_declarations
1367:                 s9 << r12
1368:               end
1369:             end
1370:             if s9.last
1371:               r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
1372:               r9.extend(Primary4)
1373:               r9.extend(Primary5)
1374:             else
1375:               @index = i9
1376:               r9 = nil
1377:             end
1378:             if r9
1379:               r0 = r9
1380:             else
1381:               i13, s13 = index, []
1382:               r14 = _nt_atomic
1383:               s13 << r14
1384:               if r14
1385:                 r15 = _nt_node_class_declarations
1386:                 s13 << r15
1387:               end
1388:               if s13.last
1389:                 r13 = instantiate_node(SyntaxNode,input, i13...index, s13)
1390:                 r13.extend(Primary6)
1391:                 r13.extend(Primary7)
1392:               else
1393:                 @index = i13
1394:                 r13 = nil
1395:               end
1396:               if r13
1397:                 r0 = r13
1398:               else
1399:                 @index = i0
1400:                 r0 = nil
1401:               end
1402:             end
1403:           end
1404:         end
1405: 
1406:         node_cache[:primary][start_index] = r0
1407: 
1408:         r0
1409:       end

      # File lib/treetop/compiler/metagrammar.rb, line 2270
2270:       def _nt_quoted_string
2271:         start_index = index
2272:         if node_cache[:quoted_string].has_key?(index)
2273:           cached = node_cache[:quoted_string][index]
2274:           if cached
2275:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
2276:             @index = cached.interval.end
2277:           end
2278:           return cached
2279:         end
2280: 
2281:         i0 = index
2282:         r1 = _nt_single_quoted_string
2283:         if r1
2284:           r0 = r1
2285:           r0.extend(QuotedString0)
2286:         else
2287:           r2 = _nt_double_quoted_string
2288:           if r2
2289:             r0 = r2
2290:             r0.extend(QuotedString0)
2291:           else
2292:             @index = i0
2293:             r0 = nil
2294:           end
2295:         end
2296: 
2297:         node_cache[:quoted_string][start_index] = r0
2298: 
2299:         r0
2300:       end

      # File lib/treetop/compiler/metagrammar.rb, line 1857
1857:       def _nt_repetition_suffix
1858:         start_index = index
1859:         if node_cache[:repetition_suffix].has_key?(index)
1860:           cached = node_cache[:repetition_suffix][index]
1861:           if cached
1862:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
1863:             @index = cached.interval.end
1864:           end
1865:           return cached
1866:         end
1867: 
1868:         i0 = index
1869:         if has_terminal?('+', false, index)
1870:           r1 = instantiate_node(OneOrMore,input, index...(index + 1))
1871:           @index += 1
1872:         else
1873:           terminal_parse_failure('+')
1874:           r1 = nil
1875:         end
1876:         if r1
1877:           r0 = r1
1878:         else
1879:           if has_terminal?('*', false, index)
1880:             r2 = instantiate_node(ZeroOrMore,input, index...(index + 1))
1881:             @index += 1
1882:           else
1883:             terminal_parse_failure('*')
1884:             r2 = nil
1885:           end
1886:           if r2
1887:             r0 = r2
1888:           else
1889:             r3 = _nt_occurrence_range
1890:             if r3
1891:               r0 = r3
1892:             else
1893:               @index = i0
1894:               r0 = nil
1895:             end
1896:           end
1897:         end
1898: 
1899:         node_cache[:repetition_suffix][start_index] = r0
1900: 
1901:         r0
1902:       end

     # File lib/treetop/compiler/metagrammar.rb, line 139
139:       def _nt_require_statement
140:         start_index = index
141:         if node_cache[:require_statement].has_key?(index)
142:           cached = node_cache[:require_statement][index]
143:           if cached
144:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
145:             @index = cached.interval.end
146:           end
147:           return cached
148:         end
149: 
150:         i0, s0 = index, []
151:         r2 = _nt_space
152:         if r2
153:           r1 = r2
154:         else
155:           r1 = instantiate_node(SyntaxNode,input, index...index)
156:         end
157:         s0 << r1
158:         if r1
159:           if has_terminal?("require", false, index)
160:             r3 = instantiate_node(SyntaxNode,input, index...(index + 7))
161:             @index += 7
162:           else
163:             terminal_parse_failure("require")
164:             r3 = nil
165:           end
166:           s0 << r3
167:           if r3
168:             s4, i4 = [], index
169:             loop do
170:               if has_terminal?('\G[ \t]', true, index)
171:                 r5 = true
172:                 @index += 1
173:               else
174:                 r5 = nil
175:               end
176:               if r5
177:                 s4 << r5
178:               else
179:                 break
180:               end
181:             end
182:             if s4.empty?
183:               @index = i4
184:               r4 = nil
185:             else
186:               r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
187:             end
188:             s0 << r4
189:             if r4
190:               s6, i6 = [], index
191:               loop do
192:                 if has_terminal?('\G[^\n\r]', true, index)
193:                   r7 = true
194:                   @index += 1
195:                 else
196:                   r7 = nil
197:                 end
198:                 if r7
199:                   s6 << r7
200:                 else
201:                   break
202:                 end
203:               end
204:               if s6.empty?
205:                 @index = i6
206:                 r6 = nil
207:               else
208:                 r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
209:               end
210:               s0 << r6
211:               if r6
212:                 if has_terminal?('\G[\n\r]', true, index)
213:                   r8 = true
214:                   @index += 1
215:                 else
216:                   r8 = nil
217:                 end
218:                 s0 << r8
219:               end
220:             end
221:           end
222:         end
223:         if s0.last
224:           r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
225:           r0.extend(RequireStatement0)
226:         else
227:           @index = i0
228:           r0 = nil
229:         end
230: 
231:         node_cache[:require_statement][start_index] = r0
232: 
233:         r0
234:       end

      # File lib/treetop/compiler/metagrammar.rb, line 1095
1095:       def _nt_sequence
1096:         start_index = index
1097:         if node_cache[:sequence].has_key?(index)
1098:           cached = node_cache[:sequence][index]
1099:           if cached
1100:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
1101:             @index = cached.interval.end
1102:           end
1103:           return cached
1104:         end
1105: 
1106:         i0, s0 = index, []
1107:         r1 = _nt_labeled_sequence_primary
1108:         s0 << r1
1109:         if r1
1110:           s2, i2 = [], index
1111:           loop do
1112:             i3, s3 = index, []
1113:             r4 = _nt_space
1114:             s3 << r4
1115:             if r4
1116:               r5 = _nt_labeled_sequence_primary
1117:               s3 << r5
1118:             end
1119:             if s3.last
1120:               r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
1121:               r3.extend(Sequence0)
1122:             else
1123:               @index = i3
1124:               r3 = nil
1125:             end
1126:             if r3
1127:               s2 << r3
1128:             else
1129:               break
1130:             end
1131:           end
1132:           if s2.empty?
1133:             @index = i2
1134:             r2 = nil
1135:           else
1136:             r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
1137:           end
1138:           s0 << r2
1139:           if r2
1140:             r6 = _nt_node_class_declarations
1141:             s0 << r6
1142:           end
1143:         end
1144:         if s0.last
1145:           r0 = instantiate_node(Sequence,input, i0...index, s0)
1146:           r0.extend(Sequence1)
1147:           r0.extend(Sequence2)
1148:         else
1149:           @index = i0
1150:           r0 = nil
1151:         end
1152: 
1153:         node_cache[:sequence][start_index] = r0
1154: 
1155:         r0
1156:       end

      # File lib/treetop/compiler/metagrammar.rb, line 1652
1652:       def _nt_sequence_primary
1653:         start_index = index
1654:         if node_cache[:sequence_primary].has_key?(index)
1655:           cached = node_cache[:sequence_primary][index]
1656:           if cached
1657:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
1658:             @index = cached.interval.end
1659:           end
1660:           return cached
1661:         end
1662: 
1663:         i0 = index
1664:         i1, s1 = index, []
1665:         r2 = _nt_prefix
1666:         s1 << r2
1667:         if r2
1668:           r3 = _nt_atomic
1669:           s1 << r3
1670:         end
1671:         if s1.last
1672:           r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
1673:           r1.extend(SequencePrimary0)
1674:           r1.extend(SequencePrimary1)
1675:         else
1676:           @index = i1
1677:           r1 = nil
1678:         end
1679:         if r1
1680:           r0 = r1
1681:         else
1682:           i4, s4 = index, []
1683:           r5 = _nt_prefix
1684:           s4 << r5
1685:           if r5
1686:             r7 = _nt_space
1687:             if r7
1688:               r6 = r7
1689:             else
1690:               r6 = instantiate_node(SyntaxNode,input, index...index)
1691:             end
1692:             s4 << r6
1693:             if r6
1694:               r8 = _nt_predicate_block
1695:               s4 << r8
1696:             end
1697:           end
1698:           if s4.last
1699:             r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
1700:             r4.extend(SequencePrimary2)
1701:             r4.extend(SequencePrimary3)
1702:           else
1703:             @index = i4
1704:             r4 = nil
1705:           end
1706:           if r4
1707:             r0 = r4
1708:           else
1709:             i9, s9 = index, []
1710:             r10 = _nt_atomic
1711:             s9 << r10
1712:             if r10
1713:               r11 = _nt_suffix
1714:               s9 << r11
1715:             end
1716:             if s9.last
1717:               r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
1718:               r9.extend(SequencePrimary4)
1719:               r9.extend(SequencePrimary5)
1720:             else
1721:               @index = i9
1722:               r9 = nil
1723:             end
1724:             if r9
1725:               r0 = r9
1726:             else
1727:               r12 = _nt_atomic
1728:               if r12
1729:                 r0 = r12
1730:               else
1731:                 @index = i0
1732:                 r0 = nil
1733:               end
1734:             end
1735:           end
1736:         end
1737: 
1738:         node_cache[:sequence_primary][start_index] = r0
1739: 
1740:         r0
1741:       end

      # File lib/treetop/compiler/metagrammar.rb, line 2439
2439:       def _nt_single_quoted_string
2440:         start_index = index
2441:         if node_cache[:single_quoted_string].has_key?(index)
2442:           cached = node_cache[:single_quoted_string][index]
2443:           if cached
2444:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
2445:             @index = cached.interval.end
2446:           end
2447:           return cached
2448:         end
2449: 
2450:         i0, s0 = index, []
2451:         if has_terminal?("'", false, index)
2452:           r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
2453:           @index += 1
2454:         else
2455:           terminal_parse_failure("'")
2456:           r1 = nil
2457:         end
2458:         s0 << r1
2459:         if r1
2460:           s2, i2 = [], index
2461:           loop do
2462:             i3, s3 = index, []
2463:             i4 = index
2464:             if has_terminal?("'", false, index)
2465:               r5 = instantiate_node(SyntaxNode,input, index...(index + 1))
2466:               @index += 1
2467:             else
2468:               terminal_parse_failure("'")
2469:               r5 = nil
2470:             end
2471:             if r5
2472:               r4 = nil
2473:             else
2474:               @index = i4
2475:               r4 = instantiate_node(SyntaxNode,input, index...index)
2476:             end
2477:             s3 << r4
2478:             if r4
2479:               i6 = index
2480:               if has_terminal?("\\\\", false, index)
2481:                 r7 = instantiate_node(SyntaxNode,input, index...(index + 2))
2482:                 @index += 2
2483:               else
2484:                 terminal_parse_failure("\\\\")
2485:                 r7 = nil
2486:               end
2487:               if r7
2488:                 r6 = r7
2489:               else
2490:                 if has_terminal?("\\'", false, index)
2491:                   r8 = instantiate_node(SyntaxNode,input, index...(index + 2))
2492:                   @index += 2
2493:                 else
2494:                   terminal_parse_failure("\\'")
2495:                   r8 = nil
2496:                 end
2497:                 if r8
2498:                   r6 = r8
2499:                 else
2500:                   if index < input_length
2501:                     r9 = instantiate_node(SyntaxNode,input, index...(index + 1))
2502:                     @index += 1
2503:                   else
2504:                     terminal_parse_failure("any character")
2505:                     r9 = nil
2506:                   end
2507:                   if r9
2508:                     r6 = r9
2509:                   else
2510:                     @index = i6
2511:                     r6 = nil
2512:                   end
2513:                 end
2514:               end
2515:               s3 << r6
2516:             end
2517:             if s3.last
2518:               r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
2519:               r3.extend(SingleQuotedString0)
2520:             else
2521:               @index = i3
2522:               r3 = nil
2523:             end
2524:             if r3
2525:               s2 << r3
2526:             else
2527:               break
2528:             end
2529:           end
2530:           r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
2531:           s0 << r2
2532:           if r2
2533:             if has_terminal?("'", false, index)
2534:               r10 = instantiate_node(SyntaxNode,input, index...(index + 1))
2535:               @index += 1
2536:             else
2537:               terminal_parse_failure("'")
2538:               r10 = nil
2539:             end
2540:             s0 << r10
2541:           end
2542:         end
2543:         if s0.last
2544:           r0 = instantiate_node(Terminal,input, i0...index, s0)
2545:           r0.extend(SingleQuotedString1)
2546:         else
2547:           @index = i0
2548:           r0 = nil
2549:         end
2550: 
2551:         node_cache[:single_quoted_string][start_index] = r0
2552: 
2553:         r0
2554:       end

      # File lib/treetop/compiler/metagrammar.rb, line 3301
3301:       def _nt_space
3302:         start_index = index
3303:         if node_cache[:space].has_key?(index)
3304:           cached = node_cache[:space][index]
3305:           if cached
3306:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
3307:             @index = cached.interval.end
3308:           end
3309:           return cached
3310:         end
3311: 
3312:         s0, i0 = [], index
3313:         loop do
3314:           i1 = index
3315:           r2 = _nt_white
3316:           if r2
3317:             r1 = r2
3318:           else
3319:             r3 = _nt_comment_to_eol
3320:             if r3
3321:               r1 = r3
3322:             else
3323:               @index = i1
3324:               r1 = nil
3325:             end
3326:           end
3327:           if r1
3328:             s0 << r1
3329:           else
3330:             break
3331:           end
3332:         end
3333:         if s0.empty?
3334:           @index = i0
3335:           r0 = nil
3336:         else
3337:           r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
3338:         end
3339: 
3340:         node_cache[:space][start_index] = r0
3341: 
3342:         r0
3343:       end

      # File lib/treetop/compiler/metagrammar.rb, line 1743
1743:       def _nt_suffix
1744:         start_index = index
1745:         if node_cache[:suffix].has_key?(index)
1746:           cached = node_cache[:suffix][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:         r1 = _nt_repetition_suffix
1756:         if r1
1757:           r0 = r1
1758:         else
1759:           r2 = _nt_optional_suffix
1760:           if r2
1761:             r0 = r2
1762:           else
1763:             @index = i0
1764:             r0 = nil
1765:           end
1766:         end
1767: 
1768:         node_cache[:suffix][start_index] = r0
1769: 
1770:         r0
1771:       end

      # File lib/treetop/compiler/metagrammar.rb, line 2229
2229:       def _nt_terminal
2230:         start_index = index
2231:         if node_cache[:terminal].has_key?(index)
2232:           cached = node_cache[:terminal][index]
2233:           if cached
2234:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
2235:             @index = cached.interval.end
2236:           end
2237:           return cached
2238:         end
2239: 
2240:         i0 = index
2241:         r1 = _nt_quoted_string
2242:         if r1
2243:           r0 = r1
2244:         else
2245:           r2 = _nt_character_class
2246:           if r2
2247:             r0 = r2
2248:           else
2249:             r3 = _nt_anything_symbol
2250:             if r3
2251:               r0 = r3
2252:             else
2253:               @index = i0
2254:               r0 = nil
2255:             end
2256:           end
2257:         end
2258: 
2259:         node_cache[:terminal][start_index] = r0
2260: 
2261:         r0
2262:       end

      # File lib/treetop/compiler/metagrammar.rb, line 2932
2932:       def _nt_trailing_inline_module
2933:         start_index = index
2934:         if node_cache[:trailing_inline_module].has_key?(index)
2935:           cached = node_cache[:trailing_inline_module][index]
2936:           if cached
2937:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
2938:             @index = cached.interval.end
2939:           end
2940:           return cached
2941:         end
2942: 
2943:         i0 = index
2944:         i1, s1 = index, []
2945:         r2 = _nt_space
2946:         s1 << r2
2947:         if r2
2948:           r3 = _nt_inline_module
2949:           s1 << r3
2950:         end
2951:         if s1.last
2952:           r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
2953:           r1.extend(TrailingInlineModule0)
2954:           r1.extend(TrailingInlineModule1)
2955:         else
2956:           @index = i1
2957:           r1 = nil
2958:         end
2959:         if r1
2960:           r0 = r1
2961:         else
2962:           if has_terminal?('', false, index)
2963:             r4 = instantiate_node(SyntaxNode,input, index...(index + 0))
2964:             r4.extend(TrailingInlineModule2)
2965:             @index += 0
2966:           else
2967:             terminal_parse_failure('')
2968:             r4 = nil
2969:           end
2970:           if r4
2971:             r0 = r4
2972:           else
2973:             @index = i0
2974:             r0 = nil
2975:           end
2976:         end
2977: 
2978:         node_cache[:trailing_inline_module][start_index] = r0
2979: 
2980:         r0
2981:       end

     # 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:             i8 = index
 94:             r9 = _nt_module_declaration
 95:             if r9
 96:               r8 = r9
 97:             else
 98:               r10 = _nt_grammar
 99:               if r10
100:                 r8 = r10
101:               else
102:                 @index = i8
103:                 r8 = nil
104:               end
105:             end
106:             s0 << r8
107:             if r8
108:               r12 = _nt_space
109:               if r12
110:                 r11 = r12
111:               else
112:                 r11 = instantiate_node(SyntaxNode,input, index...index)
113:               end
114:               s0 << r11
115:             end
116:           end
117:         end
118:         if s0.last
119:           r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
120:           r0.extend(TreetopFile1)
121:           r0.extend(TreetopFile2)
122:         else
123:           @index = i0
124:           r0 = nil
125:         end
126: 
127:         node_cache[:treetop_file][start_index] = r0
128: 
129:         r0
130:       end

      # File lib/treetop/compiler/metagrammar.rb, line 3429
3429:       def _nt_white
3430:         start_index = index
3431:         if node_cache[:white].has_key?(index)
3432:           cached = node_cache[:white][index]
3433:           if cached
3434:             cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
3435:             @index = cached.interval.end
3436:           end
3437:           return cached
3438:         end
3439: 
3440:         if has_terminal?('\G[ \t\n\r]', true, index)
3441:           r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
3442:           @index += 1
3443:         else
3444:           r0 = nil
3445:         end
3446: 
3447:         node_cache[:white][start_index] = r0
3448: 
3449:         r0
3450:       end

    # File lib/treetop/compiler/metagrammar.rb, line 9
 9:       def root
10:         @root ||= :treetop_file
11:       end