myco 0.1.7 → 0.1.8

data/lib/myco/bootstrap.my.rb

@@ -1,9 +1,46 @@
 
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  ::Myco::RubyEval = ::Myco::Component.new([::Myco.find_constant(:EmptyObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-  .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:from_string, [], nil, ::Myco.cscope.dup) { |string| (::Ruby::Kernel.instance_method(:eval).bind(self).call(string))})}}
+  ::Myco::RubyEval = ::Myco::Component.new([::Myco::EmptyObject], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {(declare_meme(:from_string, [], nil, ::Myco.cscope.dup) { |string| (::Object.__send__(
+    :eval,
+    string
+  ))})}}
   .tap { |__c__| __c__.__name__ = :RubyEval }
-  ::Myco::Component.new([::Myco.find_constant(:RubyEval)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}.instance.from_string("  Myco.eval_file(\"core/Category.my\",        [Myco::CoreLoadPath])\n  Myco.eval_file(\"core/BasicDecorators.my\", [Myco::CoreLoadPath])\n  Myco.eval_file(\"core/BasicObject.my\",     [Myco::CoreLoadPath])\n  Myco.eval_file(\"core/Decorator.my\",       [Myco::CoreLoadPath])\n  Myco.eval_file(\"core/Object.my\",          [Myco::CoreLoadPath])\n  Myco.eval_file(\"core/FileToplevel.my\",    [Myco::CoreLoadPath])\n  \n  # Below are not necessary for bootstrapping; TODO: move out of RubyEval\n  Myco.eval_file(\"core/Switch.my\",          [Myco::CoreLoadPath])\n")
+  ::Myco::Category = ::Myco::Component.new([::Myco::EmptyObject], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}
+  .tap { |__c__| __c__.__name__ = :Category }
+  ::Myco::BasicDecorators = ::Myco::Component.new([::Myco::EmptyObject], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}
+  .tap { |__c__| __c__.__name__ = :BasicDecorators }
+  ::Myco::BasicObject = ::Myco::Component.new([
+    ::Myco::EmptyObject,
+    ::Myco::BasicDecorators
+  ], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}
+  .tap { |__c__| __c__.__name__ = :BasicObject }
+  ::Myco::Decorator = ::Myco::Component.new([::Myco::BasicObject], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}
+  .tap { |__c__| __c__.__name__ = :Decorator }
+  ::Myco::FileToplevel = ::Myco::Component.new([::Myco::BasicObject], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  .tap { |__c__| __c__.__last__ = __c__.component_eval {nil}}
+  .tap { |__c__| __c__.__name__ = :FileToplevel }
+  __category__(:decorators).component_eval {(
+    declare_meme(:load, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:LoadDecorator))}
+    ::Myco.cscope.for_method_definition::LoadDecorator = (::Myco::Component.new([::Myco::Decorator], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+    .tap { |__c__| __c__.__last__ = __c__.component_eval {(
+      declare_meme(:apply, [], nil, ::Myco.cscope.dup) { |meme| (::Myco.eval_file(
+        meme.name.to_s,
+        [::Myco::CoreLoadPath]
+      ))}
+      __category__(:transforms).component_eval {(declare_meme(:apply, [], nil, ::Myco.cscope.dup) { |*| nil})}
+    )}}.instance)
+  )}
+  __category__(:main).component_eval {(
+    declare_meme(:"core/Category.my", [[:load, []]], nil, ::Myco.cscope.dup) { |*| nil}
+    declare_meme(:"core/Decorator.my", [[:load, []]], nil, ::Myco.cscope.dup) { |*| nil}
+    declare_meme(:"core/BasicDecorators.my", [[:load, []]], nil, ::Myco.cscope.dup) { |*| nil}
+    declare_meme(:"core/BasicObject.my", [[:load, []]], nil, ::Myco.cscope.dup) { |*| nil}
+    declare_meme(:"core/FileToplevel.my", [[:load, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  )}
 )}}.instance

data/lib/myco/bootstrap.rb

@@ -2,6 +2,10 @@
 require_relative 'bootstrap/find_constant'
 
 require_relative 'bootstrap/void'
+require_relative 'bootstrap/undefined'
+require_relative 'bootstrap/tuple'
+
+require_relative 'bootstrap/add_method'
 require_relative 'bootstrap/meme'
 require_relative 'bootstrap/instance'
 require_relative 'bootstrap/component'

data/lib/myco/code_loader.rb

@@ -85,10 +85,12 @@ module Myco
     # If cscope or vscope or receiver are nil, they are pulled from
     # the given call_depth, corresponding to one of the calling frames.
     # 
-    def self.load path, load_paths=[], call_depth:1, **kwargs
+    # TODO: fix rubinius JIT issue and use "call_depth:1, **kwargs" here
+    def self.load path, load_paths, kwargs={}
+      kwargs[:call_depth] ||= 1
       begin
         loader = loader_for_file(path, load_paths)
-        loader.bind_to(call_depth:call_depth+1, **kwargs)
+        loader.bind_to(kwargs.merge(call_depth: kwargs[:call_depth] + 1))
         loader.compile
         loader.emit_rb!  if self.emit_rb
         loader.emit_rbc! if self.emit_rbc
@@ -113,12 +115,12 @@ module Myco
         @line     = line
       end
       
-      def bind_to cscope:nil, vscope:nil, receiver:nil,
-                  call_depth:1
-        loc = Rubinius::VM.backtrace(call_depth, true).first
-        @constant_scope = cscope || loc.constant_scope
-        @variable_scope = vscope || loc.variables
-        @receiver =     receiver || loc.instance_variable_get(:@receiver)
+      # TODO: fix rubinius JIT issue and use "cscope:nil, vscope:nil, receiver:nil, call_depth:1" here
+      def bind_to kwargs={}
+        loc = Rubinius::VM.backtrace(kwargs.fetch(:call_depth, 1), true).first
+        @constant_scope = kwargs[:cscope] || loc.constant_scope
+        @variable_scope = kwargs[:vscope] || loc.variables
+        @receiver =     kwargs[:receiver] || loc.instance_variable_get(:@receiver)
         
         self
       end
@@ -253,7 +255,7 @@ module Myco
       end
       
       def new_parser
-        Myco::ToolSet::Parser.new
+        Myco::ToolSet::Parser
       end
       
       def new_generator

data/lib/myco/code_tools/AST/Block.my.rb

@@ -12,8 +12,8 @@
   ::Myco.cscope.for_method_definition::CompilerClass = (::Myco.find_constant(:CodeTools)::Compiler)
   declare_meme(:parameters, [[:setter, []]], nil, ::Myco.cscope.dup) { |given| (::Myco.branch_op(:"||", given) {::Myco.find_constant(:ParameterAssembly).new({:line => self.line})})}
   declare_meme(:body, [[:setter, []]], nil, ::Myco.cscope.dup) { |given| (::Myco.branch_op(:"||", given) {::Myco.find_constant(:NullLiteral).new({:line => self.line})})}
-  declare_meme(:locals, [], nil, ::Myco.cscope.dup) { |*| (::Myco.branch_op(:"??", ((self.body.respond_to?(:locals).false? ? ::Myco::Void : self.body.locals).respond_to?(:body).false? ? ::Myco::Void : (self.body.respond_to?(:locals).false? ? ::Myco::Void : self.body.locals).body).map(&:value)) {nil})}
-  declare_meme(:block_local?, [], nil, ::Myco.cscope.dup) { |name| (::Myco.branch_op(:"??", (self.locals.respond_to?(:include?).false? ? ::Myco::Void : self.locals.__send__(
+  declare_meme(:locals, [], nil, ::Myco.cscope.dup) { |*| (::Myco.branch_op(:"??", (Rubinius::Type.object_respond_to?((Rubinius::Type.object_respond_to?(self.body, :locals).false? ? ::Myco::Void : self.body.locals), :body).false? ? ::Myco::Void : (Rubinius::Type.object_respond_to?(self.body, :locals).false? ? ::Myco::Void : self.body.locals).body).map(&:value)) {nil})}
+  declare_meme(:block_local?, [], nil, ::Myco.cscope.dup) { |name| (::Myco.branch_op(:"??", (Rubinius::Type.object_respond_to?(self.locals, :include?).false? ? ::Myco::Void : self.locals.__send__(
     :include?,
     name
   ))) {false})}

data/lib/myco/code_tools/AST/ConstantAccess.my.rb

@@ -12,12 +12,12 @@
     ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.toplevel) {self.case(
       first_name,
       :Myco,
-      ::Proc.new { || (g.push_myco)},
+      ::Object::Proc.new { || (g.push_myco)},
       :Ruby,
-      ::Proc.new { || (g.push_cpath_top)},
+      ::Object::Proc.new { || (g.push_cpath_top)},
       :Rubinius,
-      ::Proc.new { || (g.push_rubinius)},
-      ::Proc.new { || (
+      ::Object::Proc.new { || (g.push_rubinius)},
+      ::Object::Proc.new { || (
         g.push_myco
         g.find_const(first_name)
       )}

data/lib/myco/code_tools/AST/ConstantAssignment.my.rb

@@ -13,12 +13,12 @@
     ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.constant.toplevel) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", first_name) {self.case(
       first_name,
       :Myco,
-      ::Proc.new { || (g.push_myco)},
+      ::Object::Proc.new { || (g.push_myco)},
       :Ruby,
-      ::Proc.new { || (g.push_cpath_top)},
+      ::Object::Proc.new { || (g.push_cpath_top)},
       :Rubinius,
-      ::Proc.new { || (g.push_rubinius)},
-      ::Proc.new { || (
+      ::Object::Proc.new { || (g.push_rubinius)},
+      ::Object::Proc.new { || (
         g.push_myco
         g.find_const(first_name)
       )}

data/lib/myco/code_tools/AST/Invoke.my

@@ -17,7 +17,7 @@ CodeTools::AST << {
         use_args.block = self.block
       )
       
-      self.receiver.nil? && use_args.nil? &? (
+      !self.receiver && !use_args &? (
         LocalVariableAccessAmbiguous.new(
           line: self.line
           name: self.name

data/lib/myco/code_tools/AST/Invoke.my.rb

@@ -23,7 +23,7 @@
         self.block
       )
     )}
-    ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", ::Myco.branch_op(:"&&", self.receiver.__send__(:nil?)) {use_args.__send__(:nil?)}) {::Myco.find_constant(:LocalVariableAccessAmbiguous).new({
+    ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", ::Myco.branch_op(:"&&", self.receiver.__send__(:!)) {use_args.__send__(:!)}) {::Myco.find_constant(:LocalVariableAccessAmbiguous).new({
       :line => self.line,
       :name => self.name
     })}) {::Myco.find_constant(:InvokeMethod).new({

data/lib/myco/code_tools/AST/Node.my

@@ -43,15 +43,13 @@ CodeTools::AST << {
     
     [decorators]
     
-    # TODO: should be "const", not "var"
-    var node_type: Decorator {
+    const node_type: Decorator {
       apply: |meme| meme.target.node_type = meme.name
       [transforms]
       expose: false
     }
     
-    # TODO: should be "const", not "var"
-    var field: Decorator {
+    const field: Decorator {
       apply: |meme| meme.target.fields.push(meme.name)
       [transforms]
       var: true

data/lib/myco/code_tools/AST/Node.my.rb

@@ -50,11 +50,11 @@
       self.line,
       *self.fields.map { |name| (
         value = self.__send__(name)
-        ::Myco.branch_op(:"??", ::Myco.branch_op(:"??", (value.respond_to?(:map).false? ? ::Myco::Void : value.map { |value| (::Myco.branch_op(:"??", (value.respond_to?(:representation).false? ? ::Myco::Void : value.representation)) {value})})) {(value.respond_to?(:representation).false? ? ::Myco::Void : value.representation)}) {value}
+        ::Myco.branch_op(:"??", ::Myco.branch_op(:"??", (Rubinius::Type.object_respond_to?(value, :map).false? ? ::Myco::Void : value.map { |value| (::Myco.branch_op(:"??", (Rubinius::Type.object_respond_to?(value, :representation).false? ? ::Myco::Void : value.representation)) {value})})) {(Rubinius::Type.object_respond_to?(value, :representation).false? ? ::Myco::Void : value.representation)}) {value}
       )}
     ])}
     __category__(:decorators).component_eval {(
-      declare_meme(:node_type, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Decorator)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+      declare_meme(:node_type, [[:const, []]], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Decorator)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
       .tap { |__c__| __c__.__last__ = __c__.component_eval {(
         declare_meme(:apply, [], nil, ::Myco.cscope.dup) { |meme| (meme.target.__send__(
           :node_type=,
@@ -62,7 +62,7 @@
         ))}
         __category__(:transforms).component_eval {(declare_meme(:expose, [], nil, ::Myco.cscope.dup) { |*| (false)})}
       )}}.instance)}
-      declare_meme(:field, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Decorator)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+      declare_meme(:field, [[:const, []]], nil, ::Myco.cscope.dup) { |*| (::Myco::Component.new([::Myco.find_constant(:Decorator)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
       .tap { |__c__| __c__.__last__ = __c__.component_eval {(
         declare_meme(:apply, [], nil, ::Myco.cscope.dup) { |meme| (meme.target.fields.push(meme.name))}
         __category__(:transforms).component_eval {(declare_meme(:var, [], nil, ::Myco.cscope.dup) { |*| (true)})}

data/lib/myco/code_tools/AST/PipeOperator.my.rb

@@ -9,7 +9,7 @@
     :line => self.line,
     :body => [self.value].__send__(
       :+,
-      ::Myco.branch_op(:"??", (self.invoke.arguments.respond_to?(:body).false? ? ::Myco::Void : self.invoke.arguments.body)) {[]}
+      ::Myco.branch_op(:"??", (Rubinius::Type.object_respond_to?(self.invoke.arguments, :body).false? ? ::Myco::Void : self.invoke.arguments.body)) {[]}
     )
   }))}
   declare_meme(:implementation, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:Invoke).new({

data/lib/myco/code_tools/AST/ToRuby.my.rb

@@ -152,12 +152,12 @@
     ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.toplevel) {self.case(
       first_name,
       :Myco,
-      ::Proc.new { || (g.add("::Myco"))},
+      ::Object::Proc.new { || (g.add("::Myco"))},
       :Ruby,
-      ::Proc.new { || (g.add("::Object"))},
+      ::Object::Proc.new { || (g.add("::Object"))},
       :Rubinius,
-      ::Proc.new { || (g.add("::Rubinius"))},
-      ::Proc.new { || (g.add("::Myco::#{first_name}"))}
+      ::Object::Proc.new { || (g.add("::Rubinius"))},
+      ::Object::Proc.new { || (g.add("::Myco::#{first_name}"))}
     )}) {g.add("::Myco.find_constant(#{first_name.inspect})")}
     name_list.each { |name| (g.add("::#{name}"))}
   )})}
@@ -168,12 +168,12 @@
     ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.constant.toplevel) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", first_name) {self.case(
       first_name,
       :Myco,
-      ::Proc.new { || (g.add("::Myco"))},
+      ::Object::Proc.new { || (g.add("::Myco"))},
       :Ruby,
-      ::Proc.new { || (g.add("::Object"))},
+      ::Object::Proc.new { || (g.add("::Object"))},
       :Rubinius,
-      ::Proc.new { || (g.add("::Rubinius"))},
-      ::Proc.new { || (g.add("::Myco::#{first_name}"))}
+      ::Object::Proc.new { || (g.add("::Rubinius"))},
+      ::Object::Proc.new { || (g.add("::Myco::#{first_name}"))}
     )}) {g.add("::Myco")}}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", first_name) {g.add("::Myco.find_constant(#{first_name.inspect})")}) {g.add("::Myco.cscope.for_method_definition")}}
     name_list.each { |name| (g.add("::#{name}"))}
     g.add("::#{last_name} = ")

data/lib/myco/code_tools/AST/misc.my.rb

@@ -57,7 +57,7 @@
     )}
   )}}
   .tap { |__c__| __c__.__name__ = :FalseLiteral }
