myco 0.1.4 → 0.1.5

data/lib/myco/code_tools/parser/MycoTokens.my

@@ -0,0 +1,78 @@
+
+MycoTokens: Pegleromyces::Grammar {
+  C: MycoCharacterClasses
+  
+  [main]
+  
+  token const_sep:     str(',')
+  token expr_sep:      str(';') / C.nl
+  token arg_sep:       str(',') / C.nl
+  token declare_begin: str('{')
+  token declare_end:   str('}') / C.eof
+  token meme_mark:     str(':')
+  token meme_begin:    str('{')
+  token meme_end:      str('}')
+  token paren_begin:   str('(')
+  token paren_end:     str(')')
+  token define:        str('<')
+  token reopen:        str('<<')
+  token params_begin:  str('|')
+  token params_end:    str('|')
+  token args_begin:    str('(')
+  token args_end:      str(')')
+  token array_begin:   str('[')
+  token array_end:     str(']')
+  
+  token constant:     C.upper + C.alnum.*
+  token identifier:   C.lower + C.alnum.* + C.suffix.-
+  token symbol:       str(':') + C.lower + C.alnum.*
+  token null:         str('null')
+  token void:         str('void')
+  token true:         str('true')
+  token false:        str('false')
+  token self:         str('self')
+  token float:        str('-').- + C.num.+ + str('.') + C.num.+
+  token integer:      str('-').- + C.num.+
+  
+  token dot:          str('.')
+  token quest:        str('.') + C.spc_nl.* + str('?')
+  token scope:        str('::')
+  token assign:       str('=')
+  token op_toproc:    str('&')
+  token op_not:       str('!')
+  token op_plus:      str('+')
+  token op_minus:     str('-')
+  token op_mult:      str('*')
+  token op_div:       str('/')
+  token op_mod:       str('%')
+  token op_exp:       str('**')
+  token op_and:       str('&&')
+  token op_or:        str('||')
+  token op_and_q:     str('&?')
+  token op_or_q:      str('|?')
+  token op_void_q:    str('??')
+  token op_compare:   str('<=>') / str('=~') / str('==') /
+                      str('<=') / str('>=') / str('<') / str('>')
+  
+  string_norm:     !set("\\\"") + any
+  token string_body:   string_norm.* + (str("\\") + any + string_norm.*).*
+  token string_begin:  str('"')
+  token string_end:    str('"')
+  token symstr_begin:  str(':"')
+  
+  sstring_norm:    !set("\\\'") + any
+  token sstring_body:  sstring_norm.* + (str("\\") + any + sstring_norm.*).*
+  token sstring_begin: str("'")
+  token sstring_end:   str("'")
+  
+  catgry_norm:     !set("\\[]") + any
+  token catgry_body:   catgry_norm.* + (str("\\") + any + catgry_norm.*).*
+  token catgry_begin:  str('[')
+  token catgry_end:    str(']')
+  
+  # TODO: more flexible declstrs?
+  declstr_norm:     !str("@@@") + any
+  token declstr_body:   declstr_norm.*
+  token declstr_begin:  str('@@@')
+  token declstr_end:    str('@@@')
+}

data/lib/myco/code_tools/parser/MycoTokens.my.rb

