myco 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: df9a55b04c78564fb8a8f10e94d72c7136fc2bde
-  data.tar.gz: 6073c4691d0c8d869435b52fc9ccee1f78093bd7
+  metadata.gz: c497fbe2e87f23f8cea7374510cbac8a7aefdd6a
+  data.tar.gz: 519dc6fbe9d381ee9478ca46fa71fefecd5318b8
 SHA512:
-  metadata.gz: 2276b5f604d73476740c3a8357e3ac7a759bbaa71606da9d778a11274550233c59e8cb92a1d47ed362565e56e73a0daffafb053f3ad3320dd5a8b24c095989dc
-  data.tar.gz: 5c68645cf8199d1f6eb86d9f861ed6fb2812caafaceb1b8b3469cdefb3c91c7205c58eafb3d661a9049cf252034e2bf591e901a602d54b84e0e9977df029441f
+  metadata.gz: 6e7dc8c64ae6d9a26b421ba7a45dc5a0ec44f969519e128ebe680701c39d68dd70b6dde54743e99c2c5fb0b2267696c4e119095cead9c41254b1de50d28556a4
+  data.tar.gz: 05cf18931bdf1d8632dcf9d7d88e09cc014b8af1e6a86d70f8a2b74395c8210c36d999cb25f4fc0096380618132e09887d4af23aa0130a73724055e0b7029b3d

data/lib/myco/bootstrap/component.rb

@@ -18,7 +18,7 @@ module Myco
       elsif @__name__
         @__name__.to_s
       else
-        "#{@super_components.map(&:to_s).join(',')}" \
+        "#{(@super_components || []).map(&:to_s).join(',')}" \
           "(#{@basename}:#{@line.to_s} 0x#{object_id.to_s 16})"
       end
     end
@@ -64,13 +64,12 @@ module Myco
       all_categories = Hash.new { |h,k| h[k] = Array.new }
       
       super_components.each do |other|
-        raise TypeError, "Got non-Component in supers for new Component: "\
-          "#{super_components.inspect}" \
-              unless other.is_a? Component
-        
         this.include other
-        other.categories.each do |name, cat|
-          all_categories[name] << cat
+        
+        if other.is_a? Component
+          other.categories.each do |name, cat|
+            all_categories[name] << cat
+          end
         end
       end
       

data/lib/myco/bootstrap/instance.rb

@@ -3,20 +3,16 @@ module Myco
   module InstanceMethods
     include ::Kernel
     
-    # TODO: clean this up
-    prepend (::Module.new {
-      def method_missing name, *args
-        msg = "#{to_s} has no method called '#{name}'"
-        ::Kernel.raise ::NoMethodError.new(msg, name, args)
-      end
-    })
-    
     def to_s
       "#<#{@component.to_s}>"
     end
     
     def inspect
-      to_s
+      vars = (instance_variables - [:@component]).map { |var|
+        [var.to_s[1..-1], instance_variable_get(var).inspect].join(": ")
+      }
+      vars = vars.any? ? (" " + vars.join(", ")) : ""
+      "#<#{@component.to_s}#{vars}>"
     end
     
     # TODO: remove (for now it makes debugging easier with RSpec)
@@ -41,5 +37,14 @@ module Myco
   
   class Instance < ::BasicObject
     include InstanceMethods
+    
+    # # TODO: clean this up
+    # prepend (::Module.new {
+      def method_missing name, *args
+        msg = "#{to_s} has no method called '#{name}'"
+        ::Kernel.raise ::NoMethodError.new(msg, name, args)
+      end
+    # })
+    
   end
 end

data/lib/myco/bootstrap/meme.rb

@@ -47,6 +47,8 @@ module Myco
     attr_accessor :cache
     attr_accessor :var
     attr_accessor :expose
+    attr_accessor :setter
+    attr_accessor :getter
     
     attr_reader :metadata
     
@@ -133,6 +135,12 @@ module Myco
         bind_var_getter
         bind_var_setter
         @effective_body = @target.instance_method(@name).executable
+      elsif @getter
+        bind_var_getter
+        @effective_body = @target.instance_method(@name).executable
+      elsif @setter
+        bind_var_setter
+        @effective_body = @target.instance_method(@name).executable
       elsif @cache
         bind_cache_method
         @effective_body = @target.instance_method(@name).executable
