soroban 0.7.3 → 0.8.0

data/lib/soroban/import.rb

@@ -1 +1,4 @@
-require 'soroban/import/ruby_xl_importer'
+if defined?(RubyXL)
+  require 'soroban/import/ruby_xl_patch'
+  require 'soroban/import/ruby_xl_importer'
+end

data/lib/soroban/import/ruby_xl_importer.rb

@@ -1,12 +1,15 @@
+require 'soroban/helpers'
+require 'soroban/sheet'
+require 'soroban/label_walker'
+
 module Soroban
+
   module Import
 
     # Use the RubyXL gem to load an xlsx file, returning a new Soroban::Sheet
     # object. Specify the path to the xlsx file, the index of the sheet to be
     # imported, and a hash of name => label bindings.
     def self.rubyXL(path, sheet, bindings)
-      require 'rubyXL'
-      require 'soroban/import/ruby_xl_patch'
       RubyXLImporter.new(path, sheet, bindings).import
     end
 
@@ -15,41 +18,44 @@ module Soroban
     class RubyXLImporter
 
       def initialize(path, index, bindings)
-        @path, @index, @bindings = path, index, bindings
+        @_path, @_index, @_bindings = path, index, bindings
+        @_sheet = nil
+        @_model = nil
       end
 
       def import
-        workbook = RubyXL::Parser.parse(@path)
-        @sheet = workbook.worksheets[@index]
-        @model = Soroban::Sheet.new
-        @bindings.values.each do |label_or_range|
-          if Soroban::range?(label_or_range)
-            LabelWalker.new(label_or_range).each do |label|
+        workbook = RubyXL::Parser.parse(@_path)
+        @_sheet = workbook.worksheets[@_index]
+        @_model = Soroban::Sheet.new
+        @_bindings.values.each do |label_or_range|
+          if Soroban::Helpers::range?(label_or_range)
+            Soroban::LabelWalker.new(label_or_range).each do |label|
               _addCell(label)
             end
           else
             _addCell(label_or_range)
           end
         end
-        while label = @model.missing.first
+        while label = @_model.missing.first
           _addCell(label)
         end
-        @model.bind(@bindings)
-        return @model
+        @_model.bind(@_bindings)
+        return @_model
       end
 
       private
 
       def _addCell(label)
-        row, col = Soroban::getPos(label)
-        cell = @sheet[row][col]
+        row, col = Soroban::Helpers::getPos(label)
+        cell = @_sheet[row][col]
         data = cell.formula rescue nil
         data = "=#{data}" unless data.nil?
         data ||= cell.value.to_s rescue nil
-        @model.set(label.to_sym => data)
+        @_model.set(label.to_sym => data)
       end
 
     end
 
   end
+
 end

data/lib/soroban/import/ruby_xl_patch.rb

@@ -1,7 +1,9 @@
 module RubyXL
+
   class Cell < PrivateClass
     def is_date?
       return false
     end
   end
+
 end

data/lib/soroban/label_walker.rb

@@ -1,30 +1,31 @@
+require 'soroban/helpers'
+
 module Soroban
 
-  # An enumerable that allows cells in a range to be visited.
+  # An enumerable that allows the labels for cells in a range to be visited.
   class LabelWalker
-
     include Enumerable
 
     # Create a new walker from a supplied range.
     def initialize(range)
-      @fc, @fr, @tc, @tr = Soroban::getRange(range)
+      @_fc, @_fr, @_tc, @_tr = Soroban::Helpers.getRange(range)
     end
 
-    # Yield the label of each cell referenced by the supplied range.
+    # Yield the label of each cell referenced by the supplied range. For a range
+    # of the form "A1:B4", this will yield "A1", "A2", "A3", ..., "B3", "B4".
     def each
-      col, row = @fc, @fr
+      col, row = @_fc, @_fr
       while true do
         yield "#{col}#{row}"
-        break if row == @tr && col == @tc
-        if row == @tr
-          row = @fr
+        break if row == @_tr && col == @_tc
+        if row == @_tr
+          row = @_fr
           col = col.next
         else
           row = row.next
         end
       end
     end
-
   end
 
 end

data/lib/soroban/parser.rb

@@ -6,10 +6,12 @@ require 'soroban/parser/grammar'
 
 module Soroban
 
-  # A Treetop parser for Excel formulas that can generate valid Ruby expression
-  # via a rewrite operation, and which can build an array of referenced labels.
-  def self.parser
-    @@parser ||= SorobanParser.new
+  class Parser
+    # A Treetop parser for Excel formulas that can generate valid Ruby expression
+    # via a rewrite operation, and which can build an array of referenced labels.
+    def self.instance
+      @@parser ||= ExcelParser.new
+    end
   end
 
 end

data/lib/soroban/parser/grammar.rb

@@ -2,989 +2,991 @@
 
 
 module Soroban
-  include Treetop::Runtime
+  module Excel
+    include Treetop::Runtime
 
-  def root
-    @root ||= :formula
-  end
-
-  module Formula0
-    def logical
-      elements[2]
+    def root
+      @root ||= :formula
     end
-  end
 
-  def _nt_formula
-    start_index = index
-    if node_cache[:formula].has_key?(index)
-      cached = node_cache[:formula][index]
-      if cached
-        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
+    module Formula0
+      def logical
+        elements[2]
       end
-      return cached
     end
 