-  ::Myco.cscope.for_method_definition::EVALUATE_NOW = (::Myco.find_constant(:CodeTools)::AST.component_eval { || (self.constants.select { |const_name| (::Myco.branch_op(:"??", (self.const_get(const_name).respond_to?(:node_type).false? ? ::Myco::Void : self.const_get(const_name).node_type)) {nil})}.each { |const_name| (
+  ::Myco.cscope.for_method_definition::EVALUATE_NOW = (::Myco.find_constant(:CodeTools)::AST.component_eval { || (self.constants.select { |const_name| (::Myco.branch_op(:"??", (Rubinius::Type.object_respond_to?(self.const_get(const_name), :node_type).false? ? ::Myco::Void : self.const_get(const_name).node_type)) {nil})}.each { |const_name| (
     component = self.const_get(const_name)
     node_type = component.node_type
     fields = component.fields

data/lib/myco/code_tools/Parser.my

@@ -2,23 +2,16 @@
 # TODO: include Pegleromyces library in a better way than clone into subdir
 import as(:Pegleromyces) 'parser/pegleromyces/lib/pegleromyces.my'
 
-# TODO: remove this hack
-::Myco::Pegleromyces: Pegleromyces
+import 'parser/MycoGrammar.my'
+import 'parser/MycoBuilder.my'
 
-CodeTools::Parser < BasicObject {
-  MycoGrammar: Myco.eval_file('parser/MycoGrammar.my')
-  MycoBuilder: Myco.eval_file('parser/MycoBuilder.my')
-  
-  MycoParser: Pegleromyces::BytecodeParser {
-    var grammar: MycoGrammar
-    # TODO: re-evaluate design that returns an existing builder as 'new_builder'
-    new_builder: MycoBuilder
-  }
+CodeTools::Parser: Pegleromyces::BytecodeParser {
+  const grammar: MycoGrammar
+  const builder: MycoBuilder
   
   parse_string: |string| {
-    parser = MycoParser
-    parser.parse(string)
-    parser.result &?
-      parser.result.fetch(:root) ?? parser.raise_error
+    state = parse(string)
+    state.result &?
+      state.result.fetch(:root) ?? state.raise_error
   }
 }

data/lib/myco/code_tools/Parser.my.rb

@@ -5,21 +5,15 @@
     [:as, [:Pegleromyces]],
     [:import, []]
   ], nil, ::Myco.cscope.dup) { |*| nil}
-  ::Myco::Pegleromyces = (::Myco.find_constant(:Pegleromyces))
-  ::Myco.find_constant(:CodeTools)::Parser = ::Myco::Component.new([::Myco.find_constant(:BasicObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+  declare_meme(:"parser/MycoGrammar.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:"parser/MycoBuilder.my", [[:import, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  ::Myco.find_constant(:CodeTools)::Parser = (::Myco::Component.new([::Myco.find_constant(:Pegleromyces)::BytecodeParser], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
   .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-    ::Myco.cscope.for_method_definition::MycoGrammar = (::Myco.find_constant(:Myco).eval_file("parser/MycoGrammar.my"))
-    ::Myco.cscope.for_method_definition::MycoBuilder = (::Myco.find_constant(:Myco).eval_file("parser/MycoBuilder.my"))
-    ::Myco.cscope.for_method_definition::MycoParser = (::Myco::Component.new([::Myco.find_constant(:Pegleromyces)::BytecodeParser], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-    .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-      declare_meme(:grammar, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:MycoGrammar))}
-      declare_meme(:new_builder, [], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:MycoBuilder))}
-    )}}.instance)
+    declare_meme(:grammar, [[:const, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:MycoGrammar))}
+    declare_meme(:builder, [[:const, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:MycoBuilder))}
     declare_meme(:parse_string, [], nil, ::Myco.cscope.dup) { |string| (
-      parser = ::Myco.find_constant(:MycoParser)
-      parser.parse(string)
-      ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", parser.result) {parser.result.fetch(:root)}) {parser.raise_error}
+      state = self.parse(string)
+      ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", state.result) {state.result.fetch(:root)}) {state.raise_error}
     )}
-  )}}
-  .tap { |__c__| __c__.__name__ = :Parser }
+  )}}.instance)
 )}}.instance

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