@@ -0,0 +1,170 @@
+
+::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.cscope.for_method_definition.const_set(:MycoTokens, (::Myco::Component.new([::Myco.find_constant(:Pegleromyces)::Grammar], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  ::Myco.cscope.for_method_definition.const_set(:C, (::Myco.find_constant(:MycoCharacterClasses)))
+  __category__(:main).component_eval {(
+    declare_meme(:const_sep, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str(","))}
+    declare_meme(:expr_sep, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str(";").__send__(
+      :/,
+      ::Myco.find_constant(:C).nl
+    ))}
+    declare_meme(:arg_sep, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str(",").__send__(
+      :/,
+      ::Myco.find_constant(:C).nl
+    ))}
+    declare_meme(:declare_begin, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("{"))}
+    declare_meme(:declare_end, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("}").__send__(
+      :/,
+      ::Myco.find_constant(:C).eof
+    ))}
+    declare_meme(:meme_mark, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str(":"))}
+    declare_meme(:meme_begin, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("{"))}
+    declare_meme(:meme_end, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("}"))}
+    declare_meme(:paren_begin, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("("))}
+    declare_meme(:paren_end, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str(")"))}
+    declare_meme(:define, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("<"))}
+    declare_meme(:reopen, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("<<"))}
+    declare_meme(:params_begin, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("|"))}
+    declare_meme(:params_end, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("|"))}
+    declare_meme(:args_begin, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("("))}
+    declare_meme(:args_end, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str(")"))}
+    declare_meme(:array_begin, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("["))}
+    declare_meme(:array_end, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("]"))}
+    declare_meme(:constant, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:C).upper.__send__(
+      :+,
+      ::Myco.find_constant(:C).alnum.__send__(:*)
+    ))}
+    declare_meme(:identifier, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:C).lower.__send__(
+      :+,
+      ::Myco.find_constant(:C).alnum.__send__(:*)
+    ).__send__(
+      :+,
+      ::Myco.find_constant(:C).suffix.__send__(:-)
+    ))}
+    declare_meme(:symbol, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str(":").__send__(
+      :+,
+      ::Myco.find_constant(:C).lower
+    ).__send__(
+      :+,
+      ::Myco.find_constant(:C).alnum.__send__(:*)
+    ))}
+    declare_meme(:null, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("null"))}
+    declare_meme(:void, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("void"))}
+    declare_meme(:true, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("true"))}
+    declare_meme(:false, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("false"))}
+    declare_meme(:self, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("self"))}
+    declare_meme(:float, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("-").__send__(:-).__send__(
+      :+,
+      ::Myco.find_constant(:C).num.__send__(:+)
+    ).__send__(
+      :+,
+      self.str(".")
+    ).__send__(
+      :+,
+      ::Myco.find_constant(:C).num.__send__(:+)
+    ))}
+    declare_meme(:integer, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("-").__send__(:-).__send__(
+      :+,
+      ::Myco.find_constant(:C).num.__send__(:+)
+    ))}
+    declare_meme(:dot, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("."))}
+    declare_meme(:quest, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str(".").__send__(
+      :+,
+      ::Myco.find_constant(:C).spc_nl.__send__(:*)
+    ).__send__(
+      :+,
+      self.str("?")
+    ))}
+    declare_meme(:scope, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("::"))}
+    declare_meme(:assign, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("="))}
+    declare_meme(:op_toproc, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("&"))}
+    declare_meme(:op_not, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("!"))}
+    declare_meme(:op_plus, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("+"))}
+    declare_meme(:op_minus, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("-"))}
+    declare_meme(:op_mult, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("*"))}
+    declare_meme(:op_div, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("/"))}
+    declare_meme(:op_mod, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("%"))}
+    declare_meme(:op_exp, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("**"))}
+    declare_meme(:op_and, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("&&"))}
+    declare_meme(:op_or, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("||"))}
+    declare_meme(:op_and_q, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("&?"))}
+    declare_meme(:op_or_q, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("|?"))}
+    declare_meme(:op_void_q, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("??"))}
+    declare_meme(:op_compare, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("<=>").__send__(
+      :/,
+      self.str("=~")
+    ).__send__(
+      :/,
+      self.str("==")
+    ).__send__(
+      :/,
+      self.str("<=")
+    ).__send__(
+      :/,
+      self.str(">=")
+    ).__send__(
+      :/,
+      self.str("<")
+    ).__send__(
+      :/,
+      self.str(">")
+    ))}
+    declare_meme(:string_norm, [], nil, ::Myco.cscope.dup) { |*| (self.set("\\\"").__send__(:!).__send__(
+      :+,
+      self.any
+    ))}
+    declare_meme(:string_body, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.string_norm.__send__(:*).__send__(
+      :+,
+      self.str("\\").__send__(
+        :+,
+        self.any
+      ).__send__(
+        :+,
+        self.string_norm.__send__(:*)
+      ).__send__(:*)
+    ))}
+    declare_meme(:string_begin, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("\""))}
+    declare_meme(:string_end, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("\""))}
+    declare_meme(:symstr_begin, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str(":\""))}
+    declare_meme(:sstring_norm, [], nil, ::Myco.cscope.dup) { |*| (self.set("\\'").__send__(:!).__send__(
+      :+,
+      self.any
+    ))}
+    declare_meme(:sstring_body, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.sstring_norm.__send__(:*).__send__(
+      :+,
+      self.str("\\").__send__(
+        :+,
+        self.any
+      ).__send__(
+        :+,
+        self.sstring_norm.__send__(:*)
+      ).__send__(:*)
+    ))}
+    declare_meme(:sstring_begin, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("'"))}
+    declare_meme(:sstring_end, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("'"))}
+    declare_meme(:catgry_norm, [], nil, ::Myco.cscope.dup) { |*| (self.set("\\[]").__send__(:!).__send__(
+      :+,
+      self.any
+    ))}
+    declare_meme(:catgry_body, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.catgry_norm.__send__(:*).__send__(
+      :+,
+      self.str("\\").__send__(
+        :+,
+        self.any
+      ).__send__(
+        :+,
+        self.catgry_norm.__send__(:*)
+      ).__send__(:*)
+    ))}
+    declare_meme(:catgry_begin, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("["))}
+    declare_meme(:catgry_end, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("]"))}
+    declare_meme(:declstr_norm, [], nil, ::Myco.cscope.dup) { |*| (self.str("@@@").__send__(:!).__send__(
+      :+,
+      self.any
+    ))}
+    declare_meme(:declstr_body, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.declstr_norm.__send__(:*))}
+    declare_meme(:declstr_begin, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("@@@"))}
+    declare_meme(:declstr_end, [[:token, []]], nil, ::Myco.cscope.dup) { |*| (self.str("@@@"))}
+  )}
+)}}.instance)))}}.instance

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

