rookout 0.1.0

data/lib/rookout/processor/paths/canopy/actions.rb

@@ -0,0 +1,184 @@
+module Rookout
+  module Processor
+    module Paths
+      module Canopy
+        require_relative "../../../exceptions"
+
+        require_relative "markers"
+        require_relative "consts"
+
+        class Actions
+          def initialize namespace
+            @namespace = namespace
+            @operations = []
+          end
+
+          attr_reader :operations
+
+          def make_lookup_operation input, start, finish, _elements
+            LookupOperation.new input[start + 1...finish - 1]
+          end
+
+          def make_function_operation _input, _start, _finish, elements
+            name = elements[0].text + elements[1].text
+            return elements[3] if elements[3].is_a? Exceptions::ToolException
+
+            args = elements[3].text
+            FunctionOperation.new name, args
+          end
+
+          def make_function_operation_access _input, _start, _finish, elements
+            # To build the function name, we will merge the unicode_set and all the unicode_set_with_numbers
+            # To build the args we will simply read the atom at index 4
+            #   which can be result of another operation; thus checking for exception
+            # For further explanation, check ArithmeticPath.peg
+
+            return elements[4] if elements[4].is_a? ToolExceptionMarker
+
+            function_name = elements[1].text + elements[2].text
+            args = elements[4].text
+            FunctionOperation.new function_name, args
+          end
+
+          def make_attribute_operation input, start, finish, _elements
+            AttributeOperation.new input[start + 1...finish]
+          end
+
+          def make_attribute input, start, finish, _elements
+            AttributeOperation.new input[start...finish]
+          end
+
+          def make_and_execute_namespace_operation input, start, finish, elements
+            # Element 1 will not be null
+            # Element 2 is a list of another elements (can be empty)
+            # element1.(element2.element3.element4)
+            # For further explanation, check ArithmeticPath.peg
+            @operations = []
+            @operations.push elements[1]
+
+            elements[2].elements.each { |e| @operations.push e }
+
+            @operations.each do |op|
+              return op if op.is_a? ToolExceptionMarker
+            end
+
+            result = elements[1].read @namespace, false
+            elements[2].elements.each do |e|
+              result = e.read result, false
+            end
+
+            NamespaceResult.new result, input[start...finish]
+          rescue StandardError => e
+            ToolExceptionMarker.new e
+          end
+
+          def make_comp_exp_ex _input, _start, _finish, elements
+            # Element 2 is the actual expression
+            # For further explanation, check ArithmeticPath.peg
+            elements[2]
+          end
+
+          # rubocop:disable Metrics/AbcSize
+          def make_comp_exp _input, _start, _finish, elements
+            # We can assume the following: atom ( opt_ atom )*
+            # the first (which must be) will be simple atom
+            # the second and so forth will always be pair <Opt, Atom>
+            # Its important to remember that this execution will handle the inner brackets if exist
+            # In order to handle priority (which i could not figure out if available with canopy library):
+            # 1. lets make the tree flat
+            # 2. handle priority ourselves - (atom opt1 atom) will be handled before (atom opt2 atom)
+            #   and will return TreeNode with result
+            # For further explanation, check ArithmeticPath.peg
+
+            # handle case the size is 1
+            return elements[0] if elements[1].elements.empty? || elements[0].is_a?(ToolExceptionMarker)
+
+            flat_elements = [elements[0]]
+            elements[1].elements.each do |it|
+              return it.elements[1] if it.elements[1].is_a? ToolExceptionMarker
+
+              flat_elements.push it.elements[0]
+              flat_elements.push it.elements[1]
+            end
+
+            until flat_elements.length == 1
+              restart_scan = false
+
+              ALL_LEVELS.each_with_index do |_, level|
+                flat_elements.each_with_index do |e, index|
+                  if e.is_a?(Opt) && e.level == level
+                    result = e.execute_operation flat_elements[index - 1], flat_elements[index + 1]
+                    flat_elements = flat_elements[0...index - 1] + [result] + flat_elements[index + 2..-1]
+                    restart_scan = true
+                    break
+                  end
+
+                  break if restart_scan
+                end
+
+                break if restart_scan
+              end
+            end
+
+            flat_elements[0]
+          end
+          # rubocop:enable Metrics/AbcSize
+
+          def make_opt _input, _start, _finish, elements
+            Opt.new elements[1].text
+          end
+
+          def make_apostrophe_string _input, _start, _finish, elements
+            Text.new elements[2].text
+          end
+
+          def make_string _input, _start, _finish, elements
+            Text.new elements[2].text
+          end
+
+          def make_list input, start, finish, elements
+            list = []
+            items_to_scan = [elements[3]]
+            until items_to_scan.empty?
+              item = items_to_scan.pop
+
+              if item.is_a? Marker
+                list.push item
+              else
+                item.elements.each do |e|
+                  items_to_scan.push e
+                end
+              end
+            end
+
+            List.new list, input[start...finish]
+          end
+
+          def make_float input, start, finish, _elements
+            FloatNumber.new input[start...finish].delete " "
+          end
+
+          def make_number input, start, finish, _elements
+            Number.new input[start...finish].delete " "
+          end
+
+          def make_char input, start, finish, _elements
+            Char.new input[start...finish].delete " "
+          end
+
+          def make_bool input, start, finish, _elements
+            Bool.new input[start...finish].delete " "
+          end
+
+          def make_null _input, _start, _finish, _elements
+            Nil.new
+          end
+
+          def make_undefined _input, _start, _finish, _elements
+            Nil.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rookout/processor/paths/canopy/consts.rb

@@ -0,0 +1,82 @@
+module Rookout
+  module Processor
+    module Paths
+      module Canopy
+        require "bigdecimal"
+
+        LEVEL1 = ["*", "/"].freeze
+        LEVEL2 = ["+", "-"].freeze
+        LEVEL3 = ["<=", ">=", "!=", "=", "==", ">", "<", "LT", "GT", "LE", "GE", "EQ", "NE", "lt", "gt", "le", "ge",
+                  "eq", "ne"].freeze
+        LEVEL4 = ["in"].freeze
+        LEVEL5 = ["or", "OR", "||", "and", "AND", "&&"].freeze
+
+        ALL_LEVELS = [LEVEL1, LEVEL2, LEVEL3, LEVEL4, LEVEL5].freeze
+
+        PRIMITIVES = [Array, Hash, TrueClass, FalseClass, Symbol, Integer, Float, Complex, Rational, BigDecimal,
+                      String].freeze
+
+        OPS_ALTERNATIVES = {
+          "NE" => "!=",
+          "=" => "==",
+          "EQ" => "==",
+          "LT" => "<",
+          "GT" => ">",
+          "GE" => ">=",
+          "LE" => "<=",
+          "AND" => "and",
+          "OR" => "or",
+          "&&" => "and",
+          "IN" => "in",
+          "||" => "or"
+        }.freeze
+
+        OPS_FUNCTIONS = {
+          "+" => ->(a, b) { a + b },
+          "-" => ->(a, b) { a - b },
+          "/" => ->(a, b) { a / b },
+          "*" => ->(a, b) { a * b },
+          "<" => ->(a, b) { a < b },
+          "<=" => ->(a, b) { a <= b },
+          ">" => ->(a, b) { a > b },
+          ">=" => ->(a, b) { a >= b },
+          "!=" => ->(a, b) { a != b },
+          "=" => ->(a, b) { a == b },
+          "==" => ->(a, b) { a == b },
+          "in" => lambda do |a, b|
+            # If both are strings, just call include
+            return b.include? a if b.is_a?(String) && a.is_a?(String)
+
+            # If it's a dict, scan the keys, compensating for additional abstraction
+            if b.is_a? Hash
+              b.each_key do |key|
+                if key.is_a? ObjectMarker
+                  return true if key.obj == a
+                elsif key == a
+                  return true
+                end
+              end
+              return false
+            end
+
+            # If it's an array, scan the value, compensating for additional abstraction
+            if b.is_a? Array
+              b.each do |value|
+                if value.is_a? ObjectMarker
+                  return true if value.obj == a
+                elsif value == a
+                  return true
+                end
+              end
+              return false
+            end
+
+            false
+          end,
+          "and" => ->(a, b) { a && b },
+          "or" => ->(a, b) { a || b }
+        }.freeze
+      end
+    end
+  end
+end

data/lib/rookout/processor/paths/canopy/maps.rb