@@ -1,10 +1,9 @@
 
-BasicObject {
+MycoBuilder: BasicObject {
   # TODO: be more clever here
-  ASTBuilder: CodeTools::AST::Builder.new
-  var ast: ASTBuilder
+  const ast: CodeTools::AST::Builder.new
   
-  var escape_encodings: {
+  const escape_encodings: {
     hash = ::Ruby::Hash.new
     hash["\\a"] =  7.chr # \a  0x07  Bell or alert
     hash["\\b"] =  8.chr # \b  0x08  Backspace

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

@@ -1,11 +1,10 @@
 
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco::Component.new([::Myco.find_constant(:BasicObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.cscope.for_method_definition::MycoBuilder = (::Myco::Component.new([::Myco.find_constant(:BasicObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
 .tap { |__c__| __c__.__last__ = __c__.component_eval {(
-  ::Myco.cscope.for_method_definition::ASTBuilder = (::Myco.find_constant(:CodeTools)::AST::Builder.new)
-  declare_meme(:ast, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:ASTBuilder))}
-  declare_meme(:escape_encodings, [[:var, []]], nil, ::Myco.cscope.dup) { |*| (
-    hash = ::Ruby::Hash.new
+  declare_meme(:ast, [[:const, []]], nil, ::Myco.cscope.dup) { |*| (::Myco.find_constant(:CodeTools)::AST::Builder.new)}
+  declare_meme(:escape_encodings, [[:const, []]], nil, ::Myco.cscope.dup) { |*| (
+    hash = ::Object::Hash.new
     hash.__send__(
       :[]=,
       "\\a",
@@ -96,4 +95,4 @@
     output.push(input.shift)
     input.replace(output)
   )}
-)}}.instance)}}.instance
+)}}.instance))}}.instance

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

@@ -1,5 +1,5 @@
 
-BytecodeHelpers < BasicObject {
+BytecodeHelpers < BasicDecorators {
   ##
   # Bytecode Generation Helper Methods
   
@@ -37,8 +37,8 @@ BytecodeHelpers < BasicObject {
   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)
+  push_new_table:
+    g.push_rubinius; g.find_const(:LookupTable); g.send(:new, 0)
   
   # Set the memo ivar to a new hash if it doesn't already exist
   memo_or_eq_new_hash: |name| {
@@ -46,7 +46,7 @@ BytecodeHelpers < BasicObject {
     
     g.push_memo_for(name)
     g.goto_if_true(memo_exists_label)
-    g.push_new_hash
+    g.push_new_table
     g.set_memo_for(name)
     g.pop # ivar
     memo_exists_label.set!
@@ -113,6 +113,8 @@ BytecodeHelpers < BasicObject {
     
     g.local_count = 2
     g.local_names = [:subject, :idx]
+    
+    # g.puts_string("trying.. "g.name"") # TODO: enable with debug flag
   }
   
   # Wrap up a compiled parser method
@@ -121,11 +123,13 @@ BytecodeHelpers < BasicObject {
     
     # end
     g.push_idx
+    # g.puts_string("SUCCESS! "g.name"") # TODO: enable with debug flag
     g.goto(overall_done)
     
     # fail
     g.overall_fail.set!
     g.push_nil
+    # g.puts_string("failure: "g.name"") # TODO: enable with debug flag
     
     overall_done.set!
     g.ret

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

@@ -1,6 +1,6 @@
 
 ::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
-.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.cscope.for_method_definition::BytecodeHelpers = ::Myco::Component.new([::Myco.find_constant(:BasicObject)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.cscope.for_method_definition::BytecodeHelpers = ::Myco::Component.new([::Myco.find_constant(:BasicDecorators)], ::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)}
@@ -64,9 +64,9 @@
       1
     )
   )}
-  declare_meme(:push_new_hash, [], nil, ::Myco.cscope.dup) { |*| (
-    self.g.push_cpath_top
-    self.g.find_const(:Hash)
+  declare_meme(:push_new_table, [], nil, ::Myco.cscope.dup) { |*| (
+    self.g.push_rubinius
+    self.g.find_const(:LookupTable)
     self.g.send(
       :new,
       0
@@ -76,7 +76,7 @@
     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.push_new_table
     self.g.set_memo_for(name)
     self.g.pop
     memo_exists_label.__send__(:set!)

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

@@ -351,10 +351,10 @@ BytecodeInstructions < BasicObject {
     g.overall_fail = old_fail # reset fail
     g.goto(g.overall_fail)
     
-    # Failure => Success, backtrack index but keep captures
+    # Failure => Success, backtrack index and cannot keep captures either (incomplete)
     local_fail.set!
     g.pop_to_set_idx
-    if(inner_can_capture) { g.pop_to_accept_captures }
+    if(inner_can_capture) { g.pop_to_reject_captures }
     g.overall_fail = old_fail
   }
   

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

@@ -17,35 +17,35 @@
         m.set(codes.map(&:chr).join)
       )})}
       ::Myco.find_constant(:NegativePredicate).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |m| (m.neg_predicate(
-        ::Proc.new { || (self.inner.bytecode(m))},
+        ::Object::Proc.new { || (self.inner.bytecode(m))},
         self.inner.bytecode_can_capture
       ))})}
       ::Myco.find_constant(:PositivePredicate).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |m| (m.pos_predicate(
-        ::Proc.new { || (self.inner.bytecode(m))},
+        ::Object::Proc.new { || (self.inner.bytecode(m))},
         self.inner.bytecode_can_capture
       ))})}
       ::Myco.find_constant(:OneOrMore).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |m| (m.many(
-        ::Proc.new { || (
+        ::Object::Proc.new { || (
           self.inner.bytecode(m)
-          (self.inlaid.respond_to?(:call).false? ? ::Myco::Void : self.inlaid.call)
+          (Rubinius::Type.object_respond_to?(self.inlaid, :call).false? ? ::Myco::Void : self.inlaid.call)
         )},
         self.inner.bytecode_can_capture
       ))})}
       ::Myco.find_constant(:ZeroOrOne).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |m| (m.choice(
-        ::Proc.new { || (self.inner.bytecode(m))},
-        ::Proc.new { || nil},
+        ::Object::Proc.new { || (self.inner.bytecode(m))},
+        ::Object::Proc.new { || nil},
         self.inner.bytecode_can_capture
       ))})}
       ::Myco.find_constant(:ZeroOrMore).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |m| (m.kleene(
-        ::Proc.new { || (
+        ::Object::Proc.new { || (
           self.inner.bytecode(m)
-          (self.inlaid.respond_to?(:call).false? ? ::Myco::Void : self.inlaid.call)
+          (Rubinius::Type.object_respond_to?(self.inlaid, :call).false? ? ::Myco::Void : self.inlaid.call)
         )},
         self.inner.bytecode_can_capture
       ))})}
       ::Myco.find_constant(:OrderedChoice).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |m| (m.choice(
-        ::Proc.new { || (self.first.bytecode(m))},
-        ::Proc.new { || (self.second.bytecode(m))},
+        ::Object::Proc.new { || (self.first.bytecode(m))},
+        ::Object::Proc.new { || (self.second.bytecode(m))},
         self.first.bytecode_can_capture
       ))})}
       ::Myco.find_constant(:Concatenation).component_eval {(declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |m| (
@@ -61,7 +61,7 @@
       )}) {(
         self.inner.__send__(
           :inlaid=,
-          ::Proc.new { || (m.capture(
+          ::Object::Proc.new { || (m.capture(
             :m_split,
             self.captargs
           ))}
@@ -347,7 +347,7 @@
       self.__send__(
         :if,
         inner_can_capture
-      ) { || (self.g.pop_to_accept_captures)}
+      ) { || (self.g.pop_to_reject_captures)}
       self.g.__send__(
         :overall_fail=,
         old_fail