@@ -272,7 +280,7 @@ module Myco
           g.make_array 0
           g.push_nil
         g.send :invoke, 5
-        g.set_ivar(@name)
+        g.set_ivar(:"@#{@name}")
         
         g.push_true
         g.set_ivar(:"__#{@name}_defined__")
@@ -280,14 +288,27 @@ module Myco
         g.goto(ret)
         
         get.set!
-        g.push_ivar(@name)
+        g.push_ivar(:"@#{@name}")
         
         ret.set!
+        
+        # If this meme has a getter defined, use it
+        if self.getter
+          g.push_self
+          g.push_local(1) # meme
+          g.send(:getter, 0)
+          g.rotate(3)
+          g.send(:call_on_object, 2)
+        end
+        
         g.ret
       end
     end
     
     def bind_var_setter
+      # TODO: move this bytecode generation to a helper method 
+      meme = self
+      
       # TODO: move this bytecode generation to a helper method 
       target.dynamic_method :"#{@name}=", '(myco_internal)' do |g|
         g.total_args = 1
@@ -298,7 +319,17 @@ module Myco
         g.pop
         
         g.push_local 0 # value
-        g.set_ivar @name
+        
+        # If this meme has a setter defined, use it
+        if meme.setter
+          g.push_self
+          g.push_literal(meme)
+          g.send(:setter, 0)
+          g.rotate(3)
+          g.send(:call_on_object, 2)
+        end
+        
+        g.set_ivar(:"@#{@name}")
         
         g.ret
       end

data/lib/myco/code_loader.rb

@@ -16,12 +16,6 @@ module Myco
     # Use generated ruby files only when Myco files cannot be found or loaded.
     self.precedence = [:rbc, :myco, :rb]
     
-    # TODO: a more elegant solution than env vars
-    # Emit ruby if env var indicates
-    # Load from ruby exclusively if env var indicates
-    self.emit_rb    = true    if ENV['MYCO_TO_RUBY'] == 'PRE'
-    self.precedence = [:myco] if ENV['MYCO_TO_RUBY'] == 'PRE'
-    
     # Try to resolve the given file path
     # in the current working directory or in the given load paths.
     def self.resolve_file path, load_paths=[]
@@ -136,10 +130,10 @@ module Myco
       def make_ast
         @string || make_string
         
-        parser = parser_type.new(@filename, @line, [])
+        parser = new_parser
         ast = parser.parse_string(@string)
         
-        ast = ast_root_type.new(ast) if ast_root_type
+        ast = ast_root_for(ast)
         ast.file = filename.to_sym
         ast.variable_scope = @variable_scope
         
@@ -149,7 +143,7 @@ module Myco
       def make_generator
         @ast || make_ast
         
-        g = generator_type.new
+        g = new_generator
         @ast.bytecode(g)
         
         g.close
@@ -206,7 +200,7 @@ module Myco
         return nil unless filename
         
         compiled_file_type.dump(
-          @compiled_code, filename, Rubinius::Signature, 0
+          @compiled_code, filename, Rubinius::Signature, Rubinius::RUBY_LIB_VERSION
         )
       end
       
@@ -249,22 +243,16 @@ module Myco
     end
     
     class MycoLoader < AbstractLoader
-      def initialize *args
-        # TODO: a more elegant solution than env vars
-        raise NotImplementedError if ENV['MYCO_TO_RUBY'] == 'POST'
-        super
-      end
-      
-      def ast_root_type
-        Myco::ToolSet::AST::EvalExpression
+      def ast_root_for(body)
+        Myco::ToolSet::AST::Script.new(body: body)
       end
       
-      def parser_type
-        Myco::ToolSet::Parser
+      def new_parser
+        Myco::ToolSet::Parser.new
       end
       
-      def generator_type
-        Myco::ToolSet::Generator
+      def new_generator
+        Myco::ToolSet::Generator.new
       end
       
       def compiled_file_type
@@ -281,16 +269,16 @@ module Myco
         super *args
       end
       
-      def ast_root_type
-        Rubinius::ToolSets::Runtime::AST::EvalExpression
+      def ast_root_for(body)
+        Rubinius::ToolSets::Runtime::AST::EvalExpression.new(body)
       end
       