@@ -0,0 +1,2837 @@
+# This file was generated from ../rookout/canopy/ArithmeticPath.peg
+# See http://canopy.jcoglan.com/ for documentation.
+
+module Maps
+  class TreeNode
+    include Enumerable
+    attr_reader :text, :offset, :elements
+
+    def initialize(text, offset, elements)
+      @text = text
+      @offset = offset
+      @elements = elements
+    end
+
+    def each(&block)
+      @elements.each(&block)
+    end
+  end
+
+  class TreeNode1 < TreeNode
+    attr_reader :atom
+
+    def initialize(text, offset, elements)
+      super
+      @atom = elements[0]
+    end
+  end
+
+  class TreeNode2 < TreeNode
+    attr_reader :opt_, :atom
+
+    def initialize(text, offset, elements)
+      super
+      @opt_ = elements[0]
+      @atom = elements[1]
+    end
+  end
+
+  class TreeNode3 < TreeNode
+    attr_reader :unicode_set
+
+    def initialize(text, offset, elements)
+      super
+      @unicode_set = elements[0]
+    end
+  end
+
+  class TreeNode4 < TreeNode
+    attr_reader :variable
+
+    def initialize(text, offset, elements)
+      super
+      @variable = elements[1]
+    end
+  end
+
+  class TreeNode5 < TreeNode
+    attr_reader :unicode_set
+
+    def initialize(text, offset, elements)
+      super
+      @unicode_set = elements[0]
+    end
+  end
+
+  class TreeNode6 < TreeNode
+    attr_reader :unicode_set
+
+    def initialize(text, offset, elements)
+      super
+      @unicode_set = elements[1]
+    end
+  end
+
+  class TreeNode7 < TreeNode
+    attr_reader :__
+
+    def initialize(text, offset, elements)
+      super
+      @__ = elements[3]
+    end
+  end
+
+  class TreeNode8 < TreeNode
+    attr_reader :__, :comp_expression
+
+    def initialize(text, offset, elements)
+      super
+      @__ = elements[4]
+      @comp_expression = elements[2]
+    end
+  end
+
+  class TreeNode9 < TreeNode
+    attr_reader :__
+
+    def initialize(text, offset, elements)
+      super
+      @__ = elements[4]
+    end
+  end
+
+  class TreeNode10 < TreeNode
+    attr_reader :__
+
+    def initialize(text, offset, elements)
+      super
+      @__ = elements[4]
+    end
+  end
+
+  class TreeNode11 < TreeNode
+    attr_reader :__
+
+    def initialize(text, offset, elements)
+      super
+      @__ = elements[6]
+    end
+  end
+
+  class TreeNode12 < TreeNode
+    attr_reader :atom, :__
+
+    def initialize(text, offset, elements)
+      super
+      @atom = elements[0]
+      @__ = elements[1]
+    end
+  end
+
+  class TreeNode13 < TreeNode
+    attr_reader :__, :atom
+
+    def initialize(text, offset, elements)
+      super
+      @__ = elements[3]
+      @atom = elements[2]
+    end
+  end
+
+  class TreeNode14 < TreeNode
+    attr_reader :__
+
+    def initialize(text, offset, elements)
+      super
+      @__ = elements[4]
+    end
+  end
+
+  class TreeNode15 < TreeNode
+    attr_reader :__
+
+    def initialize(text, offset, elements)
+      super
+      @__ = elements[3]
+    end
+  end
+
+  class TreeNode16 < TreeNode
+    attr_reader :__
+
+    def initialize(text, offset, elements)
+      super
+      @__ = elements[5]
+    end
+  end
+
+  class TreeNode17 < TreeNode
+    attr_reader :__, :data
+
+    def initialize(text, offset, elements)
+      super
+      @__ = elements[2]
+      @data = elements[1]
+    end
+  end
+
+  class TreeNode18 < TreeNode
+    attr_reader :__, :data
+
+    def initialize(text, offset, elements)
+      super
+      @__ = elements[2]
+      @data = elements[1]
+    end
+  end
+
+  class TreeNode19 < TreeNode
+    attr_reader :__, :data
+
+    def initialize(text, offset, elements)
+      super
+      @__ = elements[2]
+      @data = elements[1]
+    end
+  end
+
+  class TreeNode20 < TreeNode
+    attr_reader :__, :data
+
+    def initialize(text, offset, elements)
+      super
+      @__ = elements[2]
+      @data = elements[1]
+    end
+  end
+
+  ParseError = Class.new(StandardError)
+
+  FAILURE = Object.new
+
+  module Grammar
+    def _read_comp_expression
+      address0, index0 = FAILURE, @offset
+      cached = @cache[:comp_expression][index0]
+      if cached
+        @offset = cached[1]
+        return cached[0]
+      end
+      index1, elements0 = @offset, []
+      address1 = FAILURE
+      address1 = _read_atom
+      unless address1 == FAILURE
+        elements0 << address1
+        address2 = FAILURE
+        remaining0, index2, elements1, address3 = 0, @offset, [], true
+        until address3 == FAILURE
+          index3, elements2 = @offset, []
+          address4 = FAILURE
+          address4 = _read_opt_
+          unless address4 == FAILURE
+            elements2 << address4
+            address5 = FAILURE
+            address5 = _read_atom
+            unless address5 == FAILURE
+              elements2 << address5
+            else
+              elements2 = nil
+              @offset = index3
+            end
+          else
+            elements2 = nil
+            @offset = index3
+          end
+          if elements2.nil?
+            address3 = FAILURE
+          else
+            address3 = TreeNode2.new(@input[index3...@offset], index3, elements2)
+            @offset = @offset
+          end
+          unless address3 == FAILURE
+            elements1 << address3
+            remaining0 -= 1
+          end
+        end
+        if remaining0 <= 0
+          address2 = TreeNode.new(@input[index2...@offset], index2, elements1)
+          @offset = @offset
+        else
+          address2 = FAILURE
+        end
+        unless address2 == FAILURE
+          elements0 << address2
+        else
+          elements0 = nil
+          @offset = index1
+        end
+      else
+        elements0 = nil
+        @offset = index1
+      end
+      if elements0.nil?
+        address0 = FAILURE
+      else
+        address0 = @actions.make_comp_exp(@input, index1, @offset, elements0)
+        @offset = @offset
+      end
+      @cache[:comp_expression][index0] = [address0, @offset]
+      return address0
+    end
+
+    def _read_atom
+      address0, index0 = FAILURE, @offset
+      cached = @cache[:atom][index0]
+      if cached
+        @offset = cached[1]
+        return cached[0]
+      end
+      index1 = @offset
+      address0 = _read_float_
+      if address0 == FAILURE
+        @offset = index1
+        address0 = _read_number
+        if address0 == FAILURE
+          @offset = index1
+          address0 = _read_string
+          if address0 == FAILURE
+            @offset = index1
+            address0 = _read_apostrophe_string
+            if address0 == FAILURE
+              @offset = index1
+              address0 = _read_list
+              if address0 == FAILURE
+                @offset = index1
+                address0 = _read_chr
+                if address0 == FAILURE
+                  @offset = index1
+                  address0 = _read_boolean_
+                  if address0 == FAILURE
+                    @offset = index1
+                    address0 = _read_null_
+                    if address0 == FAILURE
+                      @offset = index1
+                      address0 = _read_undefined_
+                      if address0 == FAILURE
+                        @offset = index1
+                        address0 = _read_comp_expression_ex
+                        if address0 == FAILURE
+                          @offset = index1
+                          address0 = _read_namespace
+                          if address0 == FAILURE
+                            @offset = index1
+                          end
+                        end
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+      @cache[:atom][index0] = [address0, @offset]
+      return address0
+    end
+
+    def _read_unicode_set
+      address0, index0 = FAILURE, @offset
+      cached = @cache[:unicode_set][index0]
+      if cached
+        @offset = cached[1]
+        return cached[0]
+      end
+      chunk0, max0 = nil, @offset + 1
+      if max0 <= @input_size
+        chunk0 = @input[@offset...max0]
+      end
+      if chunk0 =~ /\A[a-zA-Z_$@]/
+        address0 = TreeNode.new(@input[@offset...@offset + 1], @offset, [])
+        @offset = @offset + 1
+      else
+        address0 = FAILURE
+        if @offset > @failure
+          @failure = @offset
+          @expected = []
+        end
+        if @offset == @failure
+          @expected << "[a-zA-Z_$@]"
+        end
+      end
+      @cache[:unicode_set][index0] = [address0, @offset]
+      return address0
+    end
+
+    def _read_unicode_set_with_numbers
+      address0, index0 = FAILURE, @offset
+      cached = @cache[:unicode_set_with_numbers][index0]
+      if cached
+        @offset = cached[1]
+        return cached[0]
+      end
+      chunk0, max0 = nil, @offset + 1
+      if max0 <= @input_size
+        chunk0 = @input[@offset...max0]
+      end
+      if chunk0 =~ /\A[a-zA-Z0-9_$@]/
+        address0 = TreeNode.new(@input[@offset...@offset + 1], @offset, [])
+        @offset = @offset + 1
+      else
+        address0 = FAILURE
+        if @offset > @failure
+          @failure = @offset
+          @expected = []
+        end
+        if @offset == @failure
+          @expected << "[a-zA-Z0-9_$@]"
+        end
+      end
+      @cache[:unicode_set_with_numbers][index0] = [address0, @offset]
+      return address0
+    end
+
+    def _read_variable
+      address0, index0 = FAILURE, @offset
+      cached = @cache[:variable][index0]
+      if cached
+        @offset = cached[1]
+        return cached[0]
+      end
+      index1, elements0 = @offset, []
+      address1 = FAILURE
+      address1 = _read_unicode_set
+      unless address1 == FAILURE
+        elements0 << address1
+        address2 = FAILURE
+        remaining0, index2, elements1, address3 = 0, @offset, [], true
+        until address3 == FAILURE
+          address3 = _read_unicode_set_with_numbers
+          unless address3 == FAILURE
+            elements1 << address3
+            remaining0 -= 1
+          end
+        end
+        if remaining0 <= 0
+          address2 = TreeNode.new(@input[index2...@offset], index2, elements1)
+          @offset = @offset
+        else
+          address2 = FAILURE
+        end
+        unless address2 == FAILURE
+          elements0 << address2
+        else
+          elements0 = nil
+          @offset = index1
+        end
+      else
+        elements0 = nil
+        @offset = index1
+      end
+      if elements0.nil?
+        address0 = FAILURE
+      else
+        address0 = @actions.make_attribute(@input, index1, @offset, elements0)
+        @offset = @offset
+      end
+      @cache[:variable][index0] = [address0, @offset]
+      return address0
+    end
+
+    def _read_variable_access
+      address0, index0 = FAILURE, @offset
+      cached = @cache[:variable_access][index0]
+      if cached
+        @offset = cached[1]
+        return cached[0]
+      end
+      index1, elements0 = @offset, []
+      address1 = FAILURE
+      chunk0, max0 = nil, @offset + 1
+      if max0 <= @input_size
+        chunk0 = @input[@offset...max0]
+      end
+      if chunk0 == "."
+        address1 = TreeNode.new(@input[@offset...@offset + 1], @offset, [])
+        @offset = @offset + 1
+      else
+        address1 = FAILURE
+        if @offset > @failure
+          @failure = @offset
+          @expected = []
+        end
+        if @offset == @failure
+          @expected << "\".\""
+        end
+      end
+      unless address1 == FAILURE
+        elements0 << address1
+        address2 = FAILURE
+        address2 = _read_variable
+        unless address2 == FAILURE
+          elements0 << address2
+        else
+          elements0 = nil
+          @offset = index1
+        end
+      else
+        elements0 = nil
+        @offset = index1
+      end
+      if elements0.nil?
+        address0 = FAILURE
+      else
+        address0 = @actions.make_attribute_operation(@input, index1, @offset, elements0)
+        @offset = @offset
+      end
+      @cache[:variable_access][index0] = [address0, @offset]
+      return address0
+    end
+
+    def _read_map_access
+      address0, index0 = FAILURE, @offset
+      cached = @cache[:map_access][index0]
+      if cached
+        @offset = cached[1]
+        return cached[0]
+      end
+      index1, elements0 = @offset, []
+      address1 = FAILURE
+      chunk0, max0 = nil, @offset + 1
+      if max0 <= @input_size
+        chunk0 = @input[@offset...max0]
+      end
+      if chunk0 == "["
+        address1 = TreeNode.new(@input[@offset...@offset + 1], @offset, [])
+        @offset = @offset + 1
+      else
+        address1 = FAILURE
+        if @offset > @failure
+          @failure = @offset
+          @expected = []
+        end
+        if @offset == @failure
+          @expected << "\"[\""
+        end
+      end
+      unless address1 == FAILURE
+        elements0 << address1
+        address2 = FAILURE
+        index2 = @offset
+        address2 = _read_chr
+        if address2 == FAILURE
+          @offset = index2
+          address2 = _read_string
+          if address2 == FAILURE
+            @offset = index2
+            address2 = _read_apostrophe_string
+            if address2 == FAILURE
+              @offset = index2
+              address2 = _read_number
+              if address2 == FAILURE
+                @offset = index2
+              end
+            end
+          end
+        end
+        unless address2 == FAILURE
+          elements0 << address2
+          address3 = FAILURE
+          chunk1, max1 = nil, @offset + 1
+          if max1 <= @input_size
+            chunk1 = @input[@offset...max1]
+          end
+          if chunk1 == "]"
+            address3 = TreeNode.new(@input[@offset...@offset + 1], @offset, [])
+            @offset = @offset + 1
+          else
+            address3 = FAILURE
+            if @offset > @failure
+              @failure = @offset
+              @expected = []
+            end
+            if @offset == @failure
+              @expected << "\"]\""
+            end
+          end
+          unless address3 == FAILURE
+            elements0 << address3
+          else
+            elements0 = nil
+            @offset = index1
+          end
+        else
+          elements0 = nil
+          @offset = index1
+        end
+      else
+        elements0 = nil
+        @offset = index1
+      end
+      if elements0.nil?
+        address0 = FAILURE
+      else
+        address0 = @actions.make_lookup_operation(@input, index1, @offset, elements0)
+        @offset = @offset
+      end
+      @cache[:map_access][index0] = [address0, @offset]
+      return address0
+    end
+
+    def _read_func_call
+      address0, index0 = FAILURE, @offset
+      cached = @cache[:func_call][index0]
+      if cached
+        @offset = cached[1]
+        return cached[0]
+      end
+      index1, elements0 = @offset, []
+      address1 = FAILURE
+      address1 = _read_unicode_set
+      unless address1 == FAILURE
+        elements0 << address1
+        address2 = FAILURE
+        remaining0, index2, elements1, address3 = 0, @offset, [], true
+        until address3 == FAILURE
+          address3 = _read_unicode_set_with_numbers
+          unless address3 == FAILURE
+            elements1 << address3
+            remaining0 -= 1
+          end
+        end
+        if remaining0 <= 0
+          address2 = TreeNode.new(@input[index2...@offset], index2, elements1)
+          @offset = @offset
+        else
+          address2 = FAILURE
+        end
+        unless address2 == FAILURE
+          elements0 << address2
+          address4 = FAILURE
+          chunk0, max0 = nil, @offset + 1
+          if max0 <= @input_size
+            chunk0 = @input[@offset...max0]
+          end
+          if chunk0 == "("
+            address4 = TreeNode.new(@input[@offset...@offset + 1], @offset, [])
+            @offset = @offset + 1
+          else
+            address4 = FAILURE
+            if @offset > @failure
+              @failure = @offset
+              @expected = []
+            end
+            if @offset == @failure
+              @expected << "\"(\""
+            end
+          end
+          unless address4 == FAILURE
+            elements0 << address4
+            address5 = FAILURE
+            index3 = @offset
+            address5 = _read_atom
+            if address5 == FAILURE
+              address5 = TreeNode.new(@input[index3...index3], index3, [])
+              @offset = index3
+            end
+            unless address5 == FAILURE
+              elements0 << address5
+              address6 = FAILURE
+              chunk1, max1 = nil, @offset + 1
+              if max1 <= @input_size
+                chunk1 = @input[@offset...max1]
+              end
+              if chunk1 == ")"
+                address6 = TreeNode.new(@input[@offset...@offset + 1], @offset, [])
+                @offset = @offset + 1
+              else
+                address6 = FAILURE
+                if @offset > @failure
+                  @failure = @offset
+                  @expected = []
+                end
+                if @offset == @failure
+                  @expected << "\")\""
+                end
+              end
+              unless address6 == FAILURE
+                elements0 << address6
+              else
+                elements0 = nil
+                @offset = index1
+              end
+            else
+              elements0 = nil
+              @offset = index1
+            end
+          else
+            elements0 = nil
+            @offset = index1
+          end
+        else
+          elements0 = nil
+          @offset = index1
+        end
+      else
+        elements0 = nil
+        @offset = index1
+      end
+      if elements0.nil?
+        address0 = FAILURE
+      else
+        address0 = @actions.make_function_operation(@input, index1, @offset, elements0)
+        @offset = @offset
+      end
+      @cache[:func_call][index0] = [address0, @offset]
+      return address0
+    end
+
+    def _read_func_call_access
+      address0, index0 = FAILURE, @offset
+      cached = @cache[:func_call_access][index0]
+      if cached
+        @offset = cached[1]
+        return cached[0]
+      end
+      index1, elements0 = @offset, []
+      address1 = FAILURE
+      chunk0, max0 = nil, @offset + 1
+      if max0 <= @input_size
+        chunk0 = @input[@offset...max0]
+      end
+      if chunk0 == "."
+        address1 = TreeNode.new(@input[@offset...@offset + 1], @offset, [])
+        @offset = @offset + 1
+      else
+        address1 = FAILURE
+        if @offset > @failure
+          @failure = @offset
+          @expected = []
+        end
+        if @offset == @failure
+          @expected << "\".\""
+        end
+      end
+      unless address1 == FAILURE
+        elements0 << address1
+        address2 = FAILURE
+        address2 = _read_unicode_set
+        unless address2 == FAILURE
+          elements0 << address2
+          address3 = FAILURE
+          remaining0, index2, elements1, address4 = 0, @offset, [], true
+          until address4 == FAILURE
+            address4 = _read_unicode_set_with_numbers
+            unless address4 == FAILURE
+              elements1 << address4
+              remaining0 -= 1
+            end
+          end
+          if remaining0 <= 0
+            address3 = TreeNode.new(@input[index2...@offset], index2, elements1)
+            @offset = @offset
+          else
+            address3 = FAILURE
+          end
+          unless address3 == FAILURE
+            elements0 << address3
+            address5 = FAILURE
+            chunk1, max1 = nil, @offset + 1
+            if max1 <= @input_size
+              chunk1 = @input[@offset...max1]
+            end
+            if chunk1 == "("
+              address5 = TreeNode.new(@input[@offset...@offset + 1], @offset, [])
+              @offset = @offset + 1
+            else
+              address5 = FAILURE
+              if @offset > @failure
+                @failure = @offset
+                @expected = []
+              end
+              if @offset == @failure
+                @expected << "\"(\""
+              end
+            end
+            unless address5 == FAILURE
+              elements0 << address5
+              address6 = FAILURE
+              index3 = @offset
+              address6 = _read_atom
+              if address6 == FAILURE
+                address6 = TreeNode.new(@input[index3...index3], index3, [])
+                @offset = index3
+              end
+              unless address6 == FAILURE
+                elements0 << address6
+                address7 = FAILURE
+                chunk2, max2 = nil, @offset + 1
+                if max2 <= @input_size
+                  chunk2 = @input[@offset...max2]
+                end
+                if chunk2 == ")"
+                  address7 = TreeNode.new(@input[@offset...@offset + 1], @offset, [])
+                  @offset = @offset + 1
+                else
+                  address7 = FAILURE
+                  if @offset > @failure
+                    @failure = @offset
+                    @expected = []
+                  end
+                  if @offset == @failure
+                    @expected << "\")\""
+                  end
+                end
+                unless address7 == FAILURE
+                  elements0 << address7
+                else
+                  elements0 = nil
+                  @offset = index1
+                end
+              else
+                elements0 = nil
+                @offset = index1
+              end
+            else
+              elements0 = nil
+              @offset = index1
+            end
+          else
+            elements0 = nil
+            @offset = index1
+          end
+        else
+          elements0 = nil
+          @offset = index1
+        end
+      else
+        elements0 = nil
+        @offset = index1
+      end
+      if elements0.nil?
+        address0 = FAILURE
+      else
+        address0 = @actions.make_function_operation_access(@input, index1, @offset, elements0)
+        @offset = @offset
+      end
+      @cache[:func_call_access][index0] = [address0, @offset]
+      return address0
+    end
+
+    def _read_namespace
+      address0, index0 = FAILURE, @offset
+      cached = @cache[:namespace][index0]
+      if cached
+        @offset = cached[1]
+        return cached[0]
+      end
+      index1, elements0 = @offset, []
+      address1 = FAILURE
+      address1 = _read___
+      unless address1 == FAILURE
+        elements0 << address1
+        address2 = FAILURE
+        index2 = @offset
+        address2 = _read_func_call
+        if address2 == FAILURE
+          @offset = index2
+          address2 = _read_variable
+          if address2 == FAILURE
+            @offset = index2
+          end
+        end
+        unless address2 == FAILURE
+          elements0 << address2
+          address3 = FAILURE
+          remaining0, index3, elements1, address4 = 0, @offset, [], true
+          until address4 == FAILURE
+            index4 = @offset
+            address4 = _read_func_call_access
+            if address4 == FAILURE
+              @offset = index4
+              address4 = _read_map_access
+              if address4 == FAILURE
+                @offset = index4
+                address4 = _read_variable_access
+                if address4 == FAILURE
+                  @offset = index4
+                end
+              end
+            end
+            unless address4 == FAILURE
+              elements1 << address4
+              remaining0 -= 1
+            end
+          end
+          if remaining0 <= 0
+            address3 = TreeNode.new(@input[index3...@offset], index3, elements1)
+            @offset = @offset
+          else
+            address3 = FAILURE
+          end
+          unless address3 == FAILURE
+            elements0 << address3
+            address5 = FAILURE
+            address5 = _read___
+            unless address5 == FAILURE
+              elements0 << address5
+            else
+              elements0 = nil
+              @offset = index1
+            end
+          else
+            elements0 = nil
+            @offset = index1
+          end
+        else
+          elements0 = nil
+          @offset = index1
+        end
+      else
+        elements0 = nil
+        @offset = index1
+      end
+      if elements0.nil?
+        address0 = FAILURE
+      else
+        address0 = @actions.make_and_execute_namespace_operation(@input, index1, @offset, elements0)
+        @offset = @offset
+      end
+      @cache[:namespace][index0] = [address0, @offset]
+      return address0
+    end
+
+    def _read_comp_expression_ex
+      address0, index0 = FAILURE, @offset
+      cached = @cache[:comp_expression_ex][index0]
+      if cached
+        @offset = cached[1]
+        return cached[0]
+      end
+      index1, elements0 = @offset, []
+      address1 = FAILURE
+      address1 = _read___
+      unless address1 == FAILURE
+        elements0 << address1
+        address2 = FAILURE
+        chunk0, max0 = nil, @offset + 1
+        if max0 <= @input_size
+          chunk0 = @input[@offset...max0]
+        end
+        if chunk0 == "("
+          address2 = TreeNode.new(@input[@offset...@offset + 1], @offset, [])
+          @offset = @offset + 1
+        else
+          address2 = FAILURE
+          if @offset > @failure
+            @failure = @offset
+            @expected = []
+          end
+          if @offset == @failure
+            @expected << "\"(\""
+          end
+        end
+        unless address2 == FAILURE
+          elements0 << address2
+          address3 = FAILURE
+          address3 = _read_comp_expression
+          unless address3 == FAILURE
+            elements0 << address3
+            address4 = FAILURE
+            chunk1, max1 = nil, @offset + 1
+            if max1 <= @input_size
+              chunk1 = @input[@offset...max1]
+            end
+            if chunk1 == ")"
+              address4 = TreeNode.new(@input[@offset...@offset + 1], @offset, [])
+              @offset = @offset + 1
+            else
+              address4 = FAILURE
+              if @offset > @failure
+                @failure = @offset
+                @expected = []
+              end
+              if @offset == @failure
+                @expected << "\")\""
+              end
+            end
+            unless address4 == FAILURE
+              elements0 << address4
+              address5 = FAILURE
+              address5 = _read___
+              unless address5 == FAILURE
+                elements0 << address5
+              else
+                elements0 = nil
+                @offset = index1
+              end
+            else
+              elements0 = nil
+              @offset = index1
+            end
+          else
+            elements0 = nil
+            @offset = index1
+          end
+        else
+          elements0 = nil
+          @offset = index1
+        end
+      else
+        elements0 = nil
+        @offset = index1
+      end
+      if elements0.nil?
+        address0 = FAILURE
+      else
+        address0 = @actions.make_comp_exp_ex(@input, index1, @offset, elements0)
+        @offset = @offset
+      end
+      @cache[:comp_expression_ex][index0] = [address0, @offset]
+      return address0
+    end
+
+    def _read_string
+      address0, index0 = FAILURE, @offset
+      cached = @cache[:string][index0]
+      if cached
+        @offset = cached[1]
+        return cached[0]
+      end
+      index1, elements0 = @offset, []
+      address1 = FAILURE
+      address1 = _read___
+      unless address1 == FAILURE
+        elements0 << address1
+        address2 = FAILURE
+        chunk0, max0 = nil, @offset + 1
+        if max0 <= @input_size
+          chunk0 = @input[@offset...max0]
+        end
+        if chunk0 =~ /\A[\"]/
+          address2 = TreeNode.new(@input[@offset...@offset + 1], @offset, [])
+          @offset = @offset + 1
+        else
+          address2 = FAILURE
+          if @offset > @failure
+            @failure = @offset
+            @expected = []
+          end
+          if @offset == @failure
+            @expected << "[\\\"]"
+          end
+        end
+        unless address2 == FAILURE
+          elements0 << address2
+          address3 = FAILURE
+          remaining0, index2, elements1, address4 = 0, @offset, [], true
+          until address4 == FAILURE
+            chunk1, max1 = nil, @offset + 1
+            if max1 <= @input_size
+              chunk1 = @input[@offset...max1]
+            end
+            if chunk1 =~ /\A[ !#-~]/
+              address4 = TreeNode.new(@input[@offset...@offset + 1], @offset, [])
+              @offset = @offset + 1
+            else
+              address4 = FAILURE
+              if @offset > @failure
+                @failure = @offset
+                @expected = []
+              end
+              if @offset == @failure
+                @expected << "[ !#-~]"
+              end
+            end
+            unless address4 == FAILURE
+              elements1 << address4
+              remaining0 -= 1
+            end
+          end
+          if remaining0 <= 0
+            address3 = TreeNode.new(@input[index2...@offset], index2, elements1)
+            @offset = @offset
+          else
+            address3 = FAILURE
+          end
+          unless address3 == FAILURE
+            elements0 << address3
+            address5 = FAILURE
+            chunk2, max2 = nil, @offset + 1
+            if max2 <= @input_size
+              chunk2 = @input[@offset...max2]
+            end
+            if chunk2 =~ /\A[\"]/
+              address5 = TreeNode.new(@input[@offset...@offset + 1], @offset, [])
+              @offset = @offset + 1
+            else
+              address5 = FAILURE
+              if @offset > @failure
+                @failure = @offset
+                @expected = []
+              end
+              if @offset == @failure
+                @expected << "[\\\"]"
+              end
+            end
+            unless address5 == FAILURE
+              elements0 << address5
+              address6 = FAILURE
+              address6 = _read___
+              unless address6 == FAILURE
+                elements0 << address6
+              else
+                elements0 = nil
+                @offset = index1
+              end
+            else
+              elements0 = nil
+              @offset = index1
+            end
+          else
+            elements0 = nil
+            @offset = index1
+          end
+        else
+          elements0 = nil
+          @offset = index1
+        end
+      else
+        elements0 = nil
+        @offset = index1
+      end
+      if elements0.nil?
+        address0 = FAILURE
+      else
+        address0 = @actions.make_string(@input, index1, @offset, elements0)
+        @offset = @offset
+      end
+      @cache[:string][index0] = [address0, @offset]
+      return address0
+    end
+
+    def _read_apostrophe_string
+      address0, index0 = FAILURE, @offset
+      cached = @cache[:apostrophe_string][index0]
+      if cached
+        @offset = cached[1]
+        return cached[0]
+      end
+      index1, elements0 = @offset, []
+      address1 = FAILURE
+      address1 = _read___
+      unless address1 == FAILURE
+        elements0 << address1
+        address2 = FAILURE
+        chunk0, max0 = nil, @offset + 1
+        if max0 <= @input_size
+          chunk0 = @input[@offset...max0]
+        end
+        if chunk0 == "'"
+          address2 = TreeNode.new(@input[@offset...@offset + 1], @offset, [])
+          @offset = @offset + 1
+        else
+          address2 = FAILURE
+          if @offset > @failure
+            @failure = @offset
+            @expected = []
+          end
+          if @offset == @failure
+            @expected << "\"'\""
+          end
+        end
+        unless address2 == FAILURE
+          elements0 << address2
+          address3 = FAILURE
+          remaining0, index2, elements1, address4 = 0, @offset, [], true
+          until address4 == FAILURE
+            chunk1, max1 = nil, @offset + 1
+            if max1 <= @input_size
+              chunk1 = @input[@offset...max1]
+            end
+            if chunk1 =~ /\A[^']/
+              address4 = TreeNode.new(@input[@offset...@offset + 1], @offset, [])
+              @offset = @offset + 1
+            else
+              address4 = FAILURE
+              if @offset > @failure
+                @failure = @offset
+                @expected = []
+              end
+              if @offset == @failure
+                @expected << "[^']"
+              end
+            end
+            unless address4 == FAILURE
+              elements1 << address4
+              remaining0 -= 1
+            end
+          end
+          if remaining0 <= 0
+            address3 = TreeNode.new(@input[index2...@offset], index2, elements1)
+            @offset = @offset
+          else
+            address3 = FAILURE
+          end
+          unless address3 == FAILURE
+            elements0 << address3
+            address5 = FAILURE
+            chunk2, max2 = nil, @offset + 1
+            if max2 <= @input_size
+              chunk2 = @input[@offset...max2]
+            end
+            if chunk2 == "'"
+              address5 = TreeNode.new(@input[@offset...@offset + 1], @offset, [])
+              @offset = @offset + 1
+            else
+              address5 = FAILURE
+              if @offset > @failure
+                @failure = @offset
+                @expected = []
+              end
+              if @offset == @failure
+                @expected << "\"'\""
+              end
+            end
+            unless address5 == FAILURE
+              elements0 << address5
+              address6 = FAILURE
+              address6 = _read___
+              unless address6 == FAILURE
+                elements0 << address6
+              else
+                elements0 = nil
+                @offset = index1
+              end
+            else
+              elements0 = nil
+              @offset = index1
+            end
+          else
+            elements0 = nil
+            @offset = index1
+          end
+        else
+          elements0 = nil
+          @offset = index1
+        end
+      else
+        elements0 = nil
+        @offset = index1
+      end
+      if elements0.nil?
+        address0 = FAILURE
+      else
+        address0 = @actions.make_apostrophe_string(@input, index1, @offset, elements0)
+        @offset = @offset
+      end
+      @cache[:apostrophe_string][index0] = [address0, @offset]
+      return address0
+    end
+
+    def _read_list
+      address0, index0 = FAILURE, @offset
+      cached = @cache[:list][index0]
+      if cached
+        @offset = cached[1]
+        return cached[0]
+      end
+      index1, elements0 = @offset, []
+      address1 = FAILURE
+      address1 = _read___
+      unless address1 == FAILURE
+        elements0 << address1
+        address2 = FAILURE
+        chunk0, max0 = nil, @offset + 1
+        if max0 <= @input_size
+          chunk0 = @input[@offset...max0]
+        end
+        if chunk0 == "["
+          address2 = TreeNode.new(@input[@offset...@offset + 1], @offset, [])
+          @offset = @offset + 1
+        else
+          address2 = FAILURE
+          if @offset > @failure
+            @failure = @offset
+            @expected = []
+          end
+          if @offset == @failure
+            @expected << "\"[\""
+          end
+        end
+        unless address2 == FAILURE
+          elements0 << address2
+          address3 = FAILURE
+          address3 = _read___
+          unless address3 == FAILURE
+            elements0 << address3
+            address4 = FAILURE
+            index2 = @offset
+            index3, elements1 = @offset, []
+            address5 = FAILURE
+            address5 = _read_atom
+            unless address5 == FAILURE
+              elements1 << address5
+              address6 = FAILURE
+              address6 = _read___
+              unless address6 == FAILURE
+                elements1 << address6
+                address7 = FAILURE
+                remaining0, index4, elements2, address8 = 0, @offset, [], true
+                until address8 == FAILURE
+                  index5, elements3 = @offset, []
+                  address9 = FAILURE
+                  chunk1, max1 = nil, @offset + 1
+                  if max1 <= @input_size
+                    chunk1 = @input[@offset...max1]
+                  end
+                  if chunk1 == ","
+                    address9 = TreeNode.new(@input[@offset...@offset + 1], @offset, [])
+                    @offset = @offset + 1
+                  else
+                    address9 = FAILURE
+                    if @offset > @failure
+                      @failure = @offset
+                      @expected = []
+                    end
+                    if @offset == @failure
+                      @expected << "\",\""
+                    end
+                  end
+                  unless address9 == FAILURE
+                    elements3 << address9
+                    address10 = FAILURE
+                    address10 = _read___
+                    unless address10 == FAILURE
+                      elements3 << address10
+                      address11 = FAILURE
+                      address11 = _read_atom
+                      unless address11 == FAILURE
+                        elements3 << address11
+                        address12 = FAILURE
+                        address12 = _read___
+                        unless address12 == FAILURE
+                          elements3 << address12
+                        else
+                          elements3 = nil
+                          @offset = index5
+                        end
+                      else
+                        elements3 = nil
+                        @offset = index5
+                      end
+                    else
+                      elements3 = nil
+                      @offset = index5
+                    end
+                  else
+                    elements3 = nil
+                    @offset = index5
+                  end
+                  if elements3.nil?
+                    address8 = FAILURE
+                  else
+                    address8 = TreeNode13.new(@input[index5...@offset], index5, elements3)
+                    @offset = @offset
+                  end
+                  unless address8 == FAILURE
+                    elements2 << address8
+                    remaining0 -= 1
+                  end
+                end
+                if remaining0 <= 0
+                  address7 = TreeNode.new(@input[index4...@offset], index4, elements2)
+                  @offset = @offset
+                else
+                  address7 = FAILURE
+                end
+                unless address7 == FAILURE
+                  elements1 << address7
+                else
+                  elements1 = nil
+                  @offset = index3
+                end
+              else
+                elements1 = nil
+                @offset = index3
+              end
+            else
+              elements1 = nil
+              @offset = index3
+            end
+            if elements1.nil?
+              address4 = FAILURE
+            else
+              address4 = TreeNode12.new(@input[index3...@offset], index3, elements1)
+              @offset = @offset
+            end
+            if address4 == FAILURE
+              address4 = TreeNode.new(@input[index2...index2], index2, [])
+              @offset = index2
+            end
+            unless address4 == FAILURE
+              elements0 << address4
+              address13 = FAILURE
+              address13 = _read___
+              unless address13 == FAILURE
+                elements0 << address13
+                address14 = FAILURE
+                chunk2, max2 = nil, @offset + 1
+                if max2 <= @input_size
+                  chunk2 = @input[@offset...max2]
+                end
+                if chunk2 == "]"
+                  address14 = TreeNode.new(@input[@offset...@offset + 1], @offset, [])
+                  @offset = @offset + 1
+                else
+                  address14 = FAILURE
+                  if @offset > @failure
+                    @failure = @offset
+                    @expected = []
+                  end
+                  if @offset == @failure
+                    @expected << "\"]\""
+                  end
+                end
+                unless address14 == FAILURE
+                  elements0 << address14
+                  address15 = FAILURE
+                  address15 = _read___
+                  unless address15 == FAILURE
+                    elements0 << address15
+                  else
+                    elements0 = nil
+                    @offset = index1
+                  end
+                else
+                  elements0 = nil
+                  @offset = index1
+                end
+              else
+                elements0 = nil
+                @offset = index1
+              end
+            else
+              elements0 = nil
+              @offset = index1
+            end
+          else
+            elements0 = nil
+            @offset = index1
+          end
+        else
+          elements0 = nil
+          @offset = index1
+        end
+      else
+        elements0 = nil
+        @offset = index1
+      end
+      if elements0.nil?
+        address0 = FAILURE
+      else
+        address0 = @actions.make_list(@input, index1, @offset, elements0)
+        @offset = @offset
+      end
+      @cache[:list][index0] = [address0, @offset]
+      return address0
+    end
+
+    def _read_chr
+      address0, index0 = FAILURE, @offset
+      cached = @cache[:chr][index0]
+      if cached
+        @offset = cached[1]
+        return cached[0]
+      end
+      index1, elements0 = @offset, []
+      address1 = FAILURE
+      address1 = _read___
+      unless address1 == FAILURE
+        elements0 << address1
+        address2 = FAILURE
+        chunk0, max0 = nil, @offset + 1
+        if max0 <= @input_size
+          chunk0 = @input[@offset...max0]
+        end
+        if chunk0 =~ /\A[']/
+          address2 = TreeNode.new(@input[@offset...@offset + 1], @offset, [])
+          @offset = @offset + 1
+        else
+          address2 = FAILURE
+          if @offset > @failure
+            @failure = @offset
+            @expected = []
+          end
+          if @offset == @failure
+            @expected << "[']"
+          end
+        end
+        unless address2 == FAILURE
+          elements0 << address2
+          address3 = FAILURE
+          chunk1, max1 = nil, @offset + 1
+          if max1 <= @input_size
+            chunk1 = @input[@offset...max1]
+          end
+          if chunk1 =~ /\A[ !#-~]/
+            address3 = TreeNode.new(@input[@offset...@offset + 1], @offset, [])
+            @offset = @offset + 1
+          else
+            address3 = FAILURE
+            if @offset > @failure
+              @failure = @offset
+              @expected = []
+            end
+            if @offset == @failure
+              @expected << "[ !#-~]"
+            end
+          end
+          unless address3 == FAILURE
+            elements0 << address3
+            address4 = FAILURE
+            chunk2, max2 = nil, @offset + 1
+            if max2 <= @input_size
+              chunk2 = @input[@offset...max2]
+            end
+            if chunk2 =~ /\A[']/
+              address4 = TreeNode.new(@input[@offset...@offset + 1], @offset, [])
+              @offset = @offset + 1
+            else
+              address4 = FAILURE
+              if @offset > @failure
+                @failure = @offset
+                @expected = []
+              end
+              if @offset == @failure
+                @expected << "[']"
+              end
+            end
+            unless address4 == FAILURE
+              elements0 << address4
+              address5 = FAILURE
+              address5 = _read___
+              unless address5 == FAILURE
+                elements0 << address5
+              else
+                elements0 = nil
+                @offset = index1
+              end
+            else
+              elements0 = nil
+              @offset = index1
+            end
+          else
+            elements0 = nil
+            @offset = index1
+          end
+        else
+          elements0 = nil
+          @offset = index1
+        end
+      else
+        elements0 = nil
+        @offset = index1
+      end
+      if elements0.nil?
+        address0 = FAILURE
+      else
+        address0 = @actions.make_char(@input, index1, @offset, elements0)
+        @offset = @offset
+      end
+      @cache[:chr][index0] = [address0, @offset]
+      return address0
+    end
+
+    def _read_number
+      address0, index0 = FAILURE, @offset
+      cached = @cache[:number][index0]
+      if cached
+        @offset = cached[1]
+        return cached[0]
+      end
+      index1, elements0 = @offset, []
+      address1 = FAILURE
+      address1 = _read___
+      unless address1 == FAILURE
+        elements0 << address1
+        address2 = FAILURE
+        index2 = @offset
+        chunk0, max0 = nil, @offset + 1
+        if max0 <= @input_size
+          chunk0 = @input[@offset...max0]
+        end
+        if chunk0 == "-"
+          address2 = TreeNode.new(@input[@offset...@offset + 1], @offset, [])
+          @offset = @offset + 1
+        else
+          address2 = FAILURE
+          if @offset > @failure
+            @failure = @offset
+            @expected = []
+          end
+          if @offset == @failure
+            @expected << "\"-\""
+          end
+        end
+        if address2 == FAILURE
+          address2 = TreeNode.new(@input[index2...index2], index2, [])
+          @offset = index2
+        end
+        unless address2 == FAILURE
+          elements0 << address2
+          address3 = FAILURE
+          remaining0, index3, elements1, address4 = 1, @offset, [], true
+          until address4 == FAILURE
+            chunk1, max1 = nil, @offset + 1
+            if max1 <= @input_size
+              chunk1 = @input[@offset...max1]
+            end
+            if chunk1 =~ /\A[0-9]/
+              address4 = TreeNode.new(@input[@offset...@offset + 1], @offset, [])
+              @offset = @offset + 1
+            else
+              address4 = FAILURE
+              if @offset > @failure
+                @failure = @offset
+                @expected = []
+              end
+              if @offset == @failure
+                @expected << "[0-9]"
+              end
+            end
+            unless address4 == FAILURE
+              elements1 << address4
+              remaining0 -= 1
+            end
+          end
+          if remaining0 <= 0
+            address3 = TreeNode.new(@input[index3...@offset], index3, elements1)
+            @offset = @offset
+          else
+            address3 = FAILURE
+          end
+          unless address3 == FAILURE
+            elements0 << address3
+            address5 = FAILURE
+            address5 = _read___
+            unless address5 == FAILURE
+              elements0 << address5
+            else
+              elements0 = nil
+              @offset = index1
+            end
+          else
+            elements0 = nil
+            @offset = index1
+          end
+        else
+          elements0 = nil
+          @offset = index1
+        end
+      else
+        elements0 = nil
+        @offset = index1
+      end
+      if elements0.nil?
+        address0 = FAILURE
+      else
+        address0 = @actions.make_number(@input, index1, @offset, elements0)
+        @offset = @offset
+      end
+      @cache[:number][index0] = [address0, @offset]
+      return address0
+    end
+
+    def _read_float_
+      address0, index0 = FAILURE, @offset
+      cached = @cache[:float_][index0]
+      if cached
+        @offset = cached[1]
+        return cached[0]
+      end
+      index1, elements0 = @offset, []
+      address1 = FAILURE
+      address1 = _read___
+      unless address1 == FAILURE
+        elements0 << address1
+        address2 = FAILURE
+        index2 = @offset
+        chunk0, max0 = nil, @offset + 1
+        if max0 <= @input_size
+          chunk0 = @input[@offset...max0]
+        end
+        if chunk0 == "-"
+          address2 = TreeNode.new(@input[@offset...@offset + 1], @offset, [])
+          @offset = @offset + 1
+        else
+          address2 = FAILURE
+          if @offset > @failure
+            @failure = @offset
+            @expected = []
+          end
+          if @offset == @failure
+            @expected << "\"-\""
+          end
+        end
+        if address2 == FAILURE
+          address2 = TreeNode.new(@input[index2...index2], index2, [])
+          @offset = index2
+        end
+        unless address2 == FAILURE
+          elements0 << address2
+          address3 = FAILURE
+          remaining0, index3, elements1, address4 = 1, @offset, [], true
+          until address4 == FAILURE
+            chunk1, max1 = nil, @offset + 1
+            if max1 <= @input_size
+              chunk1 = @input[@offset...max1]
+            end
+            if chunk1 =~ /\A[0-9]/
+              address4 = TreeNode.new(@input[@offset...@offset + 1], @offset, [])
+              @offset = @offset + 1
+            else
+              address4 = FAILURE
+              if @offset > @failure
+                @failure = @offset
+                @expected = []
+              end
+              if @offset == @failure
+                @expected << "[0-9]"
+              end
+            end
+            unless address4 == FAILURE
+              elements1 << address4
+              remaining0 -= 1
+            end
+          end
+          if remaining0 <= 0
+            address3 = TreeNode.new(@input[index3...@offset], index3, elements1)
+            @offset = @offset
+          else
+            address3 = FAILURE
+          end
+          unless address3 == FAILURE
+            elements0 << address3
+            address5 = FAILURE
+            chunk2, max2 = nil, @offset + 1
+            if max2 <= @input_size
+              chunk2 = @input[@offset...max2]
+            end
+            if chunk2 == "."
+              address5 = TreeNode.new(@input[@offset...@offset + 1], @offset, [])
+              @offset = @offset + 1
+            else
+              address5 = FAILURE
+              if @offset > @failure
+                @failure = @offset
+                @expected = []
+              end
+              if @offset == @failure
+                @expected << "\".\""
+              end
+            end
+            unless address5 == FAILURE
+              elements0 << address5
+              address6 = FAILURE
+              remaining1, index4, elements2, address7 = 1, @offset, [], true
+              until address7 == FAILURE
+                chunk3, max3 = nil, @offset + 1
+                if max3 <= @input_size
+                  chunk3 = @input[@offset...max3]
+                end
+                if chunk3 =~ /\A[0-9]/
+                  address7 = TreeNode.new(@input[@offset...@offset + 1], @offset, [])
+                  @offset = @offset + 1
+                else
+                  address7 = FAILURE
+                  if @offset > @failure
+                    @failure = @offset
+                    @expected = []
+                  end
+                  if @offset == @failure
+                    @expected << "[0-9]"
+                  end
+                end
+                unless address7 == FAILURE
+                  elements2 << address7
+                  remaining1 -= 1
+                end
+              end
+              if remaining1 <= 0
+                address6 = TreeNode.new(@input[index4...@offset], index4, elements2)
+                @offset = @offset
+              else
+                address6 = FAILURE
+              end
+              unless address6 == FAILURE
+                elements0 << address6
+                address8 = FAILURE
+                address8 = _read___
+                unless address8 == FAILURE
+                  elements0 << address8
+                else
+                  elements0 = nil
+                  @offset = index1
+                end
+              else
+                elements0 = nil
+                @offset = index1
+              end
+            else
+              elements0 = nil
+              @offset = index1
+            end
+          else
+            elements0 = nil
+            @offset = index1
+          end
+        else
+          elements0 = nil
+          @offset = index1
+        end
+      else
+        elements0 = nil
+        @offset = index1
+      end
+      if elements0.nil?
+        address0 = FAILURE
+      else
+        address0 = @actions.make_float(@input, index1, @offset, elements0)
+        @offset = @offset
+      end
+      @cache[:float_][index0] = [address0, @offset]
+      return address0
+    end
+
+    def _read_boolean_
+      address0, index0 = FAILURE, @offset
+      cached = @cache[:boolean_][index0]
+      if cached
+        @offset = cached[1]
+        return cached[0]
+      end
+      index1, elements0 = @offset, []
+      address1 = FAILURE
+      address1 = _read___
+      unless address1 == FAILURE
+        elements0 << address1
+        address2 = FAILURE
+        index2 = @offset
+        chunk0, max0 = nil, @offset + 4
+        if max0 <= @input_size
+          chunk0 = @input[@offset...max0]
+        end
+        if chunk0 == "True"
+          address2 = TreeNode.new(@input[@offset...@offset + 4], @offset, [])
+          @offset = @offset + 4
+        else
+          address2 = FAILURE
+          if @offset > @failure
+            @failure = @offset
+            @expected = []
+          end
+          if @offset == @failure
+            @expected << "\"True\""
+          end
+        end
+        if address2 == FAILURE
+          @offset = index2
+          chunk1, max1 = nil, @offset + 4
+          if max1 <= @input_size
+            chunk1 = @input[@offset...max1]
+          end
+          if chunk1 == "true"
+            address2 = TreeNode.new(@input[@offset...@offset + 4], @offset, [])
+            @offset = @offset + 4
+          else
+            address2 = FAILURE
+            if @offset > @failure
+              @failure = @offset
+              @expected = []
+            end
+            if @offset == @failure
+              @expected << "\"true\""
+            end
+          end
+          if address2 == FAILURE
+            @offset = index2
+            chunk2, max2 = nil, @offset + 5
+            if max2 <= @input_size
+              chunk2 = @input[@offset...max2]
+            end
+            if chunk2 == "False"
+              address2 = TreeNode.new(@input[@offset...@offset + 5], @offset, [])
+              @offset = @offset + 5
+            else
+              address2 = FAILURE
+              if @offset > @failure
+                @failure = @offset
+                @expected = []
+              end
+              if @offset == @failure
+                @expected << "\"False\""
+              end
+            end
+            if address2 == FAILURE
+              @offset = index2
+              chunk3, max3 = nil, @offset + 5
+              if max3 <= @input_size
+                chunk3 = @input[@offset...max3]
+              end
+              if chunk3 == "false"
+                address2 = TreeNode.new(@input[@offset...@offset + 5], @offset, [])
+                @offset = @offset + 5
+              else
+                address2 = FAILURE
+                if @offset > @failure
+                  @failure = @offset
+                  @expected = []
+                end
+                if @offset == @failure
+                  @expected << "\"false\""
+                end
+              end
+              if address2 == FAILURE
+                @offset = index2
+              end
+            end
+          end
+        end
+        unless address2 == FAILURE
+          elements0 << address2
+          address3 = FAILURE
+          address3 = _read___
+          unless address3 == FAILURE
+            elements0 << address3
+          else
+            elements0 = nil
+            @offset = index1
+          end
+        else
+          elements0 = nil
+          @offset = index1
+        end
+      else
+        elements0 = nil
+        @offset = index1
+      end
+      if elements0.nil?
+        address0 = FAILURE
+      else
+        address0 = @actions.make_bool(@input, index1, @offset, elements0)
+        @offset = @offset
+      end
+      @cache[:boolean_][index0] = [address0, @offset]
+      return address0
+    end
+
+    def _read_null_
+      address0, index0 = FAILURE, @offset
+      cached = @cache[:null_][index0]
+      if cached
+        @offset = cached[1]
+        return cached[0]
+      end
+      index1, elements0 = @offset, []
+      address1 = FAILURE
+      address1 = _read___
+      unless address1 == FAILURE
+        elements0 << address1
+        address2 = FAILURE
+        index2 = @offset
+        chunk0, max0 = nil, @offset + 4
+        if max0 <= @input_size
+          chunk0 = @input[@offset...max0]
+        end
+        if chunk0 == "None"
+          address2 = TreeNode.new(@input[@offset...@offset + 4], @offset, [])
+          @offset = @offset + 4
+        else
+          address2 = FAILURE
+          if @offset > @failure
+            @failure = @offset
+            @expected = []
+          end
+          if @offset == @failure
+            @expected << "\"None\""
+          end
+        end
+        if address2 == FAILURE
+          @offset = index2
+          chunk1, max1 = nil, @offset + 3
+          if max1 <= @input_size
+            chunk1 = @input[@offset...max1]
+          end
+          if chunk1 == "nil"
+            address2 = TreeNode.new(@input[@offset...@offset + 3], @offset, [])
+            @offset = @offset + 3
+          else
+            address2 = FAILURE
+            if @offset > @failure
+              @failure = @offset
+              @expected = []
+            end
+            if @offset == @failure
+              @expected << "\"nil\""
+            end
+          end
+          if address2 == FAILURE
+            @offset = index2
+            chunk2, max2 = nil, @offset + 4
+            if max2 <= @input_size
+              chunk2 = @input[@offset...max2]
+            end
+            if chunk2 == "null"
+              address2 = TreeNode.new(@input[@offset...@offset + 4], @offset, [])
+              @offset = @offset + 4
+            else
+              address2 = FAILURE
+              if @offset > @failure
+                @failure = @offset
+                @expected = []
+              end
+              if @offset == @failure
+                @expected << "\"null\""
+              end
+            end
+            if address2 == FAILURE
+              @offset = index2
+            end
+          end
+        end
+        unless address2 == FAILURE
+          elements0 << address2
+          address3 = FAILURE
+          address3 = _read___
+          unless address3 == FAILURE
+            elements0 << address3
+          else
+            elements0 = nil
+            @offset = index1
+          end
+        else
+          elements0 = nil
+          @offset = index1
+        end
+      else
+        elements0 = nil
+        @offset = index1
+      end
+      if elements0.nil?
+        address0 = FAILURE
+      else
+        address0 = @actions.make_null(@input, index1, @offset, elements0)
+        @offset = @offset
+      end
+      @cache[:null_][index0] = [address0, @offset]
+      return address0
+    end
+
+    def _read_undefined_
+      address0, index0 = FAILURE, @offset
+      cached = @cache[:undefined_][index0]
+      if cached
+        @offset = cached[1]
+        return cached[0]
+      end
+      index1, elements0 = @offset, []
+      address1 = FAILURE
+      address1 = _read___
+      unless address1 == FAILURE
+        elements0 << address1
+        address2 = FAILURE
+        chunk0, max0 = nil, @offset + 9
+        if max0 <= @input_size
+          chunk0 = @input[@offset...max0]
+        end
+        if chunk0 == "undefined"
+          address2 = TreeNode.new(@input[@offset...@offset + 9], @offset, [])
+          @offset = @offset + 9
+        else
+          address2 = FAILURE
+          if @offset > @failure
+            @failure = @offset
+            @expected = []
+          end
+          if @offset == @failure
+            @expected << "\"undefined\""
+          end
+        end
+        unless address2 == FAILURE
+          elements0 << address2
+          address3 = FAILURE
+          address3 = _read___
+          unless address3 == FAILURE
+            elements0 << address3
+          else
+            elements0 = nil
+            @offset = index1
+          end
+        else
+          elements0 = nil
+          @offset = index1
+        end
+      else
+        elements0 = nil
+        @offset = index1
+      end
+      if elements0.nil?
+        address0 = FAILURE
+      else
+        address0 = @actions.make_undefined(@input, index1, @offset, elements0)
+        @offset = @offset
+      end
+      @cache[:undefined_][index0] = [address0, @offset]
+      return address0
+    end
+
+    def _read_opt_
+      address0, index0 = FAILURE, @offset
+      cached = @cache[:opt_][index0]
+      if cached
+        @offset = cached[1]
+        return cached[0]
+      end
+      index1, elements0 = @offset, []
+      address1 = FAILURE
+      address1 = _read___
+      unless address1 == FAILURE
+        elements0 << address1
+        address2 = FAILURE
+        index2 = @offset
+        chunk0, max0 = nil, @offset + 1
+        if max0 <= @input_size
+          chunk0 = @input[@offset...max0]
+        end
+        if chunk0 == "+"
+          address2 = TreeNode.new(@input[@offset...@offset + 1], @offset, [])
+          @offset = @offset + 1
+        else
+          address2 = FAILURE
+          if @offset > @failure
+            @failure = @offset
+            @expected = []
+          end
+          if @offset == @failure
+            @expected << "\"+\""
+          end
+        end
+        if address2 == FAILURE
+          @offset = index2
+          chunk1, max1 = nil, @offset + 1
+          if max1 <= @input_size
+            chunk1 = @input[@offset...max1]
+          end
+          if chunk1 == "-"
+            address2 = TreeNode.new(@input[@offset...@offset + 1], @offset, [])
+            @offset = @offset + 1
+          else
+            address2 = FAILURE
+            if @offset > @failure
+              @failure = @offset
+              @expected = []
+            end
+            if @offset == @failure
+              @expected << "\"-\""
+            end
+          end
+          if address2 == FAILURE
+            @offset = index2
+            chunk2, max2 = nil, @offset + 1
+            if max2 <= @input_size
+              chunk2 = @input[@offset...max2]
+            end
+            if chunk2 == "*"
+              address2 = TreeNode.new(@input[@offset...@offset + 1], @offset, [])
+              @offset = @offset + 1
+            else
+              address2 = FAILURE
+              if @offset > @failure
+                @failure = @offset
+                @expected = []
+              end
+              if @offset == @failure
+                @expected << "\"*\""
+              end
+            end
+            if address2 == FAILURE
+              @offset = index2
+              chunk3, max3 = nil, @offset + 1
+              if max3 <= @input_size
+                chunk3 = @input[@offset...max3]
+              end
+              if chunk3 == "/"
+                address2 = TreeNode.new(@input[@offset...@offset + 1], @offset, [])
+                @offset = @offset + 1
+              else
+                address2 = FAILURE
+                if @offset > @failure
+                  @failure = @offset
+                  @expected = []
+                end
+                if @offset == @failure
+                  @expected << "\"/\""
+                end
+              end
+              if address2 == FAILURE
+                @offset = index2
+                chunk4, max4 = nil, @offset + 2
+                if max4 <= @input_size
+                  chunk4 = @input[@offset...max4]
+                end
+                if chunk4 == "<="
+                  address2 = TreeNode.new(@input[@offset...@offset + 2], @offset, [])
+                  @offset = @offset + 2
+                else
+                  address2 = FAILURE
+                  if @offset > @failure
+                    @failure = @offset
+                    @expected = []
+                  end
+                  if @offset == @failure
+                    @expected << "\"<=\""
+                  end
+                end
+                if address2 == FAILURE
+                  @offset = index2
+                  chunk5, max5 = nil, @offset + 2
+                  if max5 <= @input_size
+                    chunk5 = @input[@offset...max5]
+                  end
+                  if chunk5 == ">="
+                    address2 = TreeNode.new(@input[@offset...@offset + 2], @offset, [])
+                    @offset = @offset + 2
+                  else
+                    address2 = FAILURE
+                    if @offset > @failure
+                      @failure = @offset
+                      @expected = []
+                    end
+                    if @offset == @failure
+                      @expected << "\">=\""
+                    end
+                  end
+                  if address2 == FAILURE
+                    @offset = index2
+                    chunk6, max6 = nil, @offset + 2
+                    if max6 <= @input_size
+                      chunk6 = @input[@offset...max6]
+                    end
+                    if chunk6 == "!="
+                      address2 = TreeNode.new(@input[@offset...@offset + 2], @offset, [])
+                      @offset = @offset + 2
+                    else
+                      address2 = FAILURE
+                      if @offset > @failure
+                        @failure = @offset
+                        @expected = []
+                      end
+                      if @offset == @failure
+                        @expected << "\"!=\""
+                      end
+                    end
+                    if address2 == FAILURE
+                      @offset = index2
+                      chunk7, max7 = nil, @offset + 2
+                      if max7 <= @input_size
+                        chunk7 = @input[@offset...max7]
+                      end
+                      if chunk7 == "=="
+                        address2 = TreeNode.new(@input[@offset...@offset + 2], @offset, [])
+                        @offset = @offset + 2
+                      else
+                        address2 = FAILURE
+                        if @offset > @failure
+                          @failure = @offset
+                          @expected = []
+                        end
+                        if @offset == @failure
+                          @expected << "\"==\""
+                        end
+                      end
+                      if address2 == FAILURE
+                        @offset = index2
+                        chunk8, max8 = nil, @offset + 1
+                        if max8 <= @input_size
+                          chunk8 = @input[@offset...max8]
+                        end
+                        if chunk8 == "="
+                          address2 = TreeNode.new(@input[@offset...@offset + 1], @offset, [])
+                          @offset = @offset + 1
+                        else
+                          address2 = FAILURE
+                          if @offset > @failure
+                            @failure = @offset
+                            @expected = []
+                          end
+                          if @offset == @failure
+                            @expected << "\"=\""
+                          end
+                        end
+                        if address2 == FAILURE
+                          @offset = index2
+                          chunk9, max9 = nil, @offset + 1
+                          if max9 <= @input_size
+                            chunk9 = @input[@offset...max9]
+                          end
+                          if chunk9 == ">"
+                            address2 = TreeNode.new(@input[@offset...@offset + 1], @offset, [])
+                            @offset = @offset + 1
+                          else
+                            address2 = FAILURE
+                            if @offset > @failure
+                              @failure = @offset
+                              @expected = []
+                            end
+                            if @offset == @failure
+                              @expected << "\">\""
+                            end
+                          end
+                          if address2 == FAILURE
+                            @offset = index2
+                            chunk10, max10 = nil, @offset + 1
+                            if max10 <= @input_size
+                              chunk10 = @input[@offset...max10]
+                            end
+                            if chunk10 == "<"
+                              address2 = TreeNode.new(@input[@offset...@offset + 1], @offset, [])
+                              @offset = @offset + 1
+                            else
+                              address2 = FAILURE
+                              if @offset > @failure
+                                @failure = @offset
+                                @expected = []
+                              end
+                              if @offset == @failure
+                                @expected << "\"<\""
+                              end
+                            end
+                            if address2 == FAILURE
+                              @offset = index2
+                              chunk11, max11 = nil, @offset + 2
+                              if max11 <= @input_size
+                                chunk11 = @input[@offset...max11]
+                              end
+                              if chunk11 == "LT"
+                                address2 = TreeNode.new(@input[@offset...@offset + 2], @offset, [])
+                                @offset = @offset + 2
+                              else
+                                address2 = FAILURE
+                                if @offset > @failure
+                                  @failure = @offset
+                                  @expected = []
+                                end
+                                if @offset == @failure
+                                  @expected << "\"LT\""
+                                end
+                              end
+                              if address2 == FAILURE
+                                @offset = index2
+                                chunk12, max12 = nil, @offset + 2
+                                if max12 <= @input_size
+                                  chunk12 = @input[@offset...max12]
+                                end
+                                if chunk12 == "GT"
+                                  address2 = TreeNode.new(@input[@offset...@offset + 2], @offset, [])
+                                  @offset = @offset + 2
+                                else
+                                  address2 = FAILURE
+                                  if @offset > @failure
+                                    @failure = @offset
+                                    @expected = []
+                                  end
+                                  if @offset == @failure
+                                    @expected << "\"GT\""
+                                  end
+                                end
+                                if address2 == FAILURE
+                                  @offset = index2
+                                  chunk13, max13 = nil, @offset + 2
+                                  if max13 <= @input_size
+                                    chunk13 = @input[@offset...max13]
+                                  end
+                                  if chunk13 == "LE"
+                                    address2 = TreeNode.new(@input[@offset...@offset + 2], @offset, [])
+                                    @offset = @offset + 2
+                                  else
+                                    address2 = FAILURE
+                                    if @offset > @failure
+                                      @failure = @offset
+                                      @expected = []
+                                    end
+                                    if @offset == @failure
+                                      @expected << "\"LE\""
+                                    end
+                                  end
+                                  if address2 == FAILURE
+                                    @offset = index2
+                                    chunk14, max14 = nil, @offset + 2
+                                    if max14 <= @input_size
+                                      chunk14 = @input[@offset...max14]
+                                    end
+                                    if chunk14 == "GE"
+                                      address2 = TreeNode.new(@input[@offset...@offset + 2], @offset, [])
+                                      @offset = @offset + 2
+                                    else
+                                      address2 = FAILURE
+                                      if @offset > @failure
+                                        @failure = @offset
+                                        @expected = []
+                                      end
+                                      if @offset == @failure
+                                        @expected << "\"GE\""
+                                      end
+                                    end
+                                    if address2 == FAILURE
+                                      @offset = index2
+                                      chunk15, max15 = nil, @offset + 2
+                                      if max15 <= @input_size
+                                        chunk15 = @input[@offset...max15]
+                                      end
+                                      if chunk15 == "EQ"
+                                        address2 = TreeNode.new(@input[@offset...@offset + 2], @offset, [])
+                                        @offset = @offset + 2
+                                      else
+                                        address2 = FAILURE
+                                        if @offset > @failure
+                                          @failure = @offset
+                                          @expected = []
+                                        end
+                                        if @offset == @failure
+                                          @expected << "\"EQ\""
+                                        end
+                                      end
+                                      if address2 == FAILURE
+                                        @offset = index2
+                                        chunk16, max16 = nil, @offset + 2
+                                        if max16 <= @input_size
+                                          chunk16 = @input[@offset...max16]
+                                        end
+                                        if chunk16 == "NE"
+                                          address2 = TreeNode.new(@input[@offset...@offset + 2], @offset, [])
+                                          @offset = @offset + 2
+                                        else
+                                          address2 = FAILURE
+                                          if @offset > @failure
+                                            @failure = @offset
+                                            @expected = []
+                                          end
+                                          if @offset == @failure
+                                            @expected << "\"NE\""
+                                          end
+                                        end
+                                        if address2 == FAILURE
+                                          @offset = index2
+                                          chunk17, max17 = nil, @offset + 2
+                                          if max17 <= @input_size
+                                            chunk17 = @input[@offset...max17]
+                                          end
+                                          if chunk17 == "lt"
+                                            address2 = TreeNode.new(@input[@offset...@offset + 2], @offset, [])
+                                            @offset = @offset + 2
+                                          else
+                                            address2 = FAILURE
+                                            if @offset > @failure
+                                              @failure = @offset
+                                              @expected = []
+                                            end
+                                            if @offset == @failure
+                                              @expected << "\"lt\""
+                                            end
+                                          end
+                                          if address2 == FAILURE
+                                            @offset = index2
+                                            chunk18, max18 = nil, @offset + 2
+                                            if max18 <= @input_size
+                                              chunk18 = @input[@offset...max18]
+                                            end
+                                            if chunk18 == "gt"
+                                              address2 = TreeNode.new(@input[@offset...@offset + 2], @offset, [])
+                                              @offset = @offset + 2
+                                            else
+                                              address2 = FAILURE
+                                              if @offset > @failure
+                                                @failure = @offset
+                                                @expected = []
+                                              end
+                                              if @offset == @failure
+                                                @expected << "\"gt\""
+                                              end
+                                            end
+                                            if address2 == FAILURE
+                                              @offset = index2
+                                              chunk19, max19 = nil, @offset + 2
+                                              if max19 <= @input_size
+                                                chunk19 = @input[@offset...max19]
+                                              end
+                                              if chunk19 == "le"
+                                                address2 = TreeNode.new(@input[@offset...@offset + 2], @offset, [])
+                                                @offset = @offset + 2
+                                              else
+                                                address2 = FAILURE
+                                                if @offset > @failure
+                                                  @failure = @offset
+                                                  @expected = []
+                                                end
+                                                if @offset == @failure
+                                                  @expected << "\"le\""
+                                                end
+                                              end
+                                              if address2 == FAILURE
+                                                @offset = index2
+                                                chunk20, max20 = nil, @offset + 2
+                                                if max20 <= @input_size
+                                                  chunk20 = @input[@offset...max20]
+                                                end
+                                                if chunk20 == "ge"
+                                                  address2 = TreeNode.new(@input[@offset...@offset + 2], @offset, [])
+                                                  @offset = @offset + 2
+                                                else
+                                                  address2 = FAILURE
+                                                  if @offset > @failure
+                                                    @failure = @offset
+                                                    @expected = []
+                                                  end
+                                                  if @offset == @failure
+                                                    @expected << "\"ge\""
+                                                  end
+                                                end
+                                                if address2 == FAILURE
+                                                  @offset = index2
+                                                  chunk21, max21 = nil, @offset + 2
+                                                  if max21 <= @input_size
+                                                    chunk21 = @input[@offset...max21]
+                                                  end
+                                                  if chunk21 == "eq"
+                                                    address2 = TreeNode.new(@input[@offset...@offset + 2], @offset, [])
+                                                    @offset = @offset + 2
+                                                  else
+                                                    address2 = FAILURE
+                                                    if @offset > @failure
+                                                      @failure = @offset
+                                                      @expected = []
+                                                    end
+                                                    if @offset == @failure
+                                                      @expected << "\"eq\""
+                                                    end
+                                                  end
+                                                  if address2 == FAILURE
+                                                    @offset = index2
+                                                    chunk22, max22 = nil, @offset + 2
+                                                    if max22 <= @input_size
+                                                      chunk22 = @input[@offset...max22]
+                                                    end
+                                                    if chunk22 == "ne"
+                                                      address2 = TreeNode.new(@input[@offset...@offset + 2], @offset, [])
+                                                      @offset = @offset + 2
+                                                    else
+                                                      address2 = FAILURE
+                                                      if @offset > @failure
+                                                        @failure = @offset
+                                                        @expected = []
+                                                      end
+                                                      if @offset == @failure
+                                                        @expected << "\"ne\""
+                                                      end
+                                                    end
+                                                    if address2 == FAILURE
+                                                      @offset = index2
+                                                      chunk23, max23 = nil, @offset + 2
+                                                      if max23 <= @input_size
+                                                        chunk23 = @input[@offset...max23]
+                                                      end
+                                                      if chunk23 == "in"
+                                                        address2 = TreeNode.new(@input[@offset...@offset + 2], @offset, [])
+                                                        @offset = @offset + 2
+                                                      else
+                                                        address2 = FAILURE
+                                                        if @offset > @failure
+                                                          @failure = @offset
+                                                          @expected = []
+                                                        end
+                                                        if @offset == @failure
+                                                          @expected << "\"in\""
+                                                        end
+                                                      end
+                                                      if address2 == FAILURE
+                                                        @offset = index2
+                                                        chunk24, max24 = nil, @offset + 2
+                                                        if max24 <= @input_size
+                                                          chunk24 = @input[@offset...max24]
+                                                        end
+                                                        if chunk24 == "IN"
+                                                          address2 = TreeNode.new(@input[@offset...@offset + 2], @offset, [])
+                                                          @offset = @offset + 2
+                                                        else
+                                                          address2 = FAILURE
+                                                          if @offset > @failure
+                                                            @failure = @offset
+                                                            @expected = []
+                                                          end
+                                                          if @offset == @failure
+                                                            @expected << "\"IN\""
+                                                          end
+                                                        end
+                                                        if address2 == FAILURE
+                                                          @offset = index2
+                                                          chunk25, max25 = nil, @offset + 2
+                                                          if max25 <= @input_size
+                                                            chunk25 = @input[@offset...max25]
+                                                          end
+                                                          if chunk25 == "or"
+                                                            address2 = TreeNode.new(@input[@offset...@offset + 2], @offset, [])
+                                                            @offset = @offset + 2
+                                                          else
+                                                            address2 = FAILURE
+                                                            if @offset > @failure
+                                                              @failure = @offset
+                                                              @expected = []
+                                                            end
+                                                            if @offset == @failure
+                                                              @expected << "\"or\""
+                                                            end
+                                                          end
+                                                          if address2 == FAILURE
+                                                            @offset = index2
+                                                            chunk26, max26 = nil, @offset + 2
+                                                            if max26 <= @input_size
+                                                              chunk26 = @input[@offset...max26]
+                                                            end
+                                                            if chunk26 == "OR"
+                                                              address2 = TreeNode.new(@input[@offset...@offset + 2], @offset, [])
+                                                              @offset = @offset + 2
+                                                            else
+                                                              address2 = FAILURE
+                                                              if @offset > @failure
+                                                                @failure = @offset
+                                                                @expected = []
+                                                              end
+                                                              if @offset == @failure
+                                                                @expected << "\"OR\""
+                                                              end
+                                                            end
+                                                            if address2 == FAILURE
+                                                              @offset = index2
+                                                              chunk27, max27 = nil, @offset + 2
+                                                              if max27 <= @input_size
+                                                                chunk27 = @input[@offset...max27]
+                                                              end
+                                                              if chunk27 == "||"
+                                                                address2 = TreeNode.new(@input[@offset...@offset + 2], @offset, [])
+                                                                @offset = @offset + 2
+                                                              else
+                                                                address2 = FAILURE
+                                                                if @offset > @failure
+                                                                  @failure = @offset
+                                                                  @expected = []
+                                                                end
+                                                                if @offset == @failure
+                                                                  @expected << "\"||\""
+                                                                end
+                                                              end
+                                                              if address2 == FAILURE
+                                                                @offset = index2
+                                                                chunk28, max28 = nil, @offset + 3
+                                                                if max28 <= @input_size
+                                                                  chunk28 = @input[@offset...max28]
+                                                                end
+                                                                if chunk28 == "and"
+                                                                  address2 = TreeNode.new(@input[@offset...@offset + 3], @offset, [])
+                                                                  @offset = @offset + 3
+                                                                else
+                                                                  address2 = FAILURE
+                                                                  if @offset > @failure
+                                                                    @failure = @offset
+                                                                    @expected = []
+                                                                  end
+                                                                  if @offset == @failure
+                                                                    @expected << "\"and\""
+                                                                  end
+                                                                end
+                                                                if address2 == FAILURE
+                                                                  @offset = index2
+                                                                  chunk29, max29 = nil, @offset + 3
+                                                                  if max29 <= @input_size
+                                                                    chunk29 = @input[@offset...max29]
+                                                                  end
+                                                                  if chunk29 == "AND"
+                                                                    address2 = TreeNode.new(@input[@offset...@offset + 3], @offset, [])
+                                                                    @offset = @offset + 3
+                                                                  else
+                                                                    address2 = FAILURE
+                                                                    if @offset > @failure
+                                                                      @failure = @offset
+                                                                      @expected = []
+                                                                    end
+                                                                    if @offset == @failure
+                                                                      @expected << "\"AND\""
+                                                                    end
+                                                                  end
+                                                                  if address2 == FAILURE
+                                                                    @offset = index2
+                                                                    chunk30, max30 = nil, @offset + 2
+                                                                    if max30 <= @input_size
+                                                                      chunk30 = @input[@offset...max30]
+                                                                    end
+                                                                    if chunk30 == "&&"
+                                                                      address2 = TreeNode.new(@input[@offset...@offset + 2], @offset, [])
+                                                                      @offset = @offset + 2
+                                                                    else
+                                                                      address2 = FAILURE
+                                                                      if @offset > @failure
+                                                                        @failure = @offset
+                                                                        @expected = []
+                                                                      end
+                                                                      if @offset == @failure
+                                                                        @expected << "\"&&\""
+                                                                      end
+                                                                    end
+                                                                    if address2 == FAILURE
+                                                                      @offset = index2
+                                                                    end
+                                                                  end
+                                                                end
+                                                              end
+                                                            end
+                                                          end
+                                                        end
+                                                      end
+                                                    end
+                                                  end
+                                                end
+                                              end
+                                            end
+                                          end
+                                        end
+                                      end
+                                    end
+                                  end
+                                end
+                              end
+                            end
+                          end
+                        end
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+        unless address2 == FAILURE
+          elements0 << address2
+          address3 = FAILURE
+          address3 = _read___
+          unless address3 == FAILURE
+            elements0 << address3
+          else
+            elements0 = nil
+            @offset = index1
+          end
+        else
+          elements0 = nil
+          @offset = index1
+        end
+      else
+        elements0 = nil
+        @offset = index1
+      end
+      if elements0.nil?
+        address0 = FAILURE
+      else
+        address0 = @actions.make_opt(@input, index1, @offset, elements0)
+        @offset = @offset
+      end
+      @cache[:opt_][index0] = [address0, @offset]
+      return address0
+    end
+
+    def _read___
+      address0, index0 = FAILURE, @offset
+      cached = @cache[:__][index0]
+      if cached
+        @offset = cached[1]
+        return cached[0]
+      end
+      remaining0, index1, elements0, address1 = 0, @offset, [], true
+      until address1 == FAILURE
+        chunk0, max0 = nil, @offset + 1
+        if max0 <= @input_size
+          chunk0 = @input[@offset...max0]
+        end
+        if chunk0 =~ /\A[\s]/
+          address1 = TreeNode.new(@input[@offset...@offset + 1], @offset, [])
+          @offset = @offset + 1
+        else
+          address1 = FAILURE
+          if @offset > @failure
+            @failure = @offset
+            @expected = []
+          end
+          if @offset == @failure
+            @expected << "[\\s]"
+          end
+        end
+        unless address1 == FAILURE
+          elements0 << address1
+          remaining0 -= 1
+        end
+      end
+      if remaining0 <= 0
+        address0 = TreeNode.new(@input[index1...@offset], index1, elements0)
+        @offset = @offset
+      else
+        address0 = FAILURE
+      end
+      @cache[:__][index0] = [address0, @offset]
+      return address0
+    end
+  end
+
+  class Parser
+    include Grammar
+
+    def initialize(input, actions, types)
+      @input = input
+      @input_size = input.size
+      @actions = actions
+      @types = types
+      @offset = 0
+      @cache = Hash.new { |h,k| h[k] = {} }
+      @failure = 0
+      @expected = []
+    end
+
+    def parse
+      tree = _read_comp_expression
+      if tree != FAILURE and @offset == @input_size
+        return tree
+      end
+      if @expected.empty?
+        @failure = @offset
+        @expected << "<EOF>"
+      end
+      raise ParseError, Parser.format_error(@input, @failure, @expected)
+    end
+
+    def self.format_error(input, offset, expected)
+      lines, line_no, position = input.split(/\n/), 0, 0
+      while position <= offset
+        position += lines[line_no].size + 1
+        line_no += 1
+      end
+      message, line = "Line #{line_no}: expected #{expected * ", "}\n", lines[line_no - 1]
+      message += "#{line}\n"
+      position -= line.size + 1
+      message += " " * (offset - position)
+      return message + "^"
+    end
+  end
+
+  def self.parse(input, options = {})
+    parser = Parser.new(input, options[:actions], options[:types])
+    parser.parse
+  end
+end