module Soroban::Excel

Public Instance Methods

_nt_additive_operator() click to toggle source
# File lib/soroban/parser/grammar.rb, line 699
def _nt_additive_operator
  start_index = index
  if node_cache[:additive_operator].has_key?(index)
    cached = node_cache[:additive_operator][index]
    if cached
      node_cache[:additive_operator][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  if (match_len = has_terminal?('+', false, index))
    r1 = true
    @index += match_len
  else
    terminal_parse_failure('+')
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    if (match_len = has_terminal?('-', false, index))
      r2 = true
      @index += match_len
    else
      terminal_parse_failure('-')
      r2 = nil
    end
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      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 194
def _nt_and
  start_index = index
  if node_cache[:and].has_key?(index)
    cached = node_cache[:and][index]
    if cached
      node_cache[:and][index] = 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 (match_len = has_terminal?('and', false, index))
          r6 = instantiate_node(SyntaxNode,input, index...(index + match_len))
          @index += match_len
        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 1144
def _nt_arguments
  start_index = index
  if node_cache[:arguments].has_key?(index)
    cached = node_cache[:arguments][index]
    if cached
      node_cache[:arguments][index] = 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 (match_len = has_terminal?(',', false, index))
          r6 = true
          @index += match_len
        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 363
def _nt_boolean
  start_index = index
  if node_cache[:boolean].has_key?(index)
    cached = node_cache[:boolean][index]
    if cached
      node_cache[:boolean][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  if (match_len = has_terminal?('true', false, index))
    r1 = instantiate_node(SyntaxNode,input, index...(index + match_len))
    @index += match_len
  else
    terminal_parse_failure('true')
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    if (match_len = has_terminal?('false', false, index))
      r2 = instantiate_node(SyntaxNode,input, index...(index + match_len))
      @index += match_len
    else
      terminal_parse_failure('false')
      r2 = nil
    end
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      if (match_len = has_terminal?('TRUE', false, index))
        r3 = instantiate_node(SyntaxNode,input, index...(index + match_len))
        @index += match_len
      else
        terminal_parse_failure('TRUE')
        r3 = nil
      end
      if r3
        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
        r0 = r3
      else
        if (match_len = has_terminal?('FALSE', false, index))
          r4 = instantiate_node(SyntaxNode,input, index...(index + match_len))
          @index += match_len
        else
          terminal_parse_failure('FALSE')
          r4 = nil
        end
        if r4
          r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
          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 519
def _nt_comparator
  start_index = index
  if node_cache[:comparator].has_key?(index)
    cached = node_cache[:comparator][index]
    if cached
      node_cache[:comparator][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  if (match_len = has_terminal?('=', false, index))
    r1 = instantiate_node(Equal,input, index...(index + match_len))
    @index += match_len
  else
    terminal_parse_failure('=')
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    if (match_len = has_terminal?('<>', false, index))
      r2 = instantiate_node(NotEqual,input, index...(index + match_len))
      @index += match_len
    else
      terminal_parse_failure('<>')
      r2 = nil
    end
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      if (match_len = has_terminal?('>=', false, index))
        r3 = instantiate_node(SyntaxNode,input, index...(index + match_len))
        @index += match_len
      else
        terminal_parse_failure('>=')
        r3 = nil
      end
      if r3
        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
        r0 = r3
      else
        if (match_len = has_terminal?('<=', false, index))
          r4 = instantiate_node(SyntaxNode,input, index...(index + match_len))
          @index += match_len
        else
          terminal_parse_failure('<=')
          r4 = nil
        end
        if r4
          r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
          r0 = r4
        else
          if (match_len = has_terminal?('>', false, index))
            r5 = true
            @index += match_len
          else
            terminal_parse_failure('>')
            r5 = nil
          end
          if r5
            r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
            r0 = r5
          else
            if (match_len = has_terminal?('<', false, index))
              r6 = true
              @index += match_len
            else
              terminal_parse_failure('<')
              r6 = nil
            end
            if r6
              r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
              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 448
def _nt_comparison
  start_index = index
  if node_cache[:comparison].has_key?(index)
    cached = node_cache[:comparison][index]
    if cached
      node_cache[:comparison][index] = 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 628
def _nt_expression
  start_index = index
  if node_cache[:expression].has_key?(index)
    cached = node_cache[:expression][index]
    if cached
      node_cache[:expression][index] = 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 1457
def _nt_float
  start_index = index
  if node_cache[:float].has_key?(index)
    cached = node_cache[:float][index]
    if cached
      node_cache[:float][index] = 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?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[0-9]')
      r2 = nil
    end
    if r2
      s1 << r2
    else
      break
    end
  end
  r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
  s0 << r1
  if r1
    if (match_len = has_terminal?('.', false, index))
      r3 = true
      @index += match_len
    else
      terminal_parse_failure('.')
      r3 = nil
    end
    s0 << r3
    if r3
      s4, i4 = [], index
      loop do
        if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
          r5 = true
          @index += 1
        else
          terminal_parse_failure('[0-9]')
          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(FloatValue,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 19
def _nt_formula
  start_index = index
  if node_cache[:formula].has_key?(index)
    cached = node_cache[:formula][index]
    if cached
      node_cache[:formula][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  i1, s1 = index, []
  if (match_len = has_terminal?('=', false, index))
    r2 = true
    @index += match_len
  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
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    r6 = _nt_string
    if r6
      r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
      r0 = r6
    else
      r7 = _nt_number
      if r7
        r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
        r0 = r7
      else
        r8 = _nt_boolean
        if r8
          r8 = SyntaxNode.new(input, (index-1)...index) if r8 == true
          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 1037
def _nt_function
  start_index = index
  if node_cache[:function].has_key?(index)
    cached = node_cache[:function][index]
    if cached
      node_cache[:function][index] = 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?(@regexps[gr = '\A[a-zA-Z]'] ||= Regexp.new(gr), :regexp, index)
      r2 = true
      @index += 1
    else
      terminal_parse_failure('[a-zA-Z]')
      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 (match_len = has_terminal?('(', false, index))
      r3 = true
      @index += match_len
    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 (match_len = has_terminal?(')', false, index))
              r10 = true
              @index += match_len
            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 1577
def _nt_identifier
  start_index = index
  if node_cache[:identifier].has_key?(index)
    cached = node_cache[:identifier][index]
    if cached
      node_cache[:identifier][index] = 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?(@regexps[gr = '\A[a-zA-Z]'] ||= Regexp.new(gr), :regexp, index)
    r2 = true
    @index += 1
  else
    terminal_parse_failure('[a-zA-Z]')
    r2 = nil
  end
  s1 << r2
  if r2
    s3, i3 = [], index
    loop do
      if has_terminal?(@regexps[gr = '\A[a-zA-Z0-9]'] ||= Regexp.new(gr), :regexp, index)
        r4 = true
        @index += 1
      else
        terminal_parse_failure('[a-zA-Z0-9]')
        r4 = nil
      end
      if r4
        s3 << r4
      else
        break
      end
    end
    r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
    s1 << r3
  end
  if s1.last
    r1 = instantiate_node(Identifier,input, i1...index, s1)
    r1.extend(Identifier0)
  else
    @index = i1
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    i5, s5 = index, []
    if (match_len = has_terminal?('$', false, index))
      r6 = true
      @index += match_len
    else
      terminal_parse_failure('$')
      r6 = nil
    end
    s5 << r6
    if r6
      s7, i7 = [], index
      loop do
        if has_terminal?(@regexps[gr = '\A[A-Za-z]'] ||= Regexp.new(gr), :regexp, index)
          r8 = true
          @index += 1
        else
          terminal_parse_failure('[A-Za-z]')
          r8 = nil
        end
        if r8
          s7 << r8
        else
          break
        end
      end
      if s7.empty?
        @index = i7
        r7 = nil
      else
        r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
      end
      s5 << r7
      if r7
        if (match_len = has_terminal?('$', false, index))
          r9 = true
          @index += match_len
        else
          terminal_parse_failure('$')
          r9 = nil
        end
        s5 << r9
        if r9
          if has_terminal?(@regexps[gr = '\A[1-9]'] ||= Regexp.new(gr), :regexp, index)
            r10 = true
            @index += 1
          else
            terminal_parse_failure('[1-9]')
            r10 = nil
          end
          s5 << r10
          if r10
            s11, i11 = [], index
            loop do
              if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
                r12 = true
                @index += 1
              else
                terminal_parse_failure('[0-9]')
                r12 = nil
              end
              if r12
                s11 << r12
              else
                break
              end
            end
            r11 = instantiate_node(SyntaxNode,input, i11...index, s11)
            s5 << r11
          end
        end
      end
    end
    if s5.last
      r5 = instantiate_node(Identifier,input, i5...index, s5)
      r5.extend(Identifier1)
    else
      @index = i5
      r5 = nil
    end
    if r5
      r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
      r0 = r5
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:identifier][start_index] = r0

  r0
end
_nt_integer() click to toggle source
# File lib/soroban/parser/grammar.rb, line 1533
def _nt_integer
  start_index = index
  if node_cache[:integer].has_key?(index)
    cached = node_cache[:integer][index]
    if cached
      node_cache[:integer][index] = 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?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
      r1 = true
      @index += 1
    else
      terminal_parse_failure('[0-9]')
      r1 = nil
    end
    if r1
      s0 << r1
    else
      break
    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
_nt_label() click to toggle source
# File lib/soroban/parser/grammar.rb, line 1727
def _nt_label
  start_index = index
  if node_cache[:label].has_key?(index)
    cached = node_cache[:label][index]
    if cached
      node_cache[:label][index] = 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?(@regexps[gr = '\A[A-Za-z]'] ||= Regexp.new(gr), :regexp, index)
      r3 = true
      @index += 1
    else
      terminal_parse_failure('[A-Za-z]')
      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?(@regexps[gr = '\A[1-9]'] ||= Regexp.new(gr), :regexp, index)
      r4 = true
      @index += 1
    else
      terminal_parse_failure('[1-9]')
      r4 = nil
    end
    s1 << r4
    if r4
      s5, i5 = [], index
      loop do
        if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
          r6 = true
          @index += 1
        else
          terminal_parse_failure('[0-9]')
          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
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    i7, s7 = index, []
    if (match_len = has_terminal?('$', false, index))
      r8 = true
      @index += match_len
    else
      terminal_parse_failure('$')
      r8 = nil
    end
    s7 << r8
    if r8
      s9, i9 = [], index
      loop do
        if has_terminal?(@regexps[gr = '\A[A-Za-z]'] ||= Regexp.new(gr), :regexp, index)
          r10 = true
          @index += 1
        else
          terminal_parse_failure('[A-Za-z]')
          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 (match_len = has_terminal?('$', false, index))
          r11 = true
          @index += match_len
        else
          terminal_parse_failure('$')
          r11 = nil
        end
        s7 << r11
        if r11
          if has_terminal?(@regexps[gr = '\A[1-9]'] ||= Regexp.new(gr), :regexp, index)
            r12 = true
            @index += 1
          else
            terminal_parse_failure('[1-9]')
            r12 = nil
          end
          s7 << r12
          if r12
            s13, i13 = [], index
            loop do
              if has_terminal?(@regexps[gr = '\A[0-9]'] ||= Regexp.new(gr), :regexp, index)
                r14 = true
                @index += 1
              else
                terminal_parse_failure('[0-9]')
                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
      r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
      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 104
def _nt_logical
  start_index = index
  if node_cache[:logical].has_key?(index)
    cached = node_cache[:logical][index]
    if cached
      node_cache[:logical][index] = 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 (match_len = has_terminal?('or', false, index))
          r6 = instantiate_node(SyntaxNode,input, index...(index + match_len))
          @index += match_len
        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 760
def _nt_multiplicative
  start_index = index
  if node_cache[:multiplicative].has_key?(index)
    cached = node_cache[:multiplicative][index]
    if cached
      node_cache[:multiplicative][index] = 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 831
def _nt_multiplicative_operator
  start_index = index
  if node_cache[:multiplicative_operator].has_key?(index)
    cached = node_cache[:multiplicative_operator][index]
    if cached
      node_cache[:multiplicative_operator][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  if (match_len = has_terminal?('^', false, index))
    r1 = instantiate_node(Pow,input, index...(index + match_len))
    @index += match_len
  else
    terminal_parse_failure('^')
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    if (match_len = has_terminal?('*', false, index))
      r2 = true
      @index += match_len
    else
      terminal_parse_failure('*')
      r2 = nil
    end
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      if (match_len = has_terminal?('/', false, index))
        r3 = true
        @index += match_len
      else
        terminal_parse_failure('/')
        r3 = nil
      end
      if r3
        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
        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 1239
def _nt_number
  start_index = index
  if node_cache[:number].has_key?(index)
    cached = node_cache[:number][index]
    if cached
      node_cache[:number][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  r1 = _nt_percentage
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    r2 = _nt_float
    if r2
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      r3 = _nt_integer
      if r3
        r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
        r0 = r3
      else
        i4, s4 = index, []
        if (match_len = has_terminal?('-', false, index))
          r5 = true
          @index += match_len
        else
          terminal_parse_failure('-')
          r5 = nil
        end
        s4 << r5
        if r5
          r6 = _nt_percentage
          s4 << r6
        end
        if s4.last
          r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
          r4.extend(Number0)
        else
          @index = i4
          r4 = nil
        end
        if r4
          r4 = SyntaxNode.new(input, (index-1)...index) if r4 == true
          r0 = r4
        else
          i7, s7 = index, []
          if (match_len = has_terminal?('-', false, index))
            r8 = true
            @index += match_len
          else
            terminal_parse_failure('-')
            r8 = nil
          end
          s7 << r8
          if r8
            r9 = _nt_float
            s7 << r9
          end
          if s7.last
            r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
            r7.extend(Number1)
          else
            @index = i7
            r7 = nil
          end
          if r7
            r7 = SyntaxNode.new(input, (index-1)...index) if r7 == true
            r0 = r7
          else
            i10, s10 = index, []
            if (match_len = has_terminal?('-', false, index))
              r11 = true
              @index += match_len
            else
              terminal_parse_failure('-')
              r11 = nil
            end
            s10 << r11
            if r11
              r12 = _nt_integer
              s10 << r12
            end
            if s10.last
              r10 = instantiate_node(SyntaxNode,input, i10...index, s10)
              r10.extend(Number2)
            else
              @index = i10
              r10 = nil
            end
            if r10
              r10 = SyntaxNode.new(input, (index-1)...index) if r10 == true
              r0 = r10
            else
              @index = i0
              r0 = nil
            end
          end
        end
      end
    end
  end

  node_cache[:number][start_index] = r0

  r0
end
_nt_percentage() click to toggle source
# File lib/soroban/parser/grammar.rb, line 1366
def _nt_percentage
  start_index = index
  if node_cache[:percentage].has_key?(index)
    cached = node_cache[:percentage][index]
    if cached
      node_cache[:percentage][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  i1, s1 = index, []
  r2 = _nt_float
  s1 << r2
  if r2
    r4 = _nt_space
    if r4
      r3 = r4
    else
      r3 = instantiate_node(SyntaxNode,input, index...index)
    end
    s1 << r3
    if r3
      if (match_len = has_terminal?('%', false, index))
        r5 = true
        @index += match_len
      else
        terminal_parse_failure('%')
        r5 = nil
      end
      s1 << r5
    end
  end
  if s1.last
    r1 = instantiate_node(PercentValue,input, i1...index, s1)
    r1.extend(Percentage0)
  else
    @index = i1
    r1 = nil
  end
  if r1
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    i6, s6 = index, []
    r7 = _nt_integer
    s6 << r7
    if r7
      r9 = _nt_space
      if r9
        r8 = r9
      else
        r8 = instantiate_node(SyntaxNode,input, index...index)
      end
      s6 << r8
      if r8
        if (match_len = has_terminal?('%', false, index))
          r10 = true
          @index += match_len
        else
          terminal_parse_failure('%')
          r10 = nil
        end
        s6 << r10
      end
    end
    if s6.last
      r6 = instantiate_node(PercentValue,input, i6...index, s6)
      r6.extend(Percentage1)
    else
      @index = i6
      r6 = nil
    end
    if r6
      r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
      r0 = r6
    else
      @index = i0
      r0 = nil
    end
  end

  node_cache[:percentage][start_index] = r0

  r0
end
_nt_range() click to toggle source
# File lib/soroban/parser/grammar.rb, line 2080
def _nt_range
  start_index = index
  if node_cache[:range].has_key?(index)
    cached = node_cache[:range][index]
    if cached
      node_cache[:range][index] = 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 (match_len = has_terminal?(':', false, index))
      r2 = true
      @index += match_len
    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 2121
def _nt_space
  start_index = index
  if node_cache[:space].has_key?(index)
    cached = node_cache[:space][index]
    if cached
      node_cache[:space][index] = 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?(@regexps[gr = '\A[\\s]'] ||= Regexp.new(gr), :regexp, index)
      r1 = true
      @index += 1
    else
      terminal_parse_failure('[\\s]')
      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 1904
def _nt_string
  start_index = index
  if node_cache[:string].has_key?(index)
    cached = node_cache[:string][index]
    if cached
      node_cache[:string][index] = cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
      @index = cached.interval.end
    end
    return cached
  end

  i0 = index
  i1, s1 = index, []
  if (match_len = has_terminal?('"', false, index))
    r2 = true
    @index += match_len
  else
    terminal_parse_failure('"')
    r2 = nil
  end
  s1 << r2
  if r2
    s3, i3 = [], index
    loop do
      i4 = index
      if (match_len = has_terminal?('\"', false, index))
        r5 = instantiate_node(SyntaxNode,input, index...(index + match_len))
        @index += match_len
      else
        terminal_parse_failure('\"')
        r5 = nil
      end
      if r5
        r5 = SyntaxNode.new(input, (index-1)...index) if r5 == true
        r4 = r5
      else
        i6, s6 = index, []
        i7 = index
        if (match_len = has_terminal?('"', false, index))
          r8 = true
          @index += match_len
        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 = true
            @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
          r6 = SyntaxNode.new(input, (index-1)...index) if r6 == true
          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 (match_len = has_terminal?('"', false, index))
        r10 = true
        @index += match_len
      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
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    i11, s11 = index, []
    if (match_len = has_terminal?("'", false, index))
      r12 = true
      @index += match_len
    else
      terminal_parse_failure("'")
      r12 = nil
    end
    s11 << r12
    if r12
      s13, i13 = [], index
      loop do
        if has_terminal?(@regexps[gr = '\A[^\']'] ||= Regexp.new(gr), :regexp, index)
          r14 = true
          @index += 1
        else
          terminal_parse_failure('[^\']')
          r14 = nil
        end
        if r14
          s13 << r14
        else
          break
        end
      end
      r13 = instantiate_node(SyntaxNode,input, i13...index, s13)
      s11 << r13
      if r13
        if (match_len = has_terminal?("'", false, index))
          r15 = true
          @index += match_len
        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
      r11 = SyntaxNode.new(input, (index-1)...index) if r11 == true
      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 278
def _nt_truthval
  start_index = index
  if node_cache[:truthval].has_key?(index)
    cached = node_cache[:truthval][index]
    if cached
      node_cache[:truthval][index] = 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
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    i2, s2 = index, []
    if (match_len = has_terminal?('(', false, index))
      r3 = true
      @index += match_len
    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 (match_len = has_terminal?(')', false, index))
              r9 = true
              @index += match_len
            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
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      r10 = _nt_boolean
      if r10
        r10 = SyntaxNode.new(input, (index-1)...index) if r10 == true
        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 900
def _nt_value
  start_index = index
  if node_cache[:value].has_key?(index)
    cached = node_cache[:value][index]
    if cached
      node_cache[:value][index] = 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
    r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
    r0 = r1
  else
    i2, s2 = index, []
    if (match_len = has_terminal?('(', false, index))
      r3 = true
      @index += match_len
    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 (match_len = has_terminal?(')', false, index))
              r9 = true
              @index += match_len
            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
      r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
      r0 = r2
    else
      r10 = _nt_range
      if r10
        r10 = SyntaxNode.new(input, (index-1)...index) if r10 == true
        r0 = r10
      else
        r11 = _nt_number
        if r11
          r11 = SyntaxNode.new(input, (index-1)...index) if r11 == true
          r0 = r11
        else
          r12 = _nt_boolean
          if r12
            r12 = SyntaxNode.new(input, (index-1)...index) if r12 == true
            r0 = r12
          else
            r13 = _nt_identifier
            if r13
              r13 = SyntaxNode.new(input, (index-1)...index) if r13 == true
              r0 = r13
            else
              r14 = _nt_string
              if r14
                r14 = SyntaxNode.new(input, (index-1)...index) if r14 == true
                r0 = r14
              else
                i15, s15 = index, []
                if (match_len = has_terminal?('-', false, index))
                  r16 = true
                  @index += match_len
                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
                  r15 = SyntaxNode.new(input, (index-1)...index) if r15 == true
                  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 9
def root
  @root ||= :formula
end