-      def parser_type
-        Rubinius::ToolSets::Runtime::Melbourne
+      def new_parser
+        Rubinius::ToolSets::Runtime::Melbourne.new(@filename, @line, [])
       end
       
-      def generator_type
-        Rubinius::ToolSets::Runtime::Generator
+      def new_generator
+        Rubinius::ToolSets::Runtime::Generator.new
       end
       
       def compiled_file_type
@@ -304,17 +292,12 @@ module Myco
       def emit_rb!;  nil end
       def emit_rbc!; nil end
       
-      def initialize *args
-        # TODO: a more elegant solution than env vars
-        raise NotImplementedError if ENV['MYCO_TO_RUBY'] == 'POST'
-        super
-      end
-      
       def make_compiled_code
         begin
           @compiled_code = primitive_load_file \
             @filename, Rubinius::Signature, Rubinius::RUBY_LIB_VERSION
         rescue Rubinius::InvalidRBC => e
+          warn e.message
           File.delete @filename
           raise e
         end

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

@@ -0,0 +1,60 @@
+
+CodeTools::AST << {
+  
+  ArgumentAssembly < Node {
+    var body, var block
+    
+    Form: [:argass, :body]
+    
+    setter body: |given_body| {
+      given_body.last.is_a?(BlockArgument) && (self.block = given_body.pop)
+      given_body
+    }
+    
+    # All items before the first SplatValue
+    pre_group:
+      self.body.take_while |item| { !item.is_a?(SplatValue) }
+    
+    # All items after and including the first SplatValue
+    post_group:
+      self.body.drop_while |item| { !item.is_a?(SplatValue) }
+    
+    # Symbol of bytecode operation to use for send
+    send_op: {
+      self.body.detect |item| { item.is_a?(SplatValue) } &? (
+        :send_with_splat
+      ) ?? (self.block &? (  # TODO: better elsif construction
+        :send_with_block
+      ) ?? (
+        :send
+      ))
+    }
+    
+    # Number of arguments to use for send operation
+    send_count:
+      pre_group.size
+    
+    splat_bytecode: |g| ArrayAssembly.new(
+      line: self.line
+      body: post_group
+    ).bytecode(g)
+    
+    block_bytecode: |g|
+      self.block &? self.block.bytecode(g) ?? g.push_null
+    
+    bytecode: |g| {
+      pos(g)
+      
+      pre_group.each |item| { item.bytecode(g) }
+      
+      send_op == :send_with_splat && (
+        splat_bytecode(g)
+        block_bytecode(g)
+      )
+      send_op == :send_with_block && (
+        block_bytecode(g)
+      )
+    }
+  }
+  
+}

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

@@ -0,0 +1,55 @@
+
+::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition.const_set(:ArgumentAssembly, ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:body, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  declare_meme(:block, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  ::Myco.cscope.for_method_definition.const_set(:Form, ([
+    :argass,
+    :body
+  ]))
+  declare_meme(:body, [[:setter, []]], nil, ::Myco.cscope.dup) { |given_body| (
+    ::Myco.branch_op(:"&&", given_body.last.__send__(
+      :is_a?,
+      ::Myco.find_constant(:BlockArgument)
+    )) {self.__send__(
+      :block=,
+      given_body.pop
+    )}
+    given_body
+  )}
+  declare_meme(:pre_group, [], nil, ::Myco.cscope.dup) { |*| (self.body.take_while { |item| (item.__send__(
+    :is_a?,
+    ::Myco.find_constant(:SplatValue)
+  ).__send__(:!))})}
+  declare_meme(:post_group, [], nil, ::Myco.cscope.dup) { |*| (self.body.drop_while { |item| (item.__send__(
+    :is_a?,
+    ::Myco.find_constant(:SplatValue)
+  ).__send__(:!))})}
+  declare_meme(:send_op, [], nil, ::Myco.cscope.dup) { |*| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.body.detect { |item| (item.__send__(
+    :is_a?,
+    ::Myco.find_constant(:SplatValue)
+  ))}) {:send_with_splat}) {::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.block) {:send_with_block}) {:send}})}
+  declare_meme(:send_count, [], nil, ::Myco.cscope.dup) { |*| (self.pre_group.size)}
+  declare_meme(:splat_bytecode, [], nil, ::Myco.cscope.dup) { |g| (::Myco.find_constant(:ArrayAssembly).new({
+    :line => self.line,
+    :body => self.post_group
+  }).bytecode(g))}
+  declare_meme(:block_bytecode, [], nil, ::Myco.cscope.dup) { |g| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.block) {self.block.bytecode(g)}) {g.push_null})}
+  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+    self.pos(g)
+    self.pre_group.each { |item| (item.bytecode(g))}
+    ::Myco.branch_op(:"&&", self.send_op.__send__(
+      :==,
+      :send_with_splat
+    )) {(
+      self.splat_bytecode(g)
+      self.block_bytecode(g)
+    )}
+    ::Myco.branch_op(:"&&", self.send_op.__send__(
+      :==,
+      :send_with_block
+    )) {self.block_bytecode(g)}
+  )}
+)}})
+.tap { |__c__| __c__.__name__ = :ArgumentAssembly })})}}.instance

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