@@ -0,0 +1,4 @@
+
+Builder < BasicObject {
+  
+}

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

@@ -0,0 +1,5 @@
+
+::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.cscope.for_method_definition.const_set(:Builder, ::Myco::Component.new([::Myco.find_constant(:BasicObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {nil}})
+.tap { |__c__| __c__.__name__ = :Builder })}}.instance

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

@@ -0,0 +1,142 @@
+
+BytecodeHelpers < BasicObject {
+  ##
+  # Bytecode Generation Helper Methods
+  
+  var overall_fail: new_label
+  
+  g: self # For consistency
+  
+  puts_string: |string|
+    g.push_rubinius; g.push_literal(string); g.send(:puts, 1, true); g.pop
+  
+  inspect_top:
+    g.dup_top; g.push_rubinius; g.swap; g.send(:p, 1, true); g.pop
+  
+  set_subject:   g.set_local  (0)
+  push_subject:  g.push_local (0)
+  set_idx:       g.set_local  (1)
+  push_idx:      g.push_local (1)
+  set_captures:  g.set_ivar   (:"@captures")
+  push_captures: g.push_ivar  (:"@captures")
+  set_memo_for:  |name| g.set_ivar  (:"@memo_for_"name"")
+  push_memo_for: |name| g.push_ivar (:"@memo_for_"name"")
+  
+  pop_to_set_idx:
+    g.set_idx; g.pop
+  
+  push_temp_captures:
+    g.push_captures; g.make_array(0); g.set_captures; g.pop
+  
+  pop_to_reject_captures:
+    g.set_captures; g.pop
+  
+  pop_to_accept_captures:
+    g.push_captures; g.send(:concat, 1); g.set_captures; g.pop
+  
+  push_subject_at_idx:
+    g.push_subject; g.push_idx; g.send(:chr_at, 1)
+  
+  push_new_hash:
+    g.push_cpath_top; g.find_const(:"Hash"); g.send(:new, 0)
+  
+  # Set the memo ivar to a new hash if it doesn't already exist
+  memo_or_eq_new_hash: |name| {
+    memo_exists_label = g.new_label
+    
+    g.push_memo_for(name)
+    g.goto_if_true(memo_exists_label)
+    g.push_new_hash
+    g.set_memo_for(name)
+    g.pop # ivar
+    memo_exists_label.set!
+  }
+  
+  # Copy the top two values into the memo ivar for |name| at the current idx.
+  copy_result_to_memo: |name| {
+    g.dup
+    g.push_captures
+    g.make_array(2) # [result_idx, result_captures]
+    
+    g.push_memo_for(name)
+      g.swap # [result_idx, result_captures]
+      g.push_idx # idx
+      g.swap # TODO: use rotate
+    g.send(:"[]=", 2)
+    g.pop
+  }
+  
+  # Goto the given |label| and push the result values if a memoized result
+  # exists for the given |name| at the current idx.
+  goto_if_memo_for_idx: |name, label| {
+    skip_label = g.new_label
+    
+    g.push_memo_for(name)
+      g.push_idx
+    g.send(:"[]", 1)
+    g.dup # dup the result to retain after goto test
+    g.goto_if_nil(skip_label)
+    
+    # Shift result_idx onto the stack and swap with array
+    g.shift_array; g.swap
+    # Shift result_captures, set to @captures, and pop
+    g.shift_array; g.set_captures; g.pop
+    g.pop # pop the empty containing array
+    g.goto(label)
+    
+    skip_label.set!
+    g.pop
+  }
+  
+  # Increment the idx local by the current number at the top of the stack
+  # Saves the new idx to @highest_idx ivar if it is highest
+  increment_idx: {
+    g.push_idx
+    g.send(:"+", 1)
+    g.set_idx
+    g.dup_top
+    g.push_ivar(:"@highest_idx")
+    g.send(:">", 1)
+    not_highest_idx_label = g.new_label
+    g.goto_if_false(not_highest_idx_label)
+    g.set_ivar(:"@highest_idx")
+    not_highest_idx_label.set!
+    g.pop
+  }
+  
+  # Begin a compiled parser method
+  rule_start: {
+    # 2 argument: (subject, idx)
+    g.required_args = 2
+    g.total_args    = 2
+    g.splat_index   = null
+    
+    g.local_count = 2
+    g.local_names = [:subject, :idx]
+  }
+  
+  # Wrap up a compiled parser method
+  rule_finish: {
+    overall_done = g.new_label
+    
+    # end
+    g.push_idx
+    g.goto(overall_done)
+    
+    # fail
+    g.overall_fail.set!
+    g.push_nil
+    
+    overall_done.set!
+    g.ret
+    g.close
+  }
+  
+  push_literal_array: |ary|
+    ary.each |lit| { g.push_literal_or_array(lit) }; make_array(ary.size)
+  
+  push_literal_or_array: |item|
+    item.is_a?(::Array)
+      &? push_literal_array(item)
+      ?? push_literal(item)
+}

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

