myco 0.1.8 → 0.1.9

data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/Stream.my.rb

@@ -0,0 +1,152 @@
+
+::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.cscope.for_method_definition::Stream = ::Myco::Component.new([::Myco.find_constant(:EmptyObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  ::Myco.cscope.for_method_definition::Patterns = ::Myco::Component.new([::Myco.find_constant(:EmptyObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+    ::Myco.cscope.for_method_definition::Base = ::Myco::Component.new([::Myco.find_constant(:Common)::Patterns::Base], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}
+    .tap { |__c__| __c__.__name__ = :Base }
+    ::Myco.cscope.for_method_definition::End = ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:construct, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Constructions)::End.new)})}}
+    .tap { |__c__| __c__.__name__ = :End }
+    ::Myco.cscope.for_method_definition::Item = ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+      declare_meme(:checks, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+      declare_meme(:construct, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Constructions)::Item.new({:checks => self.checks}))}
+    )}}
+    .tap { |__c__| __c__.__name__ = :Item }
+  )}}
+  .tap { |__c__| __c__.__name__ = :Patterns }
+  ::Myco.cscope.for_method_definition::Constructions = ::Myco::Component.new([::Myco.find_constant(:EmptyObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+    ::Myco.cscope.for_method_definition::Base = ::Myco::Component.new([::Myco.find_constant(:Common)::Constructions::Base], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}
+    .tap { |__c__| __c__.__name__ = :Base }
+    ::Myco.cscope.for_method_definition::End = ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}
+    .tap { |__c__| __c__.__name__ = :End }
+    ::Myco.cscope.for_method_definition::Item = ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:checks, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil})}}
+    .tap { |__c__| __c__.__name__ = :Item }
+  )}}
+  .tap { |__c__| __c__.__name__ = :Constructions }
+  ::Myco.find_constant(:Constructions).component_eval {(
+    ::Myco.find_constant(:End).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+      g.push_subject
+      g.send(
+        :size,
+        0
+      )
+      g.push_idx
+      g.send(
+        :>,
+        1
+      )
+      g.goto_if_true(g.overall_fail)
+    )})}
+    ::Myco.find_constant(:Item).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+      many_checks = self.checks.size.__send__(
+        :>,
+        1
+      )
+      local_fail = g.overall_fail
+      self.__send__(
+        :if,
+        many_checks
+      ) { || (local_fail = g.new_label)}
+      g.push_subject
+      g.send(
+        :size,
+        0
+      )
+      g.push_idx
+      g.send(
+        :>,
+        1
+      )
+      g.goto_if_false(g.overall_fail)
+      ::Myco.branch_op(:"||", self.checks.__send__(:empty?)) {(
+        g.push_subject_at_idx
+        self.checks.each { |method, args, result| (
+          self.__send__(
+            :if,
+            many_checks
+          ) { || (g.dup_top)}
+          ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", :self.__send__(
+            :equal?,
+            method
+          )) {nil}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", method.__send__(
+            :is_a?,
+            ::Myco.find_constant(:Symbol)
+          )) {(
+            args.each { |arg| (g.push_literal_or_array(arg))}
+            g.send(
+              method,
+              args.size
+            )
+          )}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", method.__send__(
+            :is_a?,
+            ::Myco.find_constant(:Proc)
+          )) {(
+            code = method.block.compiled_code
+            g.push_literal(code)
+            g.swap_stack
+            g.push_literal(code.name)
+            g.swap_stack
+            g.push_cpath_top
+            g.find_const(:Myco)
+            g.swap_stack
+            g.push_literal_array(args)
+            g.push_nil
+            g.send(
+              :invoke,
+              5
+            )
+          )}) {self.raise("Unknown type of check method: #{method}")}}}
+          ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", nil.__send__(
+            :equal?,
+            result
+          )) {g.goto_if_not_nil(local_fail)}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", ::Myco.branch_op(:"||", ::Myco.branch_op(:"||", ::Myco.branch_op(:"||", false.__send__(
+            :equal?,
+            result
+          )) {true.__send__(
+            :equal?,
+            result
+          )}) {result.__send__(
+            :is_a?,
+            ::Myco.find_constant(:Symbol)
+          )}) {result.__send__(
+            :is_a?,
+            ::Myco.find_constant(:Fixnum)
+          )}) {(
+            g.push_literal(result)
+            g.goto_if_not_equal(local_fail)
+          )}) {(
+            g.push_literal_or_array(result)
+            g.send(
+              :==,
+              1
+            )
+            g.goto_if_false(local_fail)
+          )}}
+        )}
+        self.__send__(
+          :if,
+          many_checks
+        ) { || (
+          local_done = g.new_label
+          g.pop
+          g.goto(local_done)
+          local_fail.__send__(:set!)
+          g.pop
+          g.goto(g.overall_fail)
+          local_done.__send__(:set!)
+        )}
+      )}
+      g.__send__(:meta_push_1)
+      g.increment_idx
+    )})}
+  )}
+)}}
+.tap { |__c__| __c__.__name__ = :Stream })}}.instance