@@ -0,0 +1,43 @@
+
+CodeTools::AST << {
+  
+  ArrayAssembly < Node {
+    var body
+    
+    Form: [:arrass, :body]
+    
+    bytecode: |g| {
+      pos(g)
+      
+      self.body.empty? &? (
+        g.make_array(0)
+      ) ?? (
+        # Group the self.body into chunks of splats and non-splats
+        chunked = self.body.chunk |item| { item.is_a?(SplatValue) }
+        
+        # Each SplatValue outputs the bytecode of a single array
+        # Non-SplatValues are grouped to output the bytecode of
+        # a single array for each contiguous group.  Along the way, the
+        # arrays are concatenated to form one final array on the stack.
+        first_bytecode = true
+        chunked.each |is_splat_group, group| {
+          is_splat_group &? (
+            group.each |item| {
+              item.bytecode(g)
+              first_bytecode || g.send(:concat, 1)
+              first_bytecode = false
+            }
+          ) ?? (
+            group.each |item| {
+              item.bytecode(g)
+            }
+            g.make_array(group.size)
+            first_bytecode || g.send(:concat, 1)
+            first_bytecode = false
+          )
+        }
+      )
+    }
+  }
+   
+}

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

@@ -0,0 +1,37 @@
+
+::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition.const_set(:ArrayAssembly, ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:body, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  ::Myco.cscope.for_method_definition.const_set(:Form, ([
+    :arrass,
+    :body
+  ]))
+  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+    self.pos(g)
+    ::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", self.body.__send__(:empty?)) {g.make_array(0)}) {(
+      chunked = self.body.chunk { |item| (item.__send__(
+        :is_a?,
+        ::Myco.find_constant(:SplatValue)
+      ))}
+      first_bytecode = true
+      chunked.each { |is_splat_group, group| (::Myco.branch_op(:"??", ::Myco.branch_op(:"&?", is_splat_group) {group.each { |item| (
+        item.bytecode(g)
+        ::Myco.branch_op(:"||", first_bytecode) {g.send(
+          :concat,
+          1
+        )}
+        first_bytecode = false
+      )}}) {(
+        group.each { |item| (item.bytecode(g))}
+        g.make_array(group.size)
+        ::Myco.branch_op(:"||", first_bytecode) {g.send(
+          :concat,
+          1
+        )}
+        first_bytecode = false
+      )})}
+    )}
+  )}
+)}})
+.tap { |__c__| __c__.__name__ = :ArrayAssembly })})}}.instance

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

@@ -0,0 +1,25 @@
+
+CodeTools::AST << {
+  
+  BlockArgument < Node {
+    var body
+    
+    Form: [:blkarg, :body]
+    
+    bytecode: |g| {
+      self.body.bytecode(g)
+      
+      done_label = g.new_label
+      g.dup
+      g.is_nil
+      g.goto_if_true(done_label)
+      
+      g.push_cpath_top; g.find_const(:"Proc")
+        g.swap
+      g.send(:"__from_block__", 1)
+      
+      done_label.set!
+    }
+  }
+  
+}

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

