module Soroban

Autogenerated from a Treetop grammar. Edits may be lost.

Public Class Methods

boolean?(data) click to toggle source

Return true if the supplied data is a boolean.

# File lib/soroban/helpers.rb, line 16
def self.boolean?(data)
  /^(true|false)$/i.match(data.to_s) && true || false
end
call(sheet, name, *args) click to toggle source

Call the named function within the context of the specified sheet.

# File lib/soroban/functions.rb, line 15
def self.call(sheet, name, *args)
  function = name.upcase.to_sym
  raise Soroban::UndefinedError, "No such function '#{function}'" unless @@functions[function]
  sheet.instance_exec(*args, &@@functions[function])
end
define(function_hash) click to toggle source

Define a new function.

# File lib/soroban/functions.rb, line 4
def self.define(function_hash)
  @@functions ||= {}
  function_hash.each { |name, callback| @@functions[name] = callback }
end
formula?(data) click to toggle source

Return true if the supplied data represents a formula.

# File lib/soroban/helpers.rb, line 6
def self.formula?(data)
  data.to_s.slice(0..0) == '='
end
functions() click to toggle source

Return an array of all defined functions.

# File lib/soroban/functions.rb, line 10
def self.functions
  @@functions.keys.map { |f| f.to_s }
end
getRange(range) click to toggle source

Return the components of a range.

# File lib/soroban/helpers.rb, line 36
def self.getRange(range)
  /^([a-zA-Z]+)([\d]+):([a-zA-Z]+)([\d]+)$/.match(range.to_s).to_a[1..-1]
end
getValues(binding, *args) click to toggle source

Return an array of values for the supplied arguments (which may be numbers, labels and ranges).

# File lib/soroban/helpers.rb, line 41
def self.getValues(binding, *args)
  args.map { |arg| Soroban::range?(arg) ? Walker.new(arg, binding).map : arg }.flatten
end
number?(data) click to toggle source

Return true if the supplied data is a number.

# File lib/soroban/helpers.rb, line 11
def self.number?(data)
  Float(data.to_s) && true rescue false
end
parser() click to toggle source

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.

# File lib/soroban/parser.rb, line 11
def self.parser
  @@parser ||= SorobanParser.new
end
range?(data) click to toggle source

Return true if the supplied data is a range.

# File lib/soroban/helpers.rb, line 26
def self.range?(data)
  /^([a-zA-Z]+)([\d]+):([a-zA-Z]+)([\d]+)$/.match(data.to_s) && true || false
end
string?(data) click to toggle source

Return true if the supplied data is a string.

# File lib/soroban/helpers.rb, line 21
def self.string?(data)
  /^["](\"|[^"])*["]$/.match(data.to_s) && true || /^['][^']*[']$/.match(data.to_s) && true || false
end
unknown?(data) click to toggle source

Return true if the supplied data is of no recognised format.

# File lib/soroban/helpers.rb, line 31
def self.unknown?(data)
  !self.formula?(data) && !self.number?(data) && !self.boolean?(data) && !self.string?(data)
end

Public Instance Methods

_nt_additive_operator() click to toggle source
# File lib/soroban/parser/grammar.rb, line 680
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
_nt_and() click to toggle source
# File lib/soroban/parser/grammar.rb, line 188
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
_nt_arguments() click to toggle source
# File lib/soroban/parser/grammar.rb, line 1111
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
_nt_boolean() click to toggle source
# File lib/soroban/parser/grammar.rb, line 354
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
_nt_comparator() click to toggle source
# File lib/soroban/parser/grammar.rb, line 506
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
_nt_comparison() click to toggle source
# File lib/soroban/parser/grammar.rb, line 435
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
_nt_expression() click to toggle source
# File lib/soroban/parser/grammar.rb, line 609
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
_nt_float() click to toggle source
# File lib/soroban/parser/grammar.rb, line 1221
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
_nt_formula() click to toggle source
# File lib/soroban/parser/grammar.rb, line 17
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
_nt_function() click to toggle source
# File lib/soroban/parser/grammar.rb, line 1005
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
_nt_identifier() click to toggle source
# File lib/soroban/parser/grammar.rb, line 1335
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
_nt_integer() click to toggle source
# File lib/soroban/parser/grammar.rb, line 1295
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
_nt_label() click to toggle source
# File lib/soroban/parser/grammar.rb, line 1391
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
_nt_logical() click to toggle source
# File lib/soroban/parser/grammar.rb, line 98
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
_nt_multiplicative() click to toggle source
# File lib/soroban/parser/grammar.rb, line 739
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
_nt_multiplicative_operator() click to toggle source
# File lib/soroban/parser/grammar.rb, line 810
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
_nt_number() click to toggle source
# File lib/soroban/parser/grammar.rb, line 1188
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
_nt_range() click to toggle source
# File lib/soroban/parser/grammar.rb, line 1731
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
_nt_space() click to toggle source
# File lib/soroban/parser/grammar.rb, line 1772
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
_nt_string() click to toggle source
# File lib/soroban/parser/grammar.rb, line 1560
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
_nt_truthval() click to toggle source
# File lib/soroban/parser/grammar.rb, line 272
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
_nt_value() click to toggle source
# File lib/soroban/parser/grammar.rb, line 876
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
root() click to toggle source
# File lib/soroban/parser/grammar.rb, line 7
def root
  @root ||= :formula
end