data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/Stream/Parser.my

@@ -0,0 +1,37 @@
+
+Stream << {
+  Parser < Common::Parser {
+    State < Common::Parser::State {
+      var stream
+      
+      raise_error: self.error_idx && raise(SyntaxError
+        "Unexpected item with parser: "self.rule \
+          " at index: "self.error_idx \
+          ", item: "self.stream[self.error_idx].inspect""
+      )
+    }
+    
+    # Match and process the given stream using the current grammar
+    parse: |stream, rule:"root", start_idx:0| {
+      worker    = new_worker
+      processor = new_processor
+      state     = State.new(
+        stream:    stream
+        rule:      rule.to_sym
+        start_idx: start_idx.to_i
+      )
+      
+      state.end_idx = worker.__send__(state.rule, state.stream, state.start_idx)
+      
+      state.end_idx &? (
+        processor.string = state.stream
+        processor.capture_items = captures_of_worker(worker)
+        grammar.?tokenizer && (processor.tokenizer = grammar.tokenizer)
+        state.result = processor.process
+      ) ?? (
+        state.error_idx = highest_idx_of_worker(worker)
+      )
+      state
+    }
+  }
+}

data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/Stream/Parser.my.rb

@@ -0,0 +1,57 @@
+
+::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:Stream).component_eval {(::Myco.cscope.for_method_definition::Parser = ::Myco::Component.new([::Myco.find_constant(:Common)::Parser], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  ::Myco.cscope.for_method_definition::State = ::Myco::Component.new([::Myco.find_constant(:Common)::Parser::State], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+    declare_meme(:stream, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+    declare_meme(:raise_error, [], nil, ::Myco.cscope.dup) { |*| (::Myco.branch_op(:"&&", self.error_idx) {self.raise(
+      ::Myco.find_constant(:SyntaxError),
+      "Unexpected item with parser: #{self.rule} at index: #{self.error_idx}, item: #{self.stream.__send__(
+        :[],
+        self.error_idx
+      ).inspect}"
+    )})}
+  )}}
+  .tap { |__c__| __c__.__name__ = :State }
+  declare_meme(:parse, [], nil, ::Myco.cscope.dup) { |stream, rule:"root", start_idx:0| (
+    worker = self.new_worker
+    processor = self.new_processor
+    state = ::Myco.find_constant(:State).new({
+      :stream => stream,
+      :rule => rule.to_sym,
+      :start_idx => start_idx.to_i
+    })
+    state.__send__(
+      :end_idx=,
+      worker.__send__(
+        state.rule,
+        state.stream,
+        state.start_idx
+      )
+    )
+    ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", state.end_idx) {(
+      processor.__send__(
+        :string=,
+        state.stream
+      )
+      processor.__send__(
+        :capture_items=,
+        self.captures_of_worker(worker)
+      )
+      ::Myco.branch_op(:"&&", (Rubinius::Type.object_respond_to?(self.grammar, :tokenizer).false? ? ::Myco::Void : self.grammar.tokenizer)) {processor.__send__(
+        :tokenizer=,
+        self.grammar.tokenizer
+      )}
+      state.__send__(
+        :result=,
+        processor.process
+      )
+    )}) {state.__send__(
+      :error_idx=,
+      self.highest_idx_of_worker(worker)
+    )}
+    state
+  )}
+)}}
+.tap { |__c__| __c__.__name__ = :Parser })})}}.instance

data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/String.my