@@ -0,0 +1,26 @@
+
+::Myco::Component.new([::Myco::FileToplevel], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(::Myco.find_constant(:CodeTools)::AST.component_eval {(::Myco.cscope.for_method_definition.const_set(:BlockArgument, ::Myco::Component.new([::Myco.find_constant(:Node)], ::Myco.cscope.for_method_definition, __FILE__, __LINE__)
+.tap { |__c__| __c__.__last__ = __c__.component_eval {(
+  declare_meme(:body, [[:var, []]], nil, ::Myco.cscope.dup) { |*| nil}
+  ::Myco.cscope.for_method_definition.const_set(:Form, ([
+    :blkarg,
+    :body
+  ]))
+  declare_meme(:bytecode, [], nil, ::Myco.cscope.dup) { |g| (
+    self.body.bytecode(g)
+    done_label = g.new_label
+    g.dup
+    g.is_nil
+    g.goto_if_true(done_label)
+    g.push_cpath_top
+    g.find_const(:Proc)
+    g.swap
+    g.send(
+      :__from_block__,
+      1
+    )
+    done_label.__send__(:set!)
+  )}
+)}})
+.tap { |__c__| __c__.__name__ = :BlockArgument })})}}.instance

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

@@ -0,0 +1,104 @@
+
+CodeTools::AST << {
+  
+  BlockLiteral < CodeTools::Compiler::LocalVariables, Node {
+    var parameters, var body
+    var parent # TODO: investigate removing
+    
+    Form: [:blklit, :parameters, :body]
+    
+    CompilerClass: CodeTools::Compiler # TODO: remove this
+    
+    setter parameters: |given| given || ParameterAssembly.new(line:self.line)
+    setter body:      |given| given || NullLiteral.new(line:self.line)
+    
+    locals: self.body.?locals.?body.map(&:value) ?? null
+    
+    block_local?: |name|
+      locals.?include?(name) ?? false
+    
+    module?: false
+    
+    nest_scope: |scope| scope.parent = self
+    
+    # Look up a local variable in this block's scope.
+    search_local: |name| {
+      (variable = self.variables[name]) &? (
+        variable.nested_reference
+      ) ?? (self.block_local?(name) &? (
+        self.new_local(name)
+      ) ?? ((reference = self.parent.search_local(name)) &? (
+        reference.depth = reference.depth + 1
+        reference
+      ) ?? (
+        null
+      )))
+    }
+    
+    # Assign a slot number to a local variable access node.
+    # TODO: remove this method in favor of using search_local in all cases instead.
+    assign_local_reference: |var| {
+      var.variable = (variable = self.variables[var.name]) &? (
+        variable.reference
+      ) ?? (self.block_local?(var.name) &? (
+        variable = self.new_local(var.name)
+        variable.reference
+      ) ?? ((reference = self.parent.search_local(var.name)) &? (
+        reference.depth = reference.depth + 1
+        reference
+      ) ?? (
+        variable = self.new_local(var.name)
+        variable.reference
+      )))
+    }
+    
+    new_local: |name| {
+      self.variables[name] = \
+        self.variables[name] || CompilerClass::LocalVariable.new(allocate_slot)
+    }
+    
+    new_nested_local: |name| new_local(name).nested_reference
+    
+    bytecode: |g| {
+      pos(g)
+      
+      state = g.state
+      state.scope.nest_scope(self)
+      
+      blk = new_block_generator(g, self.parameters)
+      
+      blk.push_state(self)
+      blk.definition_line(self.line)
+      blk.state.push_super(state.super)
+      blk.state.push_eval(state.eval)
+      
+      blk.state.push_name(blk.name)
+      
+      # Push line info down.
+      pos(blk)
+      
+      self.parameters.bytecode(blk)
+      
+      blk.state.push_block
+      blk.push_modifiers
+      blk.break = null
+      blk.next = null
+      blk.redo = blk.new_label
+      blk.redo.set!
+      
+      self.body.bytecode(blk)
+      
+      blk.pop_modifiers
+      blk.state.pop_block
+      blk.ret
+      blk.close
+      blk.pop_state
+      
+      blk.local_count = local_count
+      blk.local_names = local_names
+      
+      g.create_block(blk)
+    }
+  }
+  
+}