@@ -0,0 +1,181 @@
+
+::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.cscope.for_method_definition.const_set(:BytecodeHelpers, ::Myco::Component.new([::Myco.find_constant(:BasicObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:overall_fail, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (self.new_label)}
+  declare_meme(:g, [], nil, ::Myco.cscope.dup) { |*| (self)}
+  declare_meme(:puts_string, [], nil, ::Myco.cscope.dup) { |string| (
+    self.g.push_rubinius
+    self.g.push_literal(string)
+    self.g.send(
+      :puts,
+      1,
+      true
+    )
+    self.g.pop
+  )}
+  declare_meme(:inspect_top, [], nil, ::Myco.cscope.dup) { |*| (
+    self.g.dup_top
+    self.g.push_rubinius
+    self.g.swap
+    self.g.send(
+      :p,
+      1,
+      true
+    )
+    self.g.pop
+  )}
+  declare_meme(:set_subject, [], nil, ::Myco.cscope.dup) { |*| (self.g.set_local(0))}
+  declare_meme(:push_subject, [], nil, ::Myco.cscope.dup) { |*| (self.g.push_local(0))}
+  declare_meme(:set_idx, [], nil, ::Myco.cscope.dup) { |*| (self.g.set_local(1))}
+  declare_meme(:push_idx, [], nil, ::Myco.cscope.dup) { |*| (self.g.push_local(1))}
+  declare_meme(:set_captures, [], nil, ::Myco.cscope.dup) { |*| (self.g.set_ivar(:@captures))}
+  declare_meme(:push_captures, [], nil, ::Myco.cscope.dup) { |*| (self.g.push_ivar(:@captures))}
+  declare_meme(:set_memo_for, [], nil, ::Myco.cscope.dup) { |name| (self.g.set_ivar(:"@memo_for_#{name}"))}
+  declare_meme(:push_memo_for, [], nil, ::Myco.cscope.dup) { |name| (self.g.push_ivar(:"@memo_for_#{name}"))}
+  declare_meme(:pop_to_set_idx, [], nil, ::Myco.cscope.dup) { |*| (
+    self.g.set_idx
+    self.g.pop
+  )}
+  declare_meme(:push_temp_captures, [], nil, ::Myco.cscope.dup) { |*| (
+    self.g.push_captures
+    self.g.make_array(0)
+    self.g.set_captures
+    self.g.pop
+  )}
+  declare_meme(:pop_to_reject_captures, [], nil, ::Myco.cscope.dup) { |*| (
+    self.g.set_captures
+    self.g.pop
+  )}
+  declare_meme(:pop_to_accept_captures, [], nil, ::Myco.cscope.dup) { |*| (
+    self.g.push_captures
+    self.g.send(
+      :concat,
+      1
+    )
+    self.g.set_captures
+    self.g.pop
+  )}
+  declare_meme(:push_subject_at_idx, [], nil, ::Myco.cscope.dup) { |*| (
+    self.g.push_subject
+    self.g.push_idx
+    self.g.send(
+      :chr_at,
+      1
+    )
+  )}
+  declare_meme(:push_new_hash, [], nil, ::Myco.cscope.dup) { |*| (
+    self.g.push_cpath_top
+    self.g.find_const(:Hash)
+    self.g.send(
+      :new,
+      0
+    )
+  )}
+  declare_meme(:memo_or_eq_new_hash, [], nil, ::Myco.cscope.dup) { |name| (
+    memo_exists_label = self.g.new_label
+    self.g.push_memo_for(name)
+    self.g.goto_if_true(memo_exists_label)
+    self.g.push_new_hash
+    self.g.set_memo_for(name)
+    self.g.pop
+    memo_exists_label.__send__(:set!)
+  )}
+  declare_meme(:copy_result_to_memo, [], nil, ::Myco.cscope.dup) { |name| (
+    self.g.dup
+    self.g.push_captures
+    self.g.make_array(2)
+    self.g.push_memo_for(name)
+    self.g.swap
+    self.g.push_idx
+    self.g.swap
+    self.g.send(
+      :[]=,
+      2
+    )
+    self.g.pop
+  )}
+  declare_meme(:goto_if_memo_for_idx, [], nil, ::Myco.cscope.dup) { |name, label| (
+    skip_label = self.g.new_label
+    self.g.push_memo_for(name)
+    self.g.push_idx
+    self.g.send(
+      :[],
+      1
+    )
+    self.g.dup
+    self.g.goto_if_nil(skip_label)
+    self.g.shift_array
+    self.g.swap
+    self.g.shift_array
+    self.g.set_captures
+    self.g.pop
+    self.g.pop
+    self.g.goto(label)
+    skip_label.__send__(:set!)
+    self.g.pop
+  )}
+  declare_meme(:increment_idx, [], nil, ::Myco.cscope.dup) { |*| (
+    self.g.push_idx
+    self.g.send(
+      :+,
+      1
+    )
+    self.g.set_idx
+    self.g.dup_top
+    self.g.push_ivar(:@highest_idx)
+    self.g.send(
+      :>,
+      1
+    )
+    not_highest_idx_label = self.g.new_label
+    self.g.goto_if_false(not_highest_idx_label)
+    self.g.set_ivar(:@highest_idx)
+    not_highest_idx_label.__send__(:set!)
+    self.g.pop
+  )}
+  declare_meme(:rule_start, [], nil, ::Myco.cscope.dup) { |*| (
+    self.g.__send__(
+      :required_args=,
+      2
+    )
+    self.g.__send__(
+      :total_args=,
+      2
+    )
+    self.g.__send__(
+      :splat_index=,
+      nil
+    )
+    self.g.__send__(
+      :local_count=,
+      2
+    )
+    self.g.__send__(
+      :local_names=,
+      [
+        :subject,
+        :idx
+      ]
+    )
+  )}
+  declare_meme(:rule_finish, [], nil, ::Myco.cscope.dup) { |*| (
+    overall_done = self.g.new_label
+    self.g.push_idx
+    self.g.goto(overall_done)
+    self.g.overall_fail.__send__(:set!)
+    self.g.push_nil
+    overall_done.__send__(:set!)
+    self.g.ret
+    self.g.close
+  )}
+  declare_meme(:push_literal_array, [], nil, ::Myco.cscope.dup) { |ary| (
+    ary.each { |lit| (self.g.push_literal_or_array(lit))}
+    self.make_array(ary.size)
+  )}
+  declare_meme(:push_literal_or_array, [], nil, ::Myco.cscope.dup) { |item| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", item.__send__(
+    :is_a?,
+    ::Array
+  )) {self.push_literal_array(item)}) {self.push_literal(item)})}
+)}})
+.tap { |__c__| __c__.__name__ = :BytecodeHelpers })}}.instance