@@ -0,0 +1,136 @@
+
+String < EmptyObject {
+  Patterns < EmptyObject {
+    Base < Common::Patterns::Base { }
+    
+    AnyCharacter    < Base {
+      construct: Constructions::AnyCharacter.new
+    }
+    Character       < Base { var code
+      construct: Constructions::Character.new(code: code)
+    }
+    CharacterString < Base { var codes
+      construct: Constructions::CharacterString.new(codes: codes)
+    }
+    CharacterSet    < Base { var codes
+      construct: Constructions::CharacterSet.new(codes: codes)
+    }
+    CharacterRange  < Base { var start, var stop
+      construct: Constructions::CharacterRange.new(start: start, stop: stop)
+    }
+  }
+  
+  Constructions < EmptyObject {
+    Base < Common::Constructions::Base { }
+    
+    AnyCharacter    < Base { }
+    Character       < Base { var code }
+    CharacterString < Base { var codes }
+    CharacterSet    < Base { var codes }
+    CharacterRange  < Base { var start, var stop }
+  }
+  
+  Constructions << {
+    AnyCharacter << { bytecode: |g| {
+      ##
+      # overall_fail! if idx == subject.size
+      # idx = idx + 1
+      
+      g.push_idx
+        g.push_subject; g.send(:size, 0)
+      g.send(:"==", 1)
+      g.goto_if_true(g.overall_fail)
+      
+      g.meta_push_1
+      g.increment_idx
+    }}
+    
+    Character << { bytecode: |g| {
+      ##
+      # overall_fail! unless chr == subject[idx]
+      # idx = idx + 1
+      
+      g.push_literal(code.chr)
+        g.push_subject_chr_at_idx
+      g.send(:"==", 1)
+      g.goto_if_false(g.overall_fail)
+      
+      g.meta_push_1
+      g.increment_idx
+    }}
+    
+    # TODO: get rid of this ugly hack.
+    STRING_HACK_PATCH: Ruby.eval("
+      class ::String
+        def compare_substring_safe(*args)
+          compare_substring(*args)
+        rescue Exception
+          nil
+        end
+      end
+    ")
+    
+    CharacterString << { bytecode: |g| {
+      string = codes.map(&:chr).join
+      ##
+      # begin
+      #   overall_fail! unless string.compare_substring(subject, idx, string.size) == 0
+      # rescue
+      #   overall_fail!
+      # end
+      # idx = idx + string.size
+      
+      g.push_literal(string)
+        g.push_subject
+        g.push_idx
+        g.push_int(string.size)
+      g.send(:compare_substring_safe, 3)
+        g.meta_push_0
+      
+      g.goto_if_not_equal(g.overall_fail)
+      
+      g.push_int(string.size)
+      g.increment_idx
+    }}
+    
+    CharacterSet << { bytecode: |g| {
+      string = codes.map(&:chr).join
+      ##
+      # overall_fail! unless subject[idx]
+      # overall_fail! unless string.find_string(subject[idx], 0)
+      # idx = idx + 1
+      
+      g.push_subject_chr_at_idx
+      g.goto_if_nil(g.overall_fail) # TODO: avoid second lookup using register instructions
+      
+      g.push_literal(string)
+        g.push_subject_chr_at_idx
+        g.meta_push_0
+      g.send(:find_string, 2)
+      g.goto_if_false(g.overall_fail)
+      
+      g.meta_push_1
+      g.increment_idx
+    }}
+    
+    CharacterRange << { bytecode: |g| {
+      codes = Range.new(start,stop); string = codes.map(&:chr).join
+      ##
+      # overall_fail! unless subject[idx]
+      # overall_fail! unless string.find_string(subject[idx], 0)
+      # idx = idx + 1
+      
+      g.push_subject_chr_at_idx
+      g.goto_if_nil(g.overall_fail) # TODO: avoid second lookup using register instructions
+      
+      g.push_literal(string)
+        g.push_subject_chr_at_idx
+        g.meta_push_0
+      g.send(:find_string, 2)
+      g.goto_if_false(g.overall_fail)
+      
+      g.meta_push_1
+      g.increment_idx
+    }}
+  }
+}

data/lib/myco/code_tools/parser/pegleromyces/lib/pegleromyces/String.my.rb

@@ -0,0 +1,147 @@
+
+::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.cscope.for_method_definition::String = ::Myco::Component.new([::Myco.find_constant(:EmptyObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  ::Myco.cscope.for_method_definition::Patterns = ::Myco::Component.new([::Myco.find_constant(:EmptyObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+    ::Myco.cscope.for_method_definition::Base = ::Myco::Component.new([::Myco.find_constant(:Common)::Patterns::Base], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}
+    .tap { |__c__| __c__.__name__ = :Base }
+    ::Myco.cscope.for_method_definition::AnyCharacter = ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:construct, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Constructions)::AnyCharacter.new)})}}
+    .tap { |__c__| __c__.__name__ = :AnyCharacter }
+    ::Myco.cscope.for_method_definition::Character = ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+      declare_meme(:code, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+      declare_meme(:construct, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Constructions)::Character.new({:code => self.code}))}
+    )}}
+    .tap { |__c__| __c__.__name__ = :Character }
+    ::Myco.cscope.for_method_definition::CharacterString = ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+      declare_meme(:codes, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+      declare_meme(:construct, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Constructions)::CharacterString.new({:codes => self.codes}))}
+    )}}
+    .tap { |__c__| __c__.__name__ = :CharacterString }
+    ::Myco.cscope.for_method_definition::CharacterSet = ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+      declare_meme(:codes, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+      declare_meme(:construct, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Constructions)::CharacterSet.new({:codes => self.codes}))}
+    )}}
+    .tap { |__c__| __c__.__name__ = :CharacterSet }
+    ::Myco.cscope.for_method_definition::CharacterRange = ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+      declare_meme(:start, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+      declare_meme(:stop, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+      declare_meme(:construct, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Constructions)::CharacterRange.new({
+        :start => self.start,
+        :stop => self.stop
+      }))}
+    )}}
+    .tap { |__c__| __c__.__name__ = :CharacterRange }
+  )}}
+  .tap { |__c__| __c__.__name__ = :Patterns }
+  ::Myco.cscope.for_method_definition::Constructions = ::Myco::Component.new([::Myco.find_constant(:EmptyObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+    ::Myco.cscope.for_method_definition::Base = ::Myco::Component.new([::Myco.find_constant(:Common)::Constructions::Base], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}
+    .tap { |__c__| __c__.__name__ = :Base }
+    ::Myco.cscope.for_method_definition::AnyCharacter = ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}
+    .tap { |__c__| __c__.__name__ = :AnyCharacter }
+    ::Myco.cscope.for_method_definition::Character = ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:code, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil})}}
+    .tap { |__c__| __c__.__name__ = :Character }
+    ::Myco.cscope.for_method_definition::CharacterString = ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:codes, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil})}}
+    .tap { |__c__| __c__.__name__ = :CharacterString }
+    ::Myco.cscope.for_method_definition::CharacterSet = ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:codes, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil})}}
+    .tap { |__c__| __c__.__name__ = :CharacterSet }
+    ::Myco.cscope.for_method_definition::CharacterRange = ::Myco::Component.new([::Myco.find_constant(:Base)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+      declare_meme(:start, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+      declare_meme(:stop, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+    )}}
+    .tap { |__c__| __c__.__name__ = :CharacterRange }
+  )}}
+  .tap { |__c__| __c__.__name__ = :Constructions }
+  ::Myco.find_constant(:Constructions).component_eval {(
+    ::Myco.find_constant(:AnyCharacter).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+      g.push_idx
+      g.push_subject
+      g.send(
+        :size,
+        0
+      )
+      g.send(
+        :==,
+        1
+      )
+      g.goto_if_true(g.overall_fail)
+      g.__send__(:meta_push_1)
+      g.increment_idx
+    )})}
+    ::Myco.find_constant(:Character).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+      g.push_literal(self.code.chr)
+      g.push_subject_chr_at_idx
+      g.send(
+        :==,
+        1
+      )
+      g.goto_if_false(g.overall_fail)
+      g.__send__(:meta_push_1)
+      g.increment_idx
+    )})}
+    ::Myco.cscope.for_method_definition::STRING_HACK_PATCH = (::Myco.find_constant(:Ruby).eval("\n      class ::String\n        def compare_substring_safe(*args)\n          compare_substring(*args)\n        rescue Exception\n          nil\n        end\n      end\n    "))
+    ::Myco.find_constant(:CharacterString).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+      string = self.codes.map(&:chr).join
+      g.push_literal(string)
+      g.push_subject
+      g.push_idx
+      g.push_int(string.size)
+      g.send(
+        :compare_substring_safe,
+        3
+      )
+      g.__send__(:meta_push_0)
+      g.goto_if_not_equal(g.overall_fail)
+      g.push_int(string.size)
+      g.increment_idx
+    )})}
+    ::Myco.find_constant(:CharacterSet).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+      string = self.codes.map(&:chr).join
+      g.push_subject_chr_at_idx
+      g.goto_if_nil(g.overall_fail)
+      g.push_literal(string)
+      g.push_subject_chr_at_idx
+      g.__send__(:meta_push_0)
+      g.send(
+        :find_string,
+        2
+      )
+      g.goto_if_false(g.overall_fail)
+      g.__send__(:meta_push_1)
+      g.increment_idx
+    )})}
+    ::Myco.find_constant(:CharacterRange).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+      codes = ::Myco.find_constant(:Range).new(
+        self.start,
+        self.stop
+      )
+      string = codes.map(&:chr).join
+      g.push_subject_chr_at_idx
+      g.goto_if_nil(g.overall_fail)
+      g.push_literal(string)
+      g.push_subject_chr_at_idx
+      g.__send__(:meta_push_0)
+      g.send(
+        :find_string,
+        2
+      )
+      g.goto_if_false(g.overall_fail)
+      g.__send__(:meta_push_1)
+      g.increment_idx
+    )})}
+  )}
+)}}
+.tap { |__c__| __c__.__name__ = :String })}}.instance