soroban 0.1.0

data/lib/soroban/functions/and.rb

@@ -0,0 +1,4 @@
+# Logical and of supplied arguments, which may be booleans, labels or ranges.
+Soroban::define :AND => lambda { |*args|
+  Soroban::getValues(binding, *args).reduce(true) { |s, a| s && a }
+}

data/lib/soroban/functions/average.rb

@@ -0,0 +1,5 @@
+# Average the arguments, which may be numbers, labels or ranges.
+Soroban::define :AVERAGE => lambda { |*args|
+  values = Soroban::getValues(binding, *args)
+  values.reduce(:+) / values.length.to_f
+}

data/lib/soroban/functions/if.rb

@@ -0,0 +1,4 @@
+# Return one of two values depending on the value of the supplied boolean.
+Soroban::define :IF => lambda { |val, if_true, if_false|
+  val ? if_true : if_false
+}

data/lib/soroban/functions/max.rb

@@ -0,0 +1,4 @@
+# Return the maximum of the supplied values, which may be numbers, labels or ranges.
+Soroban::define :MAX => lambda { |*args|
+  Soroban::getValues(binding, *args).max
+}

data/lib/soroban/functions/min.rb

@@ -0,0 +1,4 @@
+# Return the minimum of the supplied values, which may be numbers, labels or ranges.
+Soroban::define :MIN => lambda { |*args|
+  Soroban::getValues(binding, *args).min
+}

data/lib/soroban/functions/not.rb

@@ -0,0 +1,4 @@
+# Return the logical not of the supplied boolean.
+Soroban::define :NOT => lambda { |val|
+  !val
+}

data/lib/soroban/functions/or.rb

@@ -0,0 +1,4 @@
+# Logical or of supplied arguments, which may be booleans, labels or ranges.
+Soroban::define :OR => lambda { |*args|
+  Soroban::getValues(binding, *args).reduce(false) { |s, a| s || a }
+}

data/lib/soroban/functions/sum.rb

@@ -0,0 +1,4 @@
+# Sum the arguments, which may be numbers, labels or ranges.
+Soroban::define :SUM => lambda { |*args|
+  Soroban::getValues(binding, *args).reduce(:+)
+}

data/lib/soroban/functions/vlookup.rb

@@ -0,0 +1,10 @@
+# Return a value from the supplied range by searching the first column for the
+# supplied value, and then reading the result from the matching row.
+Soroban::define :VLOOKUP => lambda { |value, range, col, inexact|
+  fc, fr, tc, tr = Soroban::getRange(range)
+  i = walk("#{fc}#{fr}:#{fc}#{tr}").find_index(value)
+  return nil if i.nil?
+  (0...i).each { fr.next! }
+  (1...col).each { fc.next! }
+  eval("@#{fc}#{fr}.get")
+}

data/lib/soroban/helpers.rb