-    i0 = index
-    i1, s1 = index, []
-    if has_terminal?('=', false, index)
-      r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
-      @index += 1
-    else
-      terminal_parse_failure('=')
-      r2 = nil
-    end
-    s1 << r2
-    if r2
-      r4 = _nt_space
-      if r4
-        r3 = r4
+    def _nt_formula
+      start_index = index
+      if node_cache[:formula].has_key?(index)
+        cached = node_cache[:formula][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+
+      i0 = index
+      i1, s1 = index, []
+      if has_terminal?('=', false, index)
+        r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
+        @index += 1
       else
-        r3 = instantiate_node(SyntaxNode,input, index...index)
+        terminal_parse_failure('=')
+        r2 = nil
+      end
+      s1 << r2
+      if r2
+        r4 = _nt_space
+        if r4
+          r3 = r4
+        else
+          r3 = instantiate_node(SyntaxNode,input, index...index)
+        end
+        s1 << r3
+        if r3
+          r5 = _nt_logical
+          s1 << r5
+        end
       end
-      s1 << r3
-      if r3
-        r5 = _nt_logical
-        s1 << r5
+      if s1.last
+        r1 = instantiate_node(Formula,input, i1...index, s1)
+        r1.extend(Formula0)
+      else
+        @index = i1
+        r1 = nil
       end
-    end
-    if s1.last
-      r1 = instantiate_node(Formula,input, i1...index, s1)
-      r1.extend(Formula0)
-    else
-      @index = i1
-      r1 = nil
-    end
-    if r1
-      r0 = r1
-    else
-      r6 = _nt_string
-      if r6
-        r0 = r6
+      if r1
+        r0 = r1
       else
-        r7 = _nt_number
-        if r7
-          r0 = r7
+        r6 = _nt_string
+        if r6
+          r0 = r6
         else
-          r8 = _nt_boolean
-          if r8
-            r0 = r8
+          r7 = _nt_number
+          if r7
+            r0 = r7
           else
-            @index = i0
-            r0 = nil
+            r8 = _nt_boolean
+            if r8
+              r0 = r8
+            else
+              @index = i0
+              r0 = nil
+            end
           end
         end
       end
-    end
-
-    node_cache[:formula][start_index] = r0
 
-    r0
-  end
+      node_cache[:formula][start_index] = r0
 
-  module Logical0
-    def and
-      elements[3]
+      r0
     end
-  end
 
-  module Logical1
-    def and
-      elements[0]
+    module Logical0
+      def and
+        elements[3]
+      end
     end
 
-  end
-
-  def _nt_logical
-    start_index = index
-    if node_cache[:logical].has_key?(index)
-      cached = node_cache[:logical][index]
-      if cached
-        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
+    module Logical1
+      def and
+        elements[0]
       end
-      return cached
+
     end
 
-    i0, s0 = index, []
-    r1 = _nt_and
-    s0 << r1
-    if r1
-      s2, i2 = [], index
-      loop do
-        i3, s3 = index, []
-        r5 = _nt_space
-        if r5
-          r4 = r5
-        else
-          r4 = instantiate_node(SyntaxNode,input, index...index)
+    def _nt_logical
+      start_index = index
+      if node_cache[:logical].has_key?(index)
+        cached = node_cache[:logical][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
         end
-        s3 << r4
-        if r4
-          if has_terminal?('or', false, index)
-            r6 = instantiate_node(SyntaxNode,input, index...(index + 2))
-            @index += 2
+        return cached
+      end
+
+      i0, s0 = index, []
+      r1 = _nt_and
+      s0 << r1
+      if r1
+        s2, i2 = [], index
+        loop do
+          i3, s3 = index, []
+          r5 = _nt_space
+          if r5
+            r4 = r5
           else
-            terminal_parse_failure('or')
-            r6 = nil
+            r4 = instantiate_node(SyntaxNode,input, index...index)
           end
-          s3 << r6
-          if r6
-            r8 = _nt_space
-            if r8
-              r7 = r8
+          s3 << r4
+          if r4
+            if has_terminal?('or', false, index)
+              r6 = instantiate_node(SyntaxNode,input, index...(index + 2))
+              @index += 2
             else
-              r7 = instantiate_node(SyntaxNode,input, index...index)
+              terminal_parse_failure('or')
+              r6 = nil
             end
-            s3 << r7
-            if r7
-              r9 = _nt_and
-              s3 << r9
+            s3 << r6
+            if r6
+              r8 = _nt_space
+              if r8
+                r7 = r8
+              else
+                r7 = instantiate_node(SyntaxNode,input, index...index)
+              end
+              s3 << r7
+              if r7
+                r9 = _nt_and
+                s3 << r9
+              end
             end
           end
+          if s3.last
+            r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+            r3.extend(Logical0)
+          else
+            @index = i3
+            r3 = nil
+          end
+          if r3
+            s2 << r3
+          else
+            break
+          end
         end
-        if s3.last
-          r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
-          r3.extend(Logical0)
-        else
-          @index = i3
-          r3 = nil
-        end
-        if r3
-          s2 << r3
-        else
-          break
-        end
+        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+        s0 << r2
+      end
+      if s0.last
+        r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+        r0.extend(Logical1)
+      else
+        @index = i0
+        r0 = nil
       end
-      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
-      s0 << r2
-    end
-    if s0.last
-      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(Logical1)
-    else
-      @index = i0
-      r0 = nil
-    end
-
-    node_cache[:logical][start_index] = r0
 
-    r0
-  end
+      node_cache[:logical][start_index] = r0
 
-  module And0
-    def truthval
-      elements[3]
+      r0
     end
-  end
 
-  module And1
-    def truthval
-      elements[0]
+    module And0
+      def truthval
+        elements[3]
+      end
     end
 
-  end
-
-  def _nt_and
-    start_index = index
-    if node_cache[:and].has_key?(index)
-      cached = node_cache[:and][index]
-      if cached
-        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
+    module And1
+      def truthval
+        elements[0]
       end
-      return cached
+
     end
 
-    i0, s0 = index, []
-    r1 = _nt_truthval
-    s0 << r1
-    if r1
-      s2, i2 = [], index
-      loop do
-        i3, s3 = index, []
-        r5 = _nt_space
-        if r5
-          r4 = r5
-        else
-          r4 = instantiate_node(SyntaxNode,input, index...index)
+    def _nt_and
+      start_index = index
+      if node_cache[:and].has_key?(index)
+        cached = node_cache[:and][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
         end
-        s3 << r4
-        if r4
-          if has_terminal?('and', false, index)
-            r6 = instantiate_node(SyntaxNode,input, index...(index + 3))
-            @index += 3
+        return cached
+      end
+
+      i0, s0 = index, []
+      r1 = _nt_truthval
+      s0 << r1
+      if r1
+        s2, i2 = [], index
+        loop do
+          i3, s3 = index, []
+          r5 = _nt_space
+          if r5
+            r4 = r5
           else
-            terminal_parse_failure('and')
-            r6 = nil
+            r4 = instantiate_node(SyntaxNode,input, index...index)
           end
-          s3 << r6
-          if r6
-            r8 = _nt_space
-            if r8
-              r7 = r8
+          s3 << r4
+          if r4
+            if has_terminal?('and', false, index)
+              r6 = instantiate_node(SyntaxNode,input, index...(index + 3))
+              @index += 3
             else
-              r7 = instantiate_node(SyntaxNode,input, index...index)
+              terminal_parse_failure('and')
+              r6 = nil
             end
-            s3 << r7
-            if r7
-              r9 = _nt_truthval
-              s3 << r9
+            s3 << r6
+            if r6
+              r8 = _nt_space
+              if r8
+                r7 = r8
+              else
+                r7 = instantiate_node(SyntaxNode,input, index...index)
+              end
+              s3 << r7
+              if r7
+                r9 = _nt_truthval
+                s3 << r9
+              end
             end
           end
+          if s3.last
+            r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+            r3.extend(And0)
+          else
+            @index = i3
+            r3 = nil
+          end
+          if r3
+            s2 << r3
+          else
+            break
+          end
         end
-        if s3.last
-          r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
-          r3.extend(And0)
-        else
-          @index = i3
-          r3 = nil
-        end
-        if r3
-          s2 << r3
-        else
-          break
-        end
+        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+        s0 << r2
+      end
+      if s0.last
+        r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+        r0.extend(And1)
+      else
+        @index = i0
+        r0 = nil
       end
-      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
-      s0 << r2
-    end
-    if s0.last
-      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(And1)
-    else
-      @index = i0
-      r0 = nil
-    end
-
-    node_cache[:and][start_index] = r0
 
-    r0
-  end
+      node_cache[:and][start_index] = r0
 
-  module Truthval0
-    def logical
-      elements[2]
+      r0
     end
 
-  end
-
-  def _nt_truthval
-    start_index = index
-    if node_cache[:truthval].has_key?(index)
-      cached = node_cache[:truthval][index]
-      if cached
-        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
+    module Truthval0
+      def logical
+        elements[2]
       end
-      return cached
+
     end
 
-    i0 = index
-    r1 = _nt_comparison
-    if r1
-      r0 = r1
-    else
-      i2, s2 = index, []
-      if has_terminal?('(', false, index)
-        r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
-        @index += 1
+    def _nt_truthval
+      start_index = index
+      if node_cache[:truthval].has_key?(index)
+        cached = node_cache[:truthval][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+
+      i0 = index
+      r1 = _nt_comparison
+      if r1
+        r0 = r1
       else
-        terminal_parse_failure('(')
-        r3 = nil
-      end
-      s2 << r3
-      if r3
-        r5 = _nt_space
-        if r5
-          r4 = r5
+        i2, s2 = index, []
+        if has_terminal?('(', false, index)
+          r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
         else
-          r4 = instantiate_node(SyntaxNode,input, index...index)
+          terminal_parse_failure('(')
+          r3 = nil
         end
-        s2 << r4
-        if r4
-          r6 = _nt_logical
-          s2 << r6
-          if r6
-            r8 = _nt_space
-            if r8
-              r7 = r8
-            else
-              r7 = instantiate_node(SyntaxNode,input, index...index)
-            end
-            s2 << r7
-            if r7
-              if has_terminal?(')', false, index)
-                r9 = instantiate_node(SyntaxNode,input, index...(index + 1))
-                @index += 1
+        s2 << r3
+        if r3
+          r5 = _nt_space
+          if r5
+            r4 = r5
+          else
+            r4 = instantiate_node(SyntaxNode,input, index...index)
+          end
+          s2 << r4
+          if r4
+            r6 = _nt_logical
+            s2 << r6
+            if r6
+              r8 = _nt_space
+              if r8
+                r7 = r8
               else
-                terminal_parse_failure(')')
-                r9 = nil
+                r7 = instantiate_node(SyntaxNode,input, index...index)
+              end
+              s2 << r7
+              if r7
+                if has_terminal?(')', false, index)
+                  r9 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                  @index += 1
+                else
+                  terminal_parse_failure(')')
+                  r9 = nil
+                end
+                s2 << r9
               end
-              s2 << r9
             end
           end
         end
-      end
-      if s2.last
-        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
-        r2.extend(Truthval0)
-      else
-        @index = i2
-        r2 = nil
-      end
-      if r2
-        r0 = r2
-      else
-        r10 = _nt_boolean
-        if r10
-          r0 = r10
+        if s2.last
+          r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+          r2.extend(Truthval0)
         else
-          @index = i0
-          r0 = nil
+          @index = i2
+          r2 = nil
+        end
+        if r2
+          r0 = r2
+        else
+          r10 = _nt_boolean
+          if r10
+            r0 = r10
+          else
+            @index = i0
+            r0 = nil
+          end
         end
       end
-    end
 
-    node_cache[:truthval][start_index] = r0
+      node_cache[:truthval][start_index] = r0
 
-    r0
-  end
+      r0
+    end
 
-  def _nt_boolean
-    start_index = index
-    if node_cache[:boolean].has_key?(index)
-      cached = node_cache[:boolean][index]
-      if cached
-        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
+    def _nt_boolean
+      start_index = index
+      if node_cache[:boolean].has_key?(index)
+        cached = node_cache[:boolean][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
       end
-      return cached
-    end
 
-    i0 = index
-    if has_terminal?('true', false, index)
-      r1 = instantiate_node(SyntaxNode,input, index...(index + 4))
-      @index += 4
-    else
-      terminal_parse_failure('true')
-      r1 = nil
-    end
-    if r1
-      r0 = r1
-    else
-      if has_terminal?('false', false, index)
-        r2 = instantiate_node(SyntaxNode,input, index...(index + 5))
-        @index += 5
+      i0 = index
+      if has_terminal?('true', false, index)
+        r1 = instantiate_node(SyntaxNode,input, index...(index + 4))
+        @index += 4
       else
-        terminal_parse_failure('false')
-        r2 = nil
+        terminal_parse_failure('true')
+        r1 = nil
       end
-      if r2
-        r0 = r2
+      if r1
+        r0 = r1
       else
-        if has_terminal?('TRUE', false, index)
-          r3 = instantiate_node(SyntaxNode,input, index...(index + 4))
-          @index += 4
+        if has_terminal?('false', false, index)
+          r2 = instantiate_node(SyntaxNode,input, index...(index + 5))
+          @index += 5
         else
-          terminal_parse_failure('TRUE')
-          r3 = nil
+          terminal_parse_failure('false')
+          r2 = nil
         end
-        if r3
-          r0 = r3
+        if r2
+          r0 = r2
         else
-          if has_terminal?('FALSE', false, index)
-            r4 = instantiate_node(SyntaxNode,input, index...(index + 5))
-            @index += 5
+          if has_terminal?('TRUE', false, index)
+            r3 = instantiate_node(SyntaxNode,input, index...(index + 4))
+            @index += 4
           else
-            terminal_parse_failure('FALSE')
-            r4 = nil
+            terminal_parse_failure('TRUE')
+            r3 = nil
           end
-          if r4
-            r0 = r4
+          if r3
+            r0 = r3
           else
-            @index = i0
-            r0 = nil
+            if has_terminal?('FALSE', false, index)
+              r4 = instantiate_node(SyntaxNode,input, index...(index + 5))
+              @index += 5
+            else
+              terminal_parse_failure('FALSE')
+              r4 = nil
+            end
+            if r4
+              r0 = r4
+            else
+              @index = i0
+              r0 = nil
+            end
           end
         end
       end
-    end
 
-    node_cache[:boolean][start_index] = r0
-
-    r0
-  end
+      node_cache[:boolean][start_index] = r0
 
-  module Comparison0
-    def comparator
-      elements[1]
+      r0
     end
 
-    def expression
-      elements[3]
-    end
-  end
+    module Comparison0
+      def comparator
+        elements[1]
+      end
 
-  module Comparison1
-    def expression
-      elements[0]
+      def expression
+        elements[3]
+      end
     end
 
-  end
-
-  def _nt_comparison
-    start_index = index
-    if node_cache[:comparison].has_key?(index)
-      cached = node_cache[:comparison][index]
-      if cached
-        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
+    module Comparison1
+      def expression
+        elements[0]
       end
-      return cached
+
     end
 
-    i0, s0 = index, []
-    r1 = _nt_expression
-    s0 << r1
-    if r1
-      s2, i2 = [], index
-      loop do
-        i3, s3 = index, []
-        r5 = _nt_space
-        if r5
-          r4 = r5
-        else
-          r4 = instantiate_node(SyntaxNode,input, index...index)
+    def _nt_comparison
+      start_index = index
+      if node_cache[:comparison].has_key?(index)
+        cached = node_cache[:comparison][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
         end
-        s3 << r4
-        if r4
-          r6 = _nt_comparator
-          s3 << r6
-          if r6
-            r8 = _nt_space
-            if r8
-              r7 = r8
-            else
-              r7 = instantiate_node(SyntaxNode,input, index...index)
-            end
-            s3 << r7
-            if r7
-              r9 = _nt_expression
-              s3 << r9
+        return cached
+      end
+
+      i0, s0 = index, []
+      r1 = _nt_expression
+      s0 << r1
+      if r1
+        s2, i2 = [], index
+        loop do
+          i3, s3 = index, []
+          r5 = _nt_space
+          if r5
+            r4 = r5
+          else
+            r4 = instantiate_node(SyntaxNode,input, index...index)
+          end
+          s3 << r4
+          if r4
+            r6 = _nt_comparator
+            s3 << r6
+            if r6
+              r8 = _nt_space
+              if r8
+                r7 = r8
+              else
+                r7 = instantiate_node(SyntaxNode,input, index...index)
+              end
+              s3 << r7
+              if r7
+                r9 = _nt_expression
+                s3 << r9
+              end
             end
           end
+          if s3.last
+            r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+            r3.extend(Comparison0)
+          else
+            @index = i3
+            r3 = nil
+          end
+          if r3
+            s2 << r3
+          else
+            break
+          end
         end
-        if s3.last
-          r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
-          r3.extend(Comparison0)
-        else
-          @index = i3
-          r3 = nil
-        end
-        if r3
-          s2 << r3
-        else
-          break
-        end
+        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+        s0 << r2
+      end
+      if s0.last
+        r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+        r0.extend(Comparison1)
+      else
+        @index = i0
+        r0 = nil
       end
-      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
-      s0 << r2
-    end
-    if s0.last
-      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(Comparison1)
-    else
-      @index = i0
-      r0 = nil
-    end
 
-    node_cache[:comparison][start_index] = r0
+      node_cache[:comparison][start_index] = r0
 
-    r0
-  end
+      r0
+    end
 
-  def _nt_comparator
-    start_index = index
-    if node_cache[:comparator].has_key?(index)
-      cached = node_cache[:comparator][index]
-      if cached
-        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
+    def _nt_comparator
+      start_index = index
+      if node_cache[:comparator].has_key?(index)
+        cached = node_cache[:comparator][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
       end
-      return cached
-    end
 
-    i0 = index
-    if has_terminal?('=', false, index)
-      r1 = instantiate_node(Equal,input, index...(index + 1))
-      @index += 1
-    else
-      terminal_parse_failure('=')
-      r1 = nil
-    end
-    if r1
-      r0 = r1
-    else
-      if has_terminal?('<>', false, index)
-        r2 = instantiate_node(NotEqual,input, index...(index + 2))
-        @index += 2
+      i0 = index
+      if has_terminal?('=', false, index)
+        r1 = instantiate_node(Equal,input, index...(index + 1))
+        @index += 1
       else
-        terminal_parse_failure('<>')
-        r2 = nil
+        terminal_parse_failure('=')
+        r1 = nil
       end
-      if r2
-        r0 = r2
+      if r1
+        r0 = r1
       else
-        if has_terminal?('>=', false, index)
-          r3 = instantiate_node(SyntaxNode,input, index...(index + 2))
+        if has_terminal?('<>', false, index)
+          r2 = instantiate_node(NotEqual,input, index...(index + 2))
           @index += 2
         else
-          terminal_parse_failure('>=')
-          r3 = nil
+          terminal_parse_failure('<>')
+          r2 = nil
         end
-        if r3
-          r0 = r3
+        if r2
+          r0 = r2
         else
-          if has_terminal?('<=', false, index)
-            r4 = instantiate_node(SyntaxNode,input, index...(index + 2))
+          if has_terminal?('>=', false, index)
+            r3 = instantiate_node(SyntaxNode,input, index...(index + 2))
             @index += 2
           else
-            terminal_parse_failure('<=')
-            r4 = nil
+            terminal_parse_failure('>=')
+            r3 = nil
           end
-          if r4
-            r0 = r4
+          if r3
+            r0 = r3
           else
-            if has_terminal?('>', false, index)
-              r5 = instantiate_node(SyntaxNode,input, index...(index + 1))
-              @index += 1
+            if has_terminal?('<=', false, index)
+              r4 = instantiate_node(SyntaxNode,input, index...(index + 2))
+              @index += 2
             else
-              terminal_parse_failure('>')
-              r5 = nil
+              terminal_parse_failure('<=')
+              r4 = nil
             end
-            if r5
-              r0 = r5
+            if r4
+              r0 = r4
             else
-              if has_terminal?('<', false, index)
-                r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
+              if has_terminal?('>', false, index)
+                r5 = instantiate_node(SyntaxNode,input, index...(index + 1))
                 @index += 1
               else
-                terminal_parse_failure('<')
-                r6 = nil
+                terminal_parse_failure('>')
+                r5 = nil
               end
-              if r6
-                r0 = r6
+              if r5
+                r0 = r5
               else
-                @index = i0
-                r0 = nil
+                if has_terminal?('<', false, index)
+                  r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                  @index += 1
+                else
+                  terminal_parse_failure('<')
+                  r6 = nil
+                end
+                if r6
+                  r0 = r6
+                else
+                  @index = i0
+                  r0 = nil
+                end
               end
             end
           end
         end
       end
-    end
-
-    node_cache[:comparator][start_index] = r0
 
-    r0
-  end
+      node_cache[:comparator][start_index] = r0
 
-  module Expression0
-    def additive_operator
-      elements[1]
+      r0
     end
 
-    def multiplicative
-      elements[3]
-    end
-  end
+    module Expression0
+      def additive_operator
+        elements[1]
+      end
 
-  module Expression1
-    def multiplicative
-      elements[0]
+      def multiplicative
+        elements[3]
+      end
     end
 
-  end
-
-  def _nt_expression
-    start_index = index
-    if node_cache[:expression].has_key?(index)
-      cached = node_cache[:expression][index]
-      if cached
-        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
+    module Expression1
+      def multiplicative
+        elements[0]
       end
-      return cached
+
     end
 
-    i0, s0 = index, []
-    r1 = _nt_multiplicative
-    s0 << r1
-    if r1
-      s2, i2 = [], index
-      loop do
-        i3, s3 = index, []
-        r5 = _nt_space
-        if r5
-          r4 = r5
-        else
-          r4 = instantiate_node(SyntaxNode,input, index...index)
+    def _nt_expression
+      start_index = index
+      if node_cache[:expression].has_key?(index)
+        cached = node_cache[:expression][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
         end
-        s3 << r4
-        if r4
-          r6 = _nt_additive_operator
-          s3 << r6
-          if r6
-            r8 = _nt_space
-            if r8
-              r7 = r8
-            else
-              r7 = instantiate_node(SyntaxNode,input, index...index)
-            end
-            s3 << r7
-            if r7
-              r9 = _nt_multiplicative
-              s3 << r9
+        return cached
+      end
+
+      i0, s0 = index, []
+      r1 = _nt_multiplicative
+      s0 << r1
+      if r1
+        s2, i2 = [], index
+        loop do
+          i3, s3 = index, []
+          r5 = _nt_space
+          if r5
+            r4 = r5
+          else
+            r4 = instantiate_node(SyntaxNode,input, index...index)
+          end
+          s3 << r4
+          if r4
+            r6 = _nt_additive_operator
+            s3 << r6
+            if r6
+              r8 = _nt_space
+              if r8
+                r7 = r8
+              else
+                r7 = instantiate_node(SyntaxNode,input, index...index)
+              end
+              s3 << r7
+              if r7
+                r9 = _nt_multiplicative
+                s3 << r9
+              end
             end
           end
+          if s3.last
+            r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+            r3.extend(Expression0)
+          else
+            @index = i3
+            r3 = nil
+          end
+          if r3
+            s2 << r3
+          else
+            break
+          end
         end
-        if s3.last
-          r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
-          r3.extend(Expression0)
-        else
-          @index = i3
-          r3 = nil
-        end
-        if r3
-          s2 << r3
-        else
-          break
-        end
+        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+        s0 << r2
+      end
+      if s0.last
+        r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+        r0.extend(Expression1)
+      else
+        @index = i0
+        r0 = nil
       end
-      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
-      s0 << r2
-    end
-    if s0.last
-      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(Expression1)
-    else
-      @index = i0
-      r0 = nil
-    end
 
-    node_cache[:expression][start_index] = r0
+      node_cache[:expression][start_index] = r0
 
-    r0
-  end
+      r0
+    end
 
-  def _nt_additive_operator
-    start_index = index
-    if node_cache[:additive_operator].has_key?(index)
-      cached = node_cache[:additive_operator][index]
-      if cached
-        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
+    def _nt_additive_operator
+      start_index = index
+      if node_cache[:additive_operator].has_key?(index)
+        cached = node_cache[:additive_operator][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
       end
-      return cached
-    end
 
-    i0 = index
-    if has_terminal?('+', false, index)
-      r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
-      @index += 1
-    else
-      terminal_parse_failure('+')
-      r1 = nil
-    end
-    if r1
-      r0 = r1
-    else
-      if has_terminal?('-', false, index)
-        r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
+      i0 = index
+      if has_terminal?('+', false, index)
+        r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
         @index += 1
       else
-        terminal_parse_failure('-')
-        r2 = nil
+        terminal_parse_failure('+')
+        r1 = nil
       end
-      if r2
-        r0 = r2
+      if r1
+        r0 = r1
       else
-        @index = i0
-        r0 = nil
+        if has_terminal?('-', false, index)
+          r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
+        else
+          terminal_parse_failure('-')
+          r2 = nil
+        end
+        if r2
+          r0 = r2
+        else
+          @index = i0
+          r0 = nil
+        end
       end
-    end
-
-    node_cache[:additive_operator][start_index] = r0
 
-    r0
-  end
+      node_cache[:additive_operator][start_index] = r0
 
-  module Multiplicative0
-    def multiplicative_operator
-      elements[1]
+      r0
     end
 
-    def value
-      elements[3]
-    end
-  end
+    module Multiplicative0
+      def multiplicative_operator
+        elements[1]
+      end
 
-  module Multiplicative1
-    def value
-      elements[0]
+      def value
+        elements[3]
+      end
     end
 
-  end
-
-  def _nt_multiplicative
-    start_index = index
-    if node_cache[:multiplicative].has_key?(index)
-      cached = node_cache[:multiplicative][index]
-      if cached
-        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
+    module Multiplicative1
+      def value
+        elements[0]
       end
-      return cached
+
     end
 
-    i0, s0 = index, []
-    r1 = _nt_value
-    s0 << r1
-    if r1
-      s2, i2 = [], index
-      loop do
-        i3, s3 = index, []
-        r5 = _nt_space
-        if r5
-          r4 = r5
-        else
-          r4 = instantiate_node(SyntaxNode,input, index...index)
+    def _nt_multiplicative
+      start_index = index
+      if node_cache[:multiplicative].has_key?(index)
+        cached = node_cache[:multiplicative][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
         end
-        s3 << r4
-        if r4
-          r6 = _nt_multiplicative_operator
-          s3 << r6
-          if r6
-            r8 = _nt_space
-            if r8
-              r7 = r8
-            else
-              r7 = instantiate_node(SyntaxNode,input, index...index)
-            end
-            s3 << r7
-            if r7
-              r9 = _nt_value
-              s3 << r9
+        return cached
+      end
+
+      i0, s0 = index, []
+      r1 = _nt_value
+      s0 << r1
+      if r1
+        s2, i2 = [], index
+        loop do
+          i3, s3 = index, []
+          r5 = _nt_space
+          if r5
+            r4 = r5
+          else
+            r4 = instantiate_node(SyntaxNode,input, index...index)
+          end
+          s3 << r4
+          if r4
+            r6 = _nt_multiplicative_operator
+            s3 << r6
+            if r6
+              r8 = _nt_space
+              if r8
+                r7 = r8
+              else
+                r7 = instantiate_node(SyntaxNode,input, index...index)
+              end
+              s3 << r7
+              if r7
+                r9 = _nt_value
+                s3 << r9
+              end
             end
           end
+          if s3.last
+            r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+            r3.extend(Multiplicative0)
+          else
+            @index = i3
+            r3 = nil
+          end
+          if r3
+            s2 << r3
+          else
+            break
+          end
         end
-        if s3.last
-          r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
-          r3.extend(Multiplicative0)
-        else
-          @index = i3
-          r3 = nil
-        end
-        if r3
-          s2 << r3
-        else
-          break
-        end
+        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+        s0 << r2
+      end
+      if s0.last
+        r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+        r0.extend(Multiplicative1)
+      else
+        @index = i0
+        r0 = nil
       end
-      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
-      s0 << r2
-    end
-    if s0.last
-      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(Multiplicative1)
-    else
-      @index = i0
-      r0 = nil
-    end
 
-    node_cache[:multiplicative][start_index] = r0
+      node_cache[:multiplicative][start_index] = r0
 
-    r0
-  end
+      r0
+    end
 
-  def _nt_multiplicative_operator
-    start_index = index
-    if node_cache[:multiplicative_operator].has_key?(index)
-      cached = node_cache[:multiplicative_operator][index]
-      if cached
-        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
+    def _nt_multiplicative_operator
+      start_index = index
+      if node_cache[:multiplicative_operator].has_key?(index)
+        cached = node_cache[:multiplicative_operator][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
       end
-      return cached
-    end
 
-    i0 = index
-    if has_terminal?('^', false, index)
-      r1 = instantiate_node(Pow,input, index...(index + 1))
-      @index += 1
-    else
-      terminal_parse_failure('^')
-      r1 = nil
-    end
-    if r1
-      r0 = r1
-    else
-      if has_terminal?('*', false, index)
-        r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
+      i0 = index
+      if has_terminal?('^', false, index)
+        r1 = instantiate_node(Pow,input, index...(index + 1))
         @index += 1
       else
-        terminal_parse_failure('*')
-        r2 = nil
+        terminal_parse_failure('^')
+        r1 = nil
       end
-      if r2
-        r0 = r2
+      if r1
+        r0 = r1
       else
-        if has_terminal?('/', false, index)
-          r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
+        if has_terminal?('*', false, index)
+          r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
           @index += 1
         else
-          terminal_parse_failure('/')
-          r3 = nil
+          terminal_parse_failure('*')
+          r2 = nil
         end
-        if r3
-          r0 = r3
+        if r2
+          r0 = r2
         else
-          @index = i0
-          r0 = nil
+          if has_terminal?('/', false, index)
+            r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
+            @index += 1
+          else
+            terminal_parse_failure('/')
+            r3 = nil
+          end
+          if r3
+            r0 = r3
+          else
+            @index = i0
+            r0 = nil
+          end
         end
       end
-    end
 
-    node_cache[:multiplicative_operator][start_index] = r0
+      node_cache[:multiplicative_operator][start_index] = r0
 
-    r0
-  end
-
-  module Value0
-    def expression
-      elements[2]
+      r0
     end
 
-  end
+    module Value0
+      def expression
+        elements[2]
+      end
 
-  module Value1
-    def value
-      elements[1]
     end
-  end
 
-  def _nt_value
-    start_index = index
-    if node_cache[:value].has_key?(index)
-      cached = node_cache[:value][index]
-      if cached
-        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
+    module Value1
+      def value
+        elements[1]
       end
-      return cached
     end
 
-    i0 = index
-    r1 = _nt_function
-    if r1
-      r0 = r1
-    else
-      i2, s2 = index, []
-      if has_terminal?('(', false, index)
-        r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
-        @index += 1
+    def _nt_value
+      start_index = index
+      if node_cache[:value].has_key?(index)
+        cached = node_cache[:value][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+
+      i0 = index
+      r1 = _nt_function
+      if r1
+        r0 = r1
       else
-        terminal_parse_failure('(')
-        r3 = nil
-      end
-      s2 << r3
-      if r3
-        r5 = _nt_space
-        if r5
-          r4 = r5
+        i2, s2 = index, []
+        if has_terminal?('(', false, index)
+          r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
         else
-          r4 = instantiate_node(SyntaxNode,input, index...index)
+          terminal_parse_failure('(')
+          r3 = nil
         end
-        s2 << r4
-        if r4
-          r6 = _nt_expression
-          s2 << r6
-          if r6
-            r8 = _nt_space
-            if r8
-              r7 = r8
-            else
-              r7 = instantiate_node(SyntaxNode,input, index...index)
-            end
-            s2 << r7
-            if r7
-              if has_terminal?(')', false, index)
-                r9 = instantiate_node(SyntaxNode,input, index...(index + 1))
-                @index += 1
+        s2 << r3
+        if r3
+          r5 = _nt_space
+          if r5
+            r4 = r5
+          else
+            r4 = instantiate_node(SyntaxNode,input, index...index)
+          end
+          s2 << r4
+          if r4
+            r6 = _nt_expression
+            s2 << r6
+            if r6
+              r8 = _nt_space
+              if r8
+                r7 = r8
               else
-                terminal_parse_failure(')')
-                r9 = nil
+                r7 = instantiate_node(SyntaxNode,input, index...index)
+              end
+              s2 << r7
+              if r7
+                if has_terminal?(')', false, index)
+                  r9 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                  @index += 1
+                else
+                  terminal_parse_failure(')')
+                  r9 = nil
+                end
+                s2 << r9
               end
-              s2 << r9
             end
           end
         end
-      end
-      if s2.last
-        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
-        r2.extend(Value0)
-      else
-        @index = i2
-        r2 = nil
-      end
-      if r2
-        r0 = r2
-      else
-        r10 = _nt_range
-        if r10
-          r0 = r10
+        if s2.last
+          r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+          r2.extend(Value0)
         else
-          r11 = _nt_number
-          if r11
-            r0 = r11
+          @index = i2
+          r2 = nil
+        end
+        if r2
+          r0 = r2
+        else
+          r10 = _nt_range
+          if r10
+            r0 = r10
           else
-            r12 = _nt_boolean
-            if r12
-              r0 = r12
+            r11 = _nt_number
+            if r11
+              r0 = r11
             else
-              r13 = _nt_identifier
-              if r13
-                r0 = r13
+              r12 = _nt_boolean
+              if r12
+                r0 = r12
               else
-                r14 = _nt_string
-                if r14
-                  r0 = r14
+                r13 = _nt_identifier
+                if r13
+                  r0 = r13
                 else
-                  i15, s15 = index, []
-                  if has_terminal?('-', false, index)
-                    r16 = instantiate_node(SyntaxNode,input, index...(index + 1))
-                    @index += 1
-                  else
-                    terminal_parse_failure('-')
-                    r16 = nil
-                  end
-                  s15 << r16
-                  if r16
-                    r17 = _nt_value
-                    s15 << r17
-                  end
-                  if s15.last
-                    r15 = instantiate_node(SyntaxNode,input, i15...index, s15)
-                    r15.extend(Value1)
-                  else
-                    @index = i15
-                    r15 = nil
-                  end
-                  if r15
-                    r0 = r15
+                  r14 = _nt_string
+                  if r14
+                    r0 = r14
                   else
-                    @index = i0
-                    r0 = nil
+                    i15, s15 = index, []
+                    if has_terminal?('-', false, index)
+                      r16 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                      @index += 1
+                    else
+                      terminal_parse_failure('-')
+                      r16 = nil
+                    end
+                    s15 << r16
+                    if r16
+                      r17 = _nt_value
+                      s15 << r17
+                    end
+                    if s15.last
+                      r15 = instantiate_node(SyntaxNode,input, i15...index, s15)
+                      r15.extend(Value1)
+                    else
+                      @index = i15
+                      r15 = nil
+                    end
+                    if r15
+                      r0 = r15
+                    else
+                      @index = i0
+                      r0 = nil
+                    end
                   end
                 end
               end
@@ -992,883 +994,883 @@ module Soroban
           end
         end
       end
-    end
 
-    node_cache[:value][start_index] = r0
+      node_cache[:value][start_index] = r0
 
-    r0
-  end
+      r0
+    end
 
-  module Function0
-  end
+    module Function0
+    end
 
-  def _nt_function
-    start_index = index
-    if node_cache[:function].has_key?(index)
-      cached = node_cache[:function][index]
-      if cached
-        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
+    def _nt_function
+      start_index = index
+      if node_cache[:function].has_key?(index)
+        cached = node_cache[:function][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
       end
-      return cached
-    end
 
-    i0, s0 = index, []
-    s1, i1 = [], index
-    loop do
-      if has_terminal?('\G[a-zA-Z]', true, index)
-        r2 = true
-        @index += 1
-      else
-        r2 = nil
+      i0, s0 = index, []
+      s1, i1 = [], index
+      loop do
+        if has_terminal?('\G[a-zA-Z]', true, index)
+          r2 = true
+          @index += 1
+        else
+          r2 = nil
+        end
+        if r2
+          s1 << r2
+        else
+          break
+        end
       end
-      if r2
-        s1 << r2
+      if s1.empty?
+        @index = i1
+        r1 = nil
       else
-        break
+        r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
       end
-    end
-    if s1.empty?
-      @index = i1
-      r1 = nil
-    else
-      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
-    end
-    s0 << r1
-    if r1
-      if has_terminal?('(', false, index)
-        r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
-        @index += 1
-      else
-        terminal_parse_failure('(')
-        r3 = nil
-      end
-      s0 << r3
-      if r3
-        r5 = _nt_space
-        if r5
-          r4 = r5
+      s0 << r1
+      if r1
+        if has_terminal?('(', false, index)
+          r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
         else
-          r4 = instantiate_node(SyntaxNode,input, index...index)
+          terminal_parse_failure('(')
+          r3 = nil
         end
-        s0 << r4
-        if r4
-          r7 = _nt_arguments
-          if r7
-            r6 = r7
+        s0 << r3
+        if r3
+          r5 = _nt_space
+          if r5
+            r4 = r5
           else
-            r6 = instantiate_node(SyntaxNode,input, index...index)
+            r4 = instantiate_node(SyntaxNode,input, index...index)
           end
-          s0 << r6
-          if r6
-            r9 = _nt_space
-            if r9
-              r8 = r9
+          s0 << r4
+          if r4
+            r7 = _nt_arguments
+            if r7
+              r6 = r7
             else
-              r8 = instantiate_node(SyntaxNode,input, index...index)
+              r6 = instantiate_node(SyntaxNode,input, index...index)
             end
-            s0 << r8
-            if r8
-              if has_terminal?(')', false, index)
-                r10 = instantiate_node(SyntaxNode,input, index...(index + 1))
-                @index += 1
+            s0 << r6
+            if r6
+              r9 = _nt_space
+              if r9
+                r8 = r9
               else
-                terminal_parse_failure(')')
-                r10 = nil
+                r8 = instantiate_node(SyntaxNode,input, index...index)
+              end
+              s0 << r8
+              if r8
+                if has_terminal?(')', false, index)
+                  r10 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                  @index += 1
+                else
+                  terminal_parse_failure(')')
+                  r10 = nil
+                end
+                s0 << r10
               end
-              s0 << r10
             end
           end
         end
       end
-    end
-    if s0.last
-      r0 = instantiate_node(Function,input, i0...index, s0)
-      r0.extend(Function0)
-    else
-      @index = i0
-      r0 = nil
-    end
-
-    node_cache[:function][start_index] = r0
+      if s0.last
+        r0 = instantiate_node(Function,input, i0...index, s0)
+        r0.extend(Function0)
+      else
+        @index = i0
+        r0 = nil
+      end
 
-    r0
-  end
+      node_cache[:function][start_index] = r0
 
-  module Arguments0
-    def logical
-      elements[3]
+      r0
     end
-  end
 
-  module Arguments1
-    def logical
-      elements[0]
+    module Arguments0
+      def logical
+        elements[3]
+      end
     end
 
-  end
-
-  def _nt_arguments
-    start_index = index
-    if node_cache[:arguments].has_key?(index)
-      cached = node_cache[:arguments][index]
-      if cached
-        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
+    module Arguments1
+      def logical
+        elements[0]
       end
-      return cached
+
     end
 
-    i0, s0 = index, []
-    r1 = _nt_logical
-    s0 << r1
-    if r1
-      s2, i2 = [], index
-      loop do
-        i3, s3 = index, []
-        r5 = _nt_space
-        if r5
-          r4 = r5
-        else
-          r4 = instantiate_node(SyntaxNode,input, index...index)
+    def _nt_arguments
+      start_index = index
+      if node_cache[:arguments].has_key?(index)
+        cached = node_cache[:arguments][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
         end
-        s3 << r4
-        if r4
-          if has_terminal?(',', false, index)
-            r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
-            @index += 1
+        return cached
+      end
+
+      i0, s0 = index, []
+      r1 = _nt_logical
+      s0 << r1
+      if r1
+        s2, i2 = [], index
+        loop do
+          i3, s3 = index, []
+          r5 = _nt_space
+          if r5
+            r4 = r5
           else
-            terminal_parse_failure(',')
-            r6 = nil
+            r4 = instantiate_node(SyntaxNode,input, index...index)
           end
-          s3 << r6
-          if r6
-            r8 = _nt_space
-            if r8
-              r7 = r8
+          s3 << r4
+          if r4
+            if has_terminal?(',', false, index)
+              r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
+              @index += 1
             else
-              r7 = instantiate_node(SyntaxNode,input, index...index)
+              terminal_parse_failure(',')
+              r6 = nil
             end
-            s3 << r7
-            if r7
-              r9 = _nt_logical
-              s3 << r9
+            s3 << r6
+            if r6
+              r8 = _nt_space
+              if r8
+                r7 = r8
+              else
+                r7 = instantiate_node(SyntaxNode,input, index...index)
+              end
+              s3 << r7
+              if r7
+                r9 = _nt_logical
+                s3 << r9
+              end
             end
           end
+          if s3.last
+            r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+            r3.extend(Arguments0)
+          else
+            @index = i3
+            r3 = nil
+          end
+          if r3
+            s2 << r3
+          else
+            break
+          end
         end
-        if s3.last
-          r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
-          r3.extend(Arguments0)
-        else
-          @index = i3
-          r3 = nil
-        end
-        if r3
-          s2 << r3
-        else
-          break
-        end
+        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+        s0 << r2
+      end
+      if s0.last
+        r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+        r0.extend(Arguments1)
+      else
+        @index = i0
+        r0 = nil
       end
-      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
-      s0 << r2
-    end
-    if s0.last
-      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-      r0.extend(Arguments1)
-    else
-      @index = i0
-      r0 = nil
-    end
-
-    node_cache[:arguments][start_index] = r0
 
-    r0
-  end
+      node_cache[:arguments][start_index] = r0
 
-  module Number0
-    def float
-      elements[1]
+      r0
     end
-  end
 
-  module Number1
-    def integer
-      elements[1]
+    module Number0
+      def float
+        elements[1]
+      end
     end
-  end
 
-  def _nt_number
-    start_index = index
-    if node_cache[:number].has_key?(index)
-      cached = node_cache[:number][index]
-      if cached
-        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
+    module Number1
+      def integer
+        elements[1]
       end
-      return cached
     end
 
-    i0 = index
-    r1 = _nt_float
-    if r1
-      r0 = r1
-    else
-      r2 = _nt_integer
-      if r2
-        r0 = r2
-      else
-        i3, s3 = index, []
-        if has_terminal?('-', false, index)
-          r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
-          @index += 1
-        else
-          terminal_parse_failure('-')
-          r4 = nil
-        end
-        s3 << r4
-        if r4
-          r5 = _nt_float
-          s3 << r5
+    def _nt_number
+      start_index = index
+      if node_cache[:number].has_key?(index)
+        cached = node_cache[:number][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
         end
-        if s3.last
-          r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
-          r3.extend(Number0)
-        else
-          @index = i3
-          r3 = nil
-        end
-        if r3
-          r0 = r3
+        return cached
+      end
+
+      i0 = index
+      r1 = _nt_float
+      if r1
+        r0 = r1
+      else
+        r2 = _nt_integer
+        if r2
+          r0 = r2
         else
-          i6, s6 = index, []
+          i3, s3 = index, []
           if has_terminal?('-', false, index)
-            r7 = instantiate_node(SyntaxNode,input, index...(index + 1))
+            r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
             @index += 1
           else
             terminal_parse_failure('-')
-            r7 = nil
+            r4 = nil
           end
-          s6 << r7
-          if r7
-            r8 = _nt_integer
-            s6 << r8
+          s3 << r4
+          if r4
+            r5 = _nt_float
+            s3 << r5
           end
-          if s6.last
-            r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
-            r6.extend(Number1)
+          if s3.last
+            r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+            r3.extend(Number0)
           else
-            @index = i6
-            r6 = nil
+            @index = i3
+            r3 = nil
           end
-          if r6
-            r0 = r6
+          if r3
+            r0 = r3
           else
-            @index = i0
-            r0 = nil
+            i6, s6 = index, []
+            if has_terminal?('-', false, index)
+              r7 = instantiate_node(SyntaxNode,input, index...(index + 1))
+              @index += 1
+            else
+              terminal_parse_failure('-')
+              r7 = nil
+            end
+            s6 << r7
+            if r7
+              r8 = _nt_integer
+              s6 << r8
+            end
+            if s6.last
+              r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
+              r6.extend(Number1)
+            else
+              @index = i6
+              r6 = nil
+            end
+            if r6
+              r0 = r6
+            else
+              @index = i0
+              r0 = nil
+            end
           end
         end
       end
-    end
-
-    node_cache[:number][start_index] = r0
 
-    r0
-  end
+      node_cache[:number][start_index] = r0
 
-  module Float0
-  end
+      r0
+    end
 
-  def _nt_float
-    start_index = index
-    if node_cache[:float].has_key?(index)
-      cached = node_cache[:float][index]
-      if cached
-        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
-      end
-      return cached
+    module Float0
     end
 
-    i0, s0 = index, []
-    s1, i1 = [], index
-    loop do
-      if has_terminal?('\G[0-9]', true, index)
-        r2 = true
-        @index += 1
-      else
-        r2 = nil
-      end
-      if r2
-        s1 << r2
-      else
-        break
+    def _nt_float
+      start_index = index
+      if node_cache[:float].has_key?(index)
+        cached = node_cache[:float][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
       end
-    end
-    r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
-    s0 << r1
-    if r1
-      if has_terminal?('.', false, index)
-        r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
-        @index += 1
-      else
-        terminal_parse_failure('.')
-        r3 = nil
+
+      i0, s0 = index, []
+      s1, i1 = [], index
+      loop do
+        if has_terminal?('\G[0-9]', true, index)
+          r2 = true
+          @index += 1
+        else
+          r2 = nil
+        end
+        if r2
+          s1 << r2
+        else
+          break
+        end
       end
-      s0 << r3
-      if r3
-        s4, i4 = [], index
-        loop do
-          if has_terminal?('\G[0-9]', true, index)
-            r5 = true
-            @index += 1
-          else
-            r5 = nil
+      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+      s0 << r1
+      if r1
+        if has_terminal?('.', false, index)
+          r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
+        else
+          terminal_parse_failure('.')
+          r3 = nil
+        end
+        s0 << r3
+        if r3
+          s4, i4 = [], index
+          loop do
+            if has_terminal?('\G[0-9]', true, index)
+              r5 = true
+              @index += 1
+            else
+              r5 = nil
+            end
+            if r5
+              s4 << r5
+            else
+              break
+            end
           end
-          if r5
-            s4 << r5
+          if s4.empty?
+            @index = i4
+            r4 = nil
           else
-            break
+            r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
           end
+          s0 << r4
         end
-        if s4.empty?
-          @index = i4
-          r4 = nil
-        else
-          r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
-        end
-        s0 << r4
-      end
-    end
-    if s0.last
-      r0 = instantiate_node(FloatValue,input, i0...index, s0)
-      r0.extend(Float0)
-    else
-      @index = i0
-      r0 = nil
-    end
-
-    node_cache[:float][start_index] = r0
-
-    r0
-  end
-
-  def _nt_integer
-    start_index = index
-    if node_cache[:integer].has_key?(index)
-      cached = node_cache[:integer][index]
-      if cached
-        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
       end
-      return cached
-    end
-
-    s0, i0 = [], index
-    loop do
-      if has_terminal?('\G[0-9]', true, index)
-        r1 = true
-        @index += 1
+      if s0.last
+        r0 = instantiate_node(FloatValue,input, i0...index, s0)
+        r0.extend(Float0)
       else
-        r1 = nil
-      end
-      if r1
-        s0 << r1
-      else
-        break
+        @index = i0
+        r0 = nil
       end
-    end
-    if s0.empty?
-      @index = i0
-      r0 = nil
-    else
-      r0 = instantiate_node(IntegerValue,input, i0...index, s0)
-    end
 
-    node_cache[:integer][start_index] = r0
-
-    r0
-  end
+      node_cache[:float][start_index] = r0
 
-  module Identifier0
-  end
+      r0
+    end
 
-  def _nt_identifier
-    start_index = index
-    if node_cache[:identifier].has_key?(index)
-      cached = node_cache[:identifier][index]
-      if cached
-        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
+    def _nt_integer
+      start_index = index
+      if node_cache[:integer].has_key?(index)
+        cached = node_cache[:integer][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
       end
-      return cached
-    end
 
-    i0, s0 = index, []
-    if has_terminal?('\G[a-zA-Z]', true, index)
-      r1 = true
-      @index += 1
-    else
-      r1 = nil
-    end
-    s0 << r1
-    if r1
-      s2, i2 = [], index
+      s0, i0 = [], index
       loop do
-        if has_terminal?('\G[a-zA-Z0-9]', true, index)
-          r3 = true
+        if has_terminal?('\G[0-9]', true, index)
+          r1 = true
           @index += 1
         else
-          r3 = nil
+          r1 = nil
         end
-        if r3
-          s2 << r3
+        if r1
+          s0 << r1
         else
           break
         end
       end
-      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
-      s0 << r2
-    end
-    if s0.last
-      r0 = instantiate_node(Identifier,input, i0...index, s0)
-      r0.extend(Identifier0)
-    else
-      @index = i0
-      r0 = nil
-    end
-
-    node_cache[:identifier][start_index] = r0
-
-    r0
-  end
+      if s0.empty?
+        @index = i0
+        r0 = nil
+      else
+        r0 = instantiate_node(IntegerValue,input, i0...index, s0)
+      end
 
-  module Label0
-  end
+      node_cache[:integer][start_index] = r0
 
-  module Label1
-  end
+      r0
+    end
 
-  def _nt_label
-    start_index = index
-    if node_cache[:label].has_key?(index)
-      cached = node_cache[:label][index]
-      if cached
-        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
-      end
-      return cached
+    module Identifier0
     end
 
-    i0 = index
-    i1, s1 = index, []
-    s2, i2 = [], index
-    loop do
-      if has_terminal?('\G[A-Za-z]', true, index)
-        r3 = true
-        @index += 1
-      else
-        r3 = nil
-      end
-      if r3
-        s2 << r3
-      else
-        break
+    def _nt_identifier
+      start_index = index
+      if node_cache[:identifier].has_key?(index)
+        cached = node_cache[:identifier][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
       end
-    end
-    if s2.empty?
-      @index = i2
-      r2 = nil
-    else
-      r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
-    end
-    s1 << r2
-    if r2
-      if has_terminal?('\G[1-9]', true, index)
-        r4 = true
+
+      i0, s0 = index, []
+      if has_terminal?('\G[a-zA-Z]', true, index)
+        r1 = true
         @index += 1
       else
-        r4 = nil
+        r1 = nil
       end
-      s1 << r4
-      if r4
-        s5, i5 = [], index
+      s0 << r1
+      if r1
+        s2, i2 = [], index
         loop do
-          if has_terminal?('\G[0-9]', true, index)
-            r6 = true
+          if has_terminal?('\G[a-zA-Z0-9]', true, index)
+            r3 = true
             @index += 1
           else
-            r6 = nil
+            r3 = nil
           end
-          if r6
-            s5 << r6
+          if r3
+            s2 << r3
           else
             break
           end
         end
-        r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
-        s1 << r5
+        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+        s0 << r2
       end
+      if s0.last
+        r0 = instantiate_node(Identifier,input, i0...index, s0)
+        r0.extend(Identifier0)
+      else
+        @index = i0
+        r0 = nil
+      end
+
+      node_cache[:identifier][start_index] = r0
+
+      r0
     end
-    if s1.last
-      r1 = instantiate_node(Label,input, i1...index, s1)
-      r1.extend(Label0)
-    else
-      @index = i1
-      r1 = nil
+
+    module Label0
     end
-    if r1
-      r0 = r1
-    else
-      i7, s7 = index, []
-      if has_terminal?('$', false, index)
-        r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
-        @index += 1
-      else
-        terminal_parse_failure('$')
-        r8 = nil
+
+    module Label1
+    end
+
+    def _nt_label
+      start_index = index
+      if node_cache[:label].has_key?(index)
+        cached = node_cache[:label][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
       end
-      s7 << r8
-      if r8
-        s9, i9 = [], index
-        loop do
-          if has_terminal?('\G[A-Za-z]', true, index)
-            r10 = true
-            @index += 1
-          else
-            r10 = nil
-          end
-          if r10
-            s9 << r10
-          else
-            break
-          end
+
+      i0 = index
+      i1, s1 = index, []
+      s2, i2 = [], index
+      loop do
+        if has_terminal?('\G[A-Za-z]', true, index)
+          r3 = true
+          @index += 1
+        else
+          r3 = nil
         end
-        if s9.empty?
-          @index = i9
-          r9 = nil
+        if r3
+          s2 << r3
         else
-          r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
+          break
         end
-        s7 << r9
-        if r9
-          if has_terminal?('$', false, index)
-            r11 = instantiate_node(SyntaxNode,input, index...(index + 1))
-            @index += 1
-          else
-            terminal_parse_failure('$')
-            r11 = nil
-          end
-          s7 << r11
-          if r11
-            if has_terminal?('\G[1-9]', true, index)
-              r12 = true
+      end
+      if s2.empty?
+        @index = i2
+        r2 = nil
+      else
+        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      end
+      s1 << r2
+      if r2
+        if has_terminal?('\G[1-9]', true, index)
+          r4 = true
+          @index += 1
+        else
+          r4 = nil
+        end
+        s1 << r4
+        if r4
+          s5, i5 = [], index
+          loop do
+            if has_terminal?('\G[0-9]', true, index)
+              r6 = true
               @index += 1
             else
-              r12 = nil
+              r6 = nil
             end
-            s7 << r12
-            if r12
-              s13, i13 = [], index
-              loop do
-                if has_terminal?('\G[0-9]', true, index)
-                  r14 = true
-                  @index += 1
-                else
-                  r14 = nil
-                end
-                if r14
-                  s13 << r14
-                else
-                  break
-                end
-              end
-              r13 = instantiate_node(SyntaxNode,input, i13...index, s13)
-              s7 << r13
+            if r6
+              s5 << r6
+            else
+              break
             end
           end
+          r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
+          s1 << r5
         end
       end
-      if s7.last
-        r7 = instantiate_node(Label,input, i7...index, s7)
-        r7.extend(Label1)
+      if s1.last
+        r1 = instantiate_node(Label,input, i1...index, s1)
+        r1.extend(Label0)
       else
-        @index = i7
-        r7 = nil
+        @index = i1
+        r1 = nil
       end
-      if r7
-        r0 = r7
+      if r1
+        r0 = r1
       else
-        @index = i0
-        r0 = nil
-      end
-    end
-
-    node_cache[:label][start_index] = r0
-
-    r0
-  end
-
-  module String0
-  end
-
-  module String1
-  end
-
-  module String2
-  end
-
-  def _nt_string
-    start_index = index
-    if node_cache[:string].has_key?(index)
-      cached = node_cache[:string][index]
-      if cached
-        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
-      end
-      return cached
-    end
-
-    i0 = index
-    i1, s1 = index, []
-    if has_terminal?('"', false, index)
-      r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
-      @index += 1
-    else
-      terminal_parse_failure('"')
-      r2 = nil
-    end
-    s1 << r2
-    if r2
-      s3, i3 = [], index
-      loop do
-        i4 = index
-        if has_terminal?('\"', false, index)
-          r5 = instantiate_node(SyntaxNode,input, index...(index + 2))
-          @index += 2
+        i7, s7 = index, []
+        if has_terminal?('$', false, index)
+          r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
         else
-          terminal_parse_failure('\"')
-          r5 = nil
+          terminal_parse_failure('$')
+          r8 = nil
         end
-        if r5
-          r4 = r5
-        else
-          i6, s6 = index, []
-          i7 = index
-          if has_terminal?('"', false, index)
-            r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
-            @index += 1
-          else
-            terminal_parse_failure('"')
-            r8 = nil
-          end
-          if r8
-            r7 = nil
-          else
-            @index = i7
-            r7 = instantiate_node(SyntaxNode,input, index...index)
-          end
-          s6 << r7
-          if r7
-            if index < input_length
-              r9 = instantiate_node(SyntaxNode,input, index...(index + 1))
+        s7 << r8
+        if r8
+          s9, i9 = [], index
+          loop do
+            if has_terminal?('\G[A-Za-z]', true, index)
+              r10 = true
               @index += 1
             else
-              terminal_parse_failure("any character")
-              r9 = nil
+              r10 = nil
+            end
+            if r10
+              s9 << r10
+            else
+              break
             end
-            s6 << r9
           end
-          if s6.last
-            r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
-            r6.extend(String0)
+          if s9.empty?
+            @index = i9
+            r9 = nil
           else
-            @index = i6
-            r6 = nil
+            r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
           end
-          if r6
-            r4 = r6
-          else
-            @index = i4
-            r4 = nil
+          s7 << r9
+          if r9
+            if has_terminal?('$', false, index)
+              r11 = instantiate_node(SyntaxNode,input, index...(index + 1))
+              @index += 1
+            else
+              terminal_parse_failure('$')
+              r11 = nil
+            end
+            s7 << r11
+            if r11
+              if has_terminal?('\G[1-9]', true, index)
+                r12 = true
+                @index += 1
+              else
+                r12 = nil
+              end
+              s7 << r12
+              if r12
+                s13, i13 = [], index
+                loop do
+                  if has_terminal?('\G[0-9]', true, index)
+                    r14 = true
+                    @index += 1
+                  else
+                    r14 = nil
+                  end
+                  if r14
+                    s13 << r14
+                  else
+                    break
+                  end
+                end
+                r13 = instantiate_node(SyntaxNode,input, i13...index, s13)
+                s7 << r13
+              end
+            end
           end
         end
-        if r4
-          s3 << r4
+        if s7.last
+          r7 = instantiate_node(Label,input, i7...index, s7)
+          r7.extend(Label1)
         else
-          break
+          @index = i7
+          r7 = nil
         end
-      end
-      r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
-      s1 << r3
-      if r3
-        if has_terminal?('"', false, index)
-          r10 = instantiate_node(SyntaxNode,input, index...(index + 1))
-          @index += 1
+        if r7
+          r0 = r7
         else
-          terminal_parse_failure('"')
-          r10 = nil
+          @index = i0
+          r0 = nil
         end
-        s1 << r10
       end
+
+      node_cache[:label][start_index] = r0
+
+      r0
     end
-    if s1.last
-      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
-      r1.extend(String1)
-    else
-      @index = i1
-      r1 = nil
+
+    module String0
+    end
+
+    module String1
+    end
+
+    module String2
     end
-    if r1
-      r0 = r1
-    else
-      i11, s11 = index, []
-      if has_terminal?("'", false, index)
-        r12 = instantiate_node(SyntaxNode,input, index...(index + 1))
+
+    def _nt_string
+      start_index = index
+      if node_cache[:string].has_key?(index)
+        cached = node_cache[:string][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
+      end
+
+      i0 = index
+      i1, s1 = index, []
+      if has_terminal?('"', false, index)
+        r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
         @index += 1
       else
-        terminal_parse_failure("'")
-        r12 = nil
+        terminal_parse_failure('"')
+        r2 = nil
       end
-      s11 << r12
-      if r12
-        s13, i13 = [], index
+      s1 << r2
+      if r2
+        s3, i3 = [], index
         loop do
-          if has_terminal?('\G[^\']', true, index)
-            r14 = true
-            @index += 1
+          i4 = index
+          if has_terminal?('\"', false, index)
+            r5 = instantiate_node(SyntaxNode,input, index...(index + 2))
+            @index += 2
+          else
+            terminal_parse_failure('\"')
+            r5 = nil
+          end
+          if r5
+            r4 = r5
           else
-            r14 = nil
+            i6, s6 = index, []
+            i7 = index
+            if has_terminal?('"', false, index)
+              r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
+              @index += 1
+            else
+              terminal_parse_failure('"')
+              r8 = nil
+            end
+            if r8
+              r7 = nil
+            else
+              @index = i7
+              r7 = instantiate_node(SyntaxNode,input, index...index)
+            end
+            s6 << r7
+            if r7
+              if index < input_length
+                r9 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                @index += 1
+              else
+                terminal_parse_failure("any character")
+                r9 = nil
+              end
+              s6 << r9
+            end
+            if s6.last
+              r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
+              r6.extend(String0)
+            else
+              @index = i6
+              r6 = nil
+            end
+            if r6
+              r4 = r6
+            else
+              @index = i4
+              r4 = nil
+            end
           end
-          if r14
-            s13 << r14
+          if r4
+            s3 << r4
           else
             break
           end
         end
-        r13 = instantiate_node(SyntaxNode,input, i13...index, s13)
-        s11 << r13
-        if r13
-          if has_terminal?("'", false, index)
-            r15 = instantiate_node(SyntaxNode,input, index...(index + 1))
+        r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
+        s1 << r3
+        if r3
+          if has_terminal?('"', false, index)
+            r10 = instantiate_node(SyntaxNode,input, index...(index + 1))
             @index += 1
           else
-            terminal_parse_failure("'")
-            r15 = nil
+            terminal_parse_failure('"')
+            r10 = nil
           end
-          s11 << r15
+          s1 << r10
         end
       end
-      if s11.last
-        r11 = instantiate_node(SyntaxNode,input, i11...index, s11)
-        r11.extend(String2)
+      if s1.last
+        r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+        r1.extend(String1)
       else
-        @index = i11
-        r11 = nil
+        @index = i1
+        r1 = nil
       end
-      if r11
-        r0 = r11
+      if r1
+        r0 = r1
       else
-        @index = i0
-        r0 = nil
+        i11, s11 = index, []
+        if has_terminal?("'", false, index)
+          r12 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
+        else
+          terminal_parse_failure("'")
+          r12 = nil
+        end
+        s11 << r12
+        if r12
+          s13, i13 = [], index
+          loop do
+            if has_terminal?('\G[^\']', true, index)
+              r14 = true
+              @index += 1
+            else
+              r14 = nil
+            end
+            if r14
+              s13 << r14
+            else
+              break
+            end
+          end
+          r13 = instantiate_node(SyntaxNode,input, i13...index, s13)
+          s11 << r13
+          if r13
+            if has_terminal?("'", false, index)
+              r15 = instantiate_node(SyntaxNode,input, index...(index + 1))
+              @index += 1
+            else
+              terminal_parse_failure("'")
+              r15 = nil
+            end
+            s11 << r15
+          end
+        end
+        if s11.last
+          r11 = instantiate_node(SyntaxNode,input, i11...index, s11)
+          r11.extend(String2)
+        else
+          @index = i11
+          r11 = nil
+        end
+        if r11
+          r0 = r11
+        else
+          @index = i0
+          r0 = nil
+        end
       end
-    end
 
-    node_cache[:string][start_index] = r0
+      node_cache[:string][start_index] = r0
 
-    r0
-  end
-
-  module Range0
-    def label1
-      elements[0]
+      r0
     end
 
-    def label2
-      elements[2]
-    end
-  end
+    module Range0
+      def label1
+        elements[0]
+      end
 
-  def _nt_range
-    start_index = index
-    if node_cache[:range].has_key?(index)
-      cached = node_cache[:range][index]
-      if cached
-        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
+      def label2
+        elements[2]
       end
-      return cached
     end
 
-    i0, s0 = index, []
-    r1 = _nt_label
-    s0 << r1
-    if r1
-      if has_terminal?(':', false, index)
-        r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
-        @index += 1
-      else
-        terminal_parse_failure(':')
-        r2 = nil
+    def _nt_range
+      start_index = index
+      if node_cache[:range].has_key?(index)
+        cached = node_cache[:range][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
       end
-      s0 << r2
-      if r2
-        r3 = _nt_label
-        s0 << r3
+
+      i0, s0 = index, []
+      r1 = _nt_label
+      s0 << r1
+      if r1
+        if has_terminal?(':', false, index)
+          r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
+          @index += 1
+        else
+          terminal_parse_failure(':')
+          r2 = nil
+        end
+        s0 << r2
+        if r2
+          r3 = _nt_label
+          s0 << r3
+        end
+      end
+      if s0.last
+        r0 = instantiate_node(Range,input, i0...index, s0)
+        r0.extend(Range0)
+      else
+        @index = i0
+        r0 = nil
       end
-    end
-    if s0.last
-      r0 = instantiate_node(Range,input, i0...index, s0)
-      r0.extend(Range0)
-    else
-      @index = i0
-      r0 = nil
-    end
 
-    node_cache[:range][start_index] = r0
+      node_cache[:range][start_index] = r0
 
-    r0
-  end
+      r0
+    end
 
-  def _nt_space
-    start_index = index
-    if node_cache[:space].has_key?(index)
-      cached = node_cache[:space][index]
-      if cached
-        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-        @index = cached.interval.end
+    def _nt_space
+      start_index = index
+      if node_cache[:space].has_key?(index)
+        cached = node_cache[:space][index]
+        if cached
+          cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+          @index = cached.interval.end
+        end
+        return cached
       end
-      return cached
-    end
 
-    s0, i0 = [], index
-    loop do
-      if has_terminal?('\G[\\s]', true, index)
-        r1 = true
-        @index += 1
-      else
-        r1 = nil
+      s0, i0 = [], index
+      loop do
+        if has_terminal?('\G[\\s]', true, index)
+          r1 = true
+          @index += 1
+        else
+          r1 = nil
+        end
+        if r1
+          s0 << r1
+        else
+          break
+        end
       end
-      if r1
-        s0 << r1
+      if s0.empty?
+        @index = i0
+        r0 = nil
       else
-        break
+        r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
       end
-    end
-    if s0.empty?
-      @index = i0
-      r0 = nil
-    else
-      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
-    end
 
-    node_cache[:space][start_index] = r0
+      node_cache[:space][start_index] = r0
+
+      r0
+    end
 
-    r0
   end
 
-end
+  class ExcelParser < Treetop::Runtime::CompiledParser
+    include Excel
+  end
 
-class SorobanParser < Treetop::Runtime::CompiledParser
-  include Soroban
 end
-