@@ -0,0 +1,45 @@
+require 'soroban/parser'
+
+module Soroban
+
+  # Return true if the supplied data represents a formula.
+  def self.formula?(data)
+    data.to_s.slice(0..0) == '='
+  end
+
+  # Return true if the supplied data is a number.
+  def self.number?(data)
+    Float(data.to_s) && true rescue false
+  end
+
+  # Return true if the supplied data is a boolean.
+  def self.boolean?(data)
+    /^(true|false)$/i.match(data.to_s) && true || false
+  end
+
+  # Return true if the supplied data is a string.
+  def self.string?(data)
+    /^["](\"|[^"])*["]$/.match(data.to_s) && true || /^['][^']*[']$/.match(data.to_s) && true || false
+  end
+
+  # Return true if the supplied data is a range.
+  def self.range?(data)
+    /^([a-zA-Z]+)([\d]+):([a-zA-Z]+)([\d]+)$/.match(data.to_s) && true || false
+  end
+
+  # Return true if the supplied data is of no recognised format.
+  def self.unknown?(data)
+    !self.formula?(data) && !self.number?(data) && !self.boolean?(data) && !self.string?(data)
+  end
+
+  # Return the components of a range.
+  def self.getRange(range)
+    /^([a-zA-Z]+)([\d]+):([a-zA-Z]+)([\d]+)$/.match(range.to_s).to_a[1..-1]
+  end
+
+  # Return an array of values for the supplied arguments (which may be numbers, labels and ranges).
+  def self.getValues(binding, *args)
+    args.map { |arg| Soroban::range?(arg) ? Walker.new(arg, binding).map : arg }.flatten
+  end
+
+end

data/lib/soroban/parser.rb

@@ -0,0 +1,15 @@
+require 'treetop'
+
+require 'soroban/parser/rewrite'
+require 'soroban/parser/nodes'
+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
+  end
+
+end

data/lib/soroban/parser/grammar.rb

@@ -0,0 +1,1814 @@
+# Autogenerated from a Treetop grammar. Edits may be lost.
+
+
+module Soroban
+  include Treetop::Runtime
+
+  def root
+    @root ||= :formula
+  end
+
+  module Formula0
+    def logical
+      elements[2]
+    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
+      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
+      else
+        r3 = instantiate_node(SyntaxNode,input, index...index)
+      end
+      s1 << r3
+      if r3
+        r5 = _nt_logical
+        s1 << r5
+      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
+      else
+        r7 = _nt_number
+        if r7
+          r0 = r7
+        else
+          r8 = _nt_boolean
+          if r8
+            r0 = r8
+          else
+            @index = i0
+            r0 = nil
+          end
+        end
+      end
+    end
+
+    node_cache[:formula][start_index] = r0
+
+    r0
+  end
+
+  module Logical0
+    def and
+      elements[3]
+    end
+  end
+
+  module Logical1
+    def and
+      elements[0]
+    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
+      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)
+        end
+        s3 << r4
+        if r4
+          if has_terminal?('or', false, index)
+            r6 = instantiate_node(SyntaxNode,input, index...(index + 2))
+            @index += 2
+          else
+            terminal_parse_failure('or')
+            r6 = nil
+          end
+          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
+      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
+
+  module And0
+    def truthval
+      elements[3]
+    end
+  end
+
+  module And1
+    def truthval
+      elements[0]
+    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
+      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)
+        end
+        s3 << r4
+        if r4
+          if has_terminal?('and', false, index)
+            r6 = instantiate_node(SyntaxNode,input, index...(index + 3))
+            @index += 3
+          else
+            terminal_parse_failure('and')
+            r6 = nil
+          end
+          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
+      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
+
+  module Truthval0
+    def logical
+      elements[2]
+    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
+      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
+      else
+        terminal_parse_failure('(')
+        r3 = nil
+      end
+      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
+              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
+          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
+        else
+          @index = i0
+          r0 = nil
+        end
+      end
+    end
+
+    node_cache[:truthval][start_index] = r0
+
+    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
+      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
+      else
+        terminal_parse_failure('false')
+        r2 = nil
+      end
+      if r2
+        r0 = r2
+      else
+        if has_terminal?('TRUE', false, index)
+          r3 = instantiate_node(SyntaxNode,input, index...(index + 4))
+          @index += 4
+        else
+          terminal_parse_failure('TRUE')
+          r3 = nil
+        end
+        if r3
+          r0 = r3
+        else
+          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
+
+    node_cache[:boolean][start_index] = r0
+
+    r0
+  end
+
+  module Comparison0
+    def comparator
+      elements[1]
+    end
+
+    def expression
+      elements[3]
+    end
+  end
+
+  module Comparison1
+    def expression
+      elements[0]
+    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
+      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)
+        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
+      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
+
+    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
+      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
+      else
+        terminal_parse_failure('<>')
+        r2 = nil
+      end
+      if r2
+        r0 = r2
+      else
+        if has_terminal?('>=', false, index)
+          r3 = instantiate_node(SyntaxNode,input, index...(index + 2))
+          @index += 2
+        else
+          terminal_parse_failure('>=')
+          r3 = nil
+        end
+        if r3
+          r0 = r3
+        else
+          if has_terminal?('<=', false, index)
+            r4 = instantiate_node(SyntaxNode,input, index...(index + 2))
+            @index += 2
+          else
+            terminal_parse_failure('<=')
+            r4 = nil
+          end
+          if r4
+            r0 = r4
+          else
+            if has_terminal?('>', false, index)
+              r5 = instantiate_node(SyntaxNode,input, index...(index + 1))
+              @index += 1
+            else
+              terminal_parse_failure('>')
+              r5 = nil
+            end
+            if r5
+              r0 = r5
+            else
+              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
+
+    node_cache[:comparator][start_index] = r0
+
+    r0
+  end
+
+  module Expression0
+    def additive_operator
+      elements[1]
+    end
+
+    def multiplicative
+      elements[3]
+    end
+  end
+
+  module Expression1
+    def multiplicative
+      elements[0]
+    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
+      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)
+        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
+      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
+
+    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
+      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))
+        @index += 1
+      else
+        terminal_parse_failure('-')
+        r2 = nil
+      end
+      if r2
+        r0 = r2
+      else
+        @index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:additive_operator][start_index] = r0
+
+    r0
+  end
+
+  module Multiplicative0
+    def multiplicative_operator
+      elements[1]
+    end
+
+    def value
+      elements[3]
+    end
+  end
+
+  module Multiplicative1
+    def value
+      elements[0]
+    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
+      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)
+        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
+      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
+
+    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
+      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))
+        @index += 1
+      else
+        terminal_parse_failure('*')
+        r2 = nil
+      end
+      if r2
+        r0 = r2
+      else
+        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
+
+    node_cache[:multiplicative_operator][start_index] = r0
+
+    r0
+  end
+
+  module Value0
+    def expression
+      elements[2]
+    end
+
+  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
+      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
+      else
+        terminal_parse_failure('(')
+        r3 = nil
+      end
+      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
+              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
+          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
+        else
+          r11 = _nt_number
+          if r11
+            r0 = r11
+          else
+            r12 = _nt_boolean
+            if r12
+              r0 = r12
+            else
+              r13 = _nt_identifier
+              if r13
+                r0 = r13
+              else
+                r14 = _nt_string
+                if r14
+                  r0 = r14
+                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
+                  else
+                    @index = i0
+                    r0 = nil
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    node_cache[:value][start_index] = r0
+
+    r0
+  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
+      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
+      end
+      if r2
+        s1 << r2
+      else
+        break
+      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
+        else
+          r4 = instantiate_node(SyntaxNode,input, index...index)
+        end
+        s0 << r4
+        if r4
+          r7 = _nt_arguments
+          if r7
+            r6 = r7
+          else
+            r6 = instantiate_node(SyntaxNode,input, index...index)
+          end
+          s0 << r6
+          if r6
+            r9 = _nt_space
+            if r9
+              r8 = r9
+            else
+              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
+          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
+
+    r0
+  end
+
+  module Arguments0
+    def logical
+      elements[3]
+    end
+  end
+
+  module Arguments1
+    def logical
+      elements[0]
+    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
+      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)
+        end
+        s3 << r4
+        if r4
+          if has_terminal?(',', false, index)
+            r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
+            @index += 1
+          else
+            terminal_parse_failure(',')
+            r6 = nil
+          end
+          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
+      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
+
+  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
+      return cached
+    end
+
+    i0 = index
+    r1 = _nt_float
+    if r1
+      r0 = r1
+    else
+      r2 = _nt_integer
+      if r2
+        r0 = r2
+      else
+        @index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:number][start_index] = r0
+
+    r0
+  end
+
+  module Float0
+  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
+    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
+      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
+      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 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(SyntaxNode,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
+      else
+        r1 = nil
+      end
+      if r1
+        s0 << r1
+      else
+        break
+      end
+    end
+    if s0.empty?
+      @index = i0
+      r0 = nil
+    else
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+    end
+
+    node_cache[:integer][start_index] = r0
+
+    r0
+  end
+
+  module Identifier0
+  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
+      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
+      loop do
+        if has_terminal?('\G[a-zA-Z0-9]', true, index)
+          r3 = true
+          @index += 1
+        else
+          r3 = nil
+        end
+        if r3
+          s2 << r3
+        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
+
+  module Label0
+  end
+
+  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
+
+    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
+      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
+        @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
+            r6 = nil
+          end
+          if r6
+            s5 << r6
+          else
+            break
+          end
+        end
+        r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
+        s1 << r5
+      end
+    end
+    if s1.last
+      r1 = instantiate_node(Label,input, i1...index, s1)
+      r1.extend(Label0)
+    else
+      @index = i1
+      r1 = nil
+    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
+      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
+        end
+        if s9.empty?
+          @index = i9
+          r9 = nil
+        else
+          r9 = instantiate_node(SyntaxNode,input, i9...index, s9)
+        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
+              @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 s7.last
+        r7 = instantiate_node(Label,input, i7...index, s7)
+        r7.extend(Label1)
+      else
+        @index = i7
+        r7 = nil
+      end
+      if r7
+        r0 = r7
+      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
+        else
+          terminal_parse_failure('\"')
+          r5 = 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))
+              @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 r4
+          s3 << r4
+        else
+          break
+        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
+        else
+          terminal_parse_failure('"')
+          r10 = nil
+        end
+        s1 << r10
+      end
+    end
+    if s1.last
+      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+      r1.extend(String1)
+    else
+      @index = i1
+      r1 = nil
+    end
+    if r1
+      r0 = r1
+    else
+      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
+
+    node_cache[:string][start_index] = r0
+
+    r0
+  end
+
+  module Range0
+    def label1
+      elements[0]
+    end
+
+    def label2
+      elements[2]
+    end
+  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
+      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
+      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
+
+    node_cache[:range][start_index] = r0
+
+    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
+      end
+      return cached
+    end
+
+    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 s0.empty?
+      @index = i0
+      r0 = nil
+    else
+      r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+    end
+
+    node_cache[:space][start_index] = r0
+
+    r0
+  end
+
+end
+
+class SorobanParser < Treetop::Runtime::CompiledParser
+  include Soroban
+end
+