myco 0.1.0.dev → 0.1.0

data/lib/myco/misc.rb

@@ -0,0 +1,16 @@
+
+module Myco
+  
+  # Logical branching operator with lazy evaluation of right hand
+  def self.branch_op type, left
+    case type
+    when :"&&"; return left if left.false?
+    when :"||"; return left unless left.false?
+    when :"??"; return left unless left.void?
+    when :"&?"; return ::Myco::Void if left.false?
+    when :"|?"; return ::Myco::Void unless left.false?
+    end
+    return yield # evaluate and return right hand
+  end
+  
+end

data/lib/myco/parser/ast/argument_assembly.rb

@@ -0,0 +1,76 @@
+
+module CodeTools::AST
+  
+  module BuilderMethods
+    def argass loc, body
+      ArgumentAssembly.new loc.line, body
+    end
+  end
+  
+  class ArgumentAssembly < Node
+    attr_accessor :body, :block
+    
+    def initialize(line, body, block=nil)
+      @line = line
+      @body = body
+      
+      # TODO: error for multiple block arguments
+      @block = body.pop if body.last.is_a?(BlockPass)
+    end
+    
+    # All items before the first SplatValue
+    def pre_group
+      @body.take_while { |item| !item.is_a?(SplatValue) }
+    end
+    
+    # All items after and including the first SplatValue
+    def post_group
+      @body.drop_while { |item| !item.is_a?(SplatValue) }
+    end
+    
+    # Symbol of bytecode operation to use for send
+    def send_op
+      if @body.detect { |item| item.is_a?(SplatValue) }
+        :send_with_splat
+      elsif @block
+        :send_with_block
+      else
+        :send
+      end
+    end
+    
+    # Number of arguments to use for send operation
+    def send_count
+      pre_group.size
+    end
+    
+    def splat_bytecode(g)
+      ArrayAssembly.new(@line, post_group).bytecode(g)
+    end
+    
+    def block_bytecode(g)
+      @block ? @block.bytecode(g) : g.push_nil
+    end
+    
+    def bytecode(g)
+      pos(g)
+      
+      pre_group.each { |item| item.bytecode(g) }
+      
+      case send_op
+      when :send_with_splat
+        splat_bytecode(g)
+        block_bytecode(g)
+      when :send_with_block
+        block_bytecode(g)
+      end
+    end
+    
+    def to_sexp
+      sexp = [:arglist] + @body.map(&:to_sexp)
+      sexp.push(@block.to_sexp) if @block
+      sexp
+    end
+  end
+   
+end

data/lib/myco/parser/ast/array_assembly.rb

@@ -0,0 +1,57 @@
+
+module CodeTools::AST
+  
+  module BuilderMethods
+    def arrass loc, body
+      ArrayAssembly.new loc.line, body
+    end
+  end
+  
+  class ArrayAssembly < Node
+    attr_accessor :body
+    
+    def initialize(line, body)
+      @line = line
+      @body = body
+    end
+    
+    def bytecode(g)
+      pos(g)
+      
+      if @body.empty?
+        g.make_array(0)
+        return
+      end
+      
+      # Group the @body into chunks of splats and non-splats
+      chunked = @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 do |is_splat_group, group|
+        if is_splat_group
+          group.each { |item|
+            item.bytecode(g)
+            g.send(:concat, 1) unless first_bytecode
+            first_bytecode = false
+          }
+        else
+          group.each { |item|
+            item.bytecode(g)
+          }
+          g.make_array(group.size)
+          g.send(:concat, 1) unless first_bytecode
+          first_bytecode = false
+        end
+      end
+    end
+    
+    def to_sexp
+      [:array] + @body.map(&:to_sexp)
+    end
+  end
+   
+end

data/lib/myco/parser/ast/branch_operator.rb

@@ -0,0 +1,73 @@
+
+module CodeTools::AST
+  
+  module BuilderMethods
+    def branch_op loc, type, left, right
+      BranchOperator.new loc.line, type, left, right
+    end
+  end
+  
+  class BranchOperator < Node
+    attr_accessor :type
+    attr_accessor :left
+    attr_accessor :right
+    
+    def initialize line, type, left, right
+      @line  = line
+      @type  = type
+      @left  = left
+      @right = right
+    end
+    
+    def bytecode g
+      pos(g)
+      
+      done_label = g.new_label
+      right_label = g.new_label
+      can_push_void = false
+      
+      @left.bytecode(g)
+      
+      case type
+      when :"&&"
+        g.dup_top
+        g.send :false?, 0
+        g.goto_if_true done_label
+        g.pop
+      when :"||"
+        g.dup_top
+        g.send :false?, 0
+        g.goto_if_false done_label
+        g.pop
+      when :"??"
+        g.dup_top
+        g.send :void?, 0
+        g.goto_if_false done_label
+        g.pop
+      when :"&?"
+        g.send :false?, 0
+        g.goto_if_false right_label
+        otherwise_push_void = true
+      when :"|?"
+        g.send :false?, 0
+        g.goto_if_true right_label
+        otherwise_push_void = true
+      end
+      
+      if otherwise_push_void
+        g.push_void
+        g.goto done_label
+        
+        right_label.set!
+      end
+      
+      @right.bytecode(g)
+      done_label.set!
+    end
+    
+    def to_sexp
+      [:branch_op, @type, @left.to_sexp, @right.to_sexp]
+    end
+  end
+  
+end

data/lib/myco/parser/ast/constant_access.rb

@@ -1,29 +1,15 @@
 
 module CodeTools::AST
-  
-  # Monkey patch original to use methods of ::Myco to lookup constants
+  # Monkey patch original to use ::Myco to look up constants
   class ConstantAccess
     def bytecode(g)
       pos(g)
       
-      if g.state.op_asgn? # TODO: is this branch unnecessary with Myco AST?
-        g.push_cpath_top
-        g.find_const :Myco
+      g.push_cpath_top
+      g.find_const :Myco
         g.push_literal @name
         g.push_scope
-        g.send :find_constant_for_op_asign_or, 2
-      else
-        if @top_level
-          g.push_cpath_top
-          g.find_const @name
-        else
-          g.push_cpath_top
-          g.find_const :Myco
-          g.push_literal @name
-          g.push_scope
-          g.send :find_constant, 2
-        end
-      end
+      g.send :find_constant, 2
     end
   end
 end

data/lib/myco/parser/ast/constant_define.rb

@@ -1,9 +1,9 @@
 
 module CodeTools::AST
   
-  module ProcessorMethods
-    def process_cdefn line, name, object
-      ConstantDefine.new line, name, object
+  module BuilderMethods
+    def cdefn loc, name, object
+      ConstantDefine.new loc.line, name, object
     end
   end
   

data/lib/myco/parser/ast/constant_reopen.rb

@@ -1,23 +1,22 @@
 
+require_relative 'myco_module_scope'
+
+
 module CodeTools::AST
   
-  module ProcessorMethods
-    def process_copen line, name, body
-      ConstantReopen.new line, name, body
+  module BuilderMethods
+    def copen loc, name, body
+      ConstantReopen.new loc.line, name, body
     end
   end
   
-  class ConstantReopenScope < ModuleScope
-    def initialize(line, body)
-      @line = line
-      @name = :ConstantReopenScope # TODO: remove/fix
-      @body = body
-    end
-    
-    def bytecode(g)
-      pos(g)
+  class ConstantReopenScope < MycoModuleScope
+    def body_bytecode g
+      g.push_scope
+      g.send :set_myco_component, 0
+      g.pop
       
-      attach_and_call g, :__component_init__, true
+      @body.bytecode g
     end
   end
   

data/lib/myco/parser/ast/declare_category.rb

@@ -4,9 +4,9 @@ require_relative 'myco_module_scope'
 
 module CodeTools::AST
   
-  module ProcessorMethods
-    def process_category line, name, body
-      DeclareCategory.new line, name, body
+  module BuilderMethods
+    def category loc, name, body
+      DeclareCategory.new loc.line, name, body
     end
   end
   
@@ -33,18 +33,20 @@ module CodeTools::AST
       [:category, @name.value, @body.to_sexp]
     end
     
+    def scope_implementation
+      DeclareCategoryScope.new @line, @body
+    end
+    
     def bytecode g
       pos(g)
       
-      scope = DeclareCategoryScope.new @line, @body
-      
       ##
       # category = self.__category__ @name
       g.push_self
         g.push_literal @name.value
       g.send :__category__, 1
       
-      scope.bytecode g
+      scope_implementation.bytecode g
     end
   end
   

data/lib/myco/parser/ast/declare_decorator.rb

@@ -1,9 +1,9 @@
 
 module CodeTools::AST
   
-  module ProcessorMethods
-    def process_deco line, name, arguments
-      DeclareDecorator.new line, name, arguments
+  module BuilderMethods
+    def deco loc, name, arguments
+      DeclareDecorator.new loc.line, name, arguments
     end
   end
   
@@ -13,7 +13,7 @@ module CodeTools::AST
     def initialize line, name, arguments
       @line      = line
       @name      = name
-      @arguments = arguments || ArrayLiteral.new(@line, [])
+      @arguments = arguments || ArrayAssembly.new(@line, [])
     end
     
     def to_sexp

data/lib/myco/parser/ast/declare_file.rb

@@ -1,9 +1,9 @@
 
 module CodeTools::AST
   
-  module ProcessorMethods
-    def process_declfile line, body
-      DeclareFile.new line, body
+  module BuilderMethods
+    def declfile loc, body
+      DeclareFile.new loc.line, body
     end
   end
   
@@ -38,7 +38,7 @@ module CodeTools::AST
     def implementation
       myco = ToplevelConstant.new @line, :Myco
       type = ScopedConstant.new @line, myco, :FileToplevel
-      types = ArrayLiteral.new @line, [type]
+      types = ArrayAssembly.new @line, [type]
       decl = DeclareObject.new @line, types, @body
       decl.scope_type = DeclareFileScope
       decl

data/lib/myco/parser/ast/declare_meme.rb

@@ -1,20 +1,58 @@
 
 module CodeTools::AST
   
-  module ProcessorMethods
-    def process_meme line, name, decorations, arguments, body
-      DeclareMeme.new line, name, decorations, arguments, body
+  module BuilderMethods
+    def meme loc, name, decorations, arguments, body
+      DeclareMeme.new loc.line, name, decorations, arguments, body
     end
   end
   
-  class DeclareMeme < Define
+  class DeclareMemeBody < Iter
+    attr_accessor :name
+    
+    def bytecode(g)
+      pos(g)
+      
+      g.state.scope.nest_scope self
+      
+      meth = new_generator g, @name, @arguments
+      
+      meth.push_state self
+      meth.state.push_super self
+      meth.definition_line @line
+      
+      meth.state.push_name @name
+      
+      @arguments.bytecode meth
+      @body.bytecode meth
+      
+      meth.state.pop_name
+      
+      meth.local_count = local_count
+      meth.local_names = local_names
+      meth.splat_index = @arguments.splat_index
+      
+      meth.ret
+      meth.close
+      meth.pop_state
+      
+      g.push_scope
+      g.send :for_method_definition, 0
+      g.add_scope
+      
+      # Create the BlockEnvironment from the meth Generator
+      g.create_block meth
+    end
+  end
+  
+  class DeclareMeme < Node
     attr_accessor :name, :decorations, :arguments, :body
     
     def initialize line, name, decorations, arguments, body
       @line        = line
       @name        = name.value
-      @decorations = decorations || ArrayLiteral.new(line, [])
-      @arguments   = arguments || Parameters.new(line, [], nil, false, nil, nil, nil, nil)
+      @decorations = decorations || ArrayAssembly.new(line, [])
+      @arguments   = arguments || Parameters.new(line, [], nil, true, nil, nil, nil, nil)
       @body        = body || NilLiteral.new(line)
     end
     
@@ -22,22 +60,26 @@ module CodeTools::AST
       [:meme, @name, @decorations.to_sexp, @arguments.to_sexp, @body.to_sexp]
     end
     
+    def body_implementation
+      meme_body = DeclareMemeBody.new(@line, @arguments, @body)
+      meme_body.name = @name
+      meme_body
+    end
+    
     def bytecode(g)
       pos(g)
       
       ##
       # module = scope.for_method_definition
       # module.send :declare_meme, @name, @decorations,
-      #   CompiledCode(@body), const_scope, var_scope
+      #   BlockEnvironment(body_implementation)
       #
       g.push_scope
       g.send :for_method_definition, 0
         g.push_literal @name
         @decorations.bytecode g
-        g.push_generator compile_body(g)
-        g.push_scope
-        g.push_variables
-      g.send :declare_meme, 5
+        body_implementation.bytecode(g)
+      g.send :declare_meme, 3
     end
   end
   

data/lib/myco/parser/ast/declare_object.rb

@@ -4,9 +4,9 @@ require_relative 'myco_module_scope'
 
 module CodeTools::AST
   
-  module ProcessorMethods
-    def process_declobj line, types, body
-      DeclareObject.new line, types, body
+  module BuilderMethods
+    def declobj loc, types, body
+      DeclareObject.new loc.line, types, body
     end
   end
   
@@ -39,11 +39,13 @@ module CodeTools::AST
       [:declobj, @types.to_sexp, @body.to_sexp]
     end
     
+    def scope_implementation
+      @scope_type.new @line, @body
+    end
+    
     def bytecode g
       pos(g)
       
-      scope = @scope_type.new @line, @body
-      
       # ::Myco::Component.new types, parent, filename
       g.push_cpath_top
       g.find_const :Myco
@@ -51,7 +53,7 @@ module CodeTools::AST
         @types.bytecode g
         g.push_scope; g.send :for_method_definition, 0
         g.push_scope; g.send :active_path, 0; g.meta_to_s
-        g.push_literal @line
+        g.push_int @line
       g.send :new, 4
       
       # The return value of Component.new at the top of the stack
@@ -61,7 +63,7 @@ module CodeTools::AST
       
       # Compile the inner scope,
       # leaving the last object in the scope at the top of the stack.
-      scope.bytecode g
+      scope_implementation.bytecode g
       
       # component.__last__ = (value left on stack from @scope.bytecode)
       g.send :__last__=, 1

data/lib/myco/parser/ast/declare_string.rb

@@ -1,9 +1,9 @@
 
 module CodeTools::AST
   
-  module ProcessorMethods
-    def process_declstr line, types, string
-      DeclareString.new line, types, string
+  module BuilderMethods
+    def declstr loc, types, string
+      DeclareString.new loc.line, types, string
     end
   end
   
@@ -23,8 +23,8 @@ module CodeTools::AST
     def implementation
       blk   = NilLiteral.new @line
       obj   = DeclareObject.new @line, @types, blk
-      args  = ArrayLiteral.new @string.line, [@string]
-      SendWithArguments.new @string.line, obj, :from_string, args
+      args  = ArgumentAssembly.new @string.line, [@string]
+      InvokeMethod.new @string.line, obj, :from_string, args
     end
     
     def bytecode g

data/lib/myco/parser/ast/invoke.rb

@@ -1,30 +1,27 @@
 
 module CodeTools::AST
   
-  module ProcessorMethods
-    def process_invoke line, receiver, name, arguments, *rest
-      Invoke.new line, receiver, name, arguments, *rest
+  module BuilderMethods
+    def invoke loc, receiver, name, arguments, *rest
+      Invoke.new loc.line, receiver, name, arguments, *rest
     end
   end
   
   class Invoke < Node
-    attr_accessor :receiver, :name, :arguments, :block_params, :block
+    attr_accessor :receiver, :name, :arguments
     
     def initialize line, receiver, name, arguments, block_params=nil, block=nil
-      block_arg = nil
-      if arguments.is_a? BlockPass
-        block_arg = arguments
-        arguments = block_arg.arguments
-        block_arg.arguments = nil
-      end
+      @line      = line
+      @receiver  = receiver
+      @name      = name
+      @arguments = arguments
       
-      @line         = line
-      @receiver     = receiver
-      @name         = name
-      @arguments    = arguments
-      @block_params = block_params
-      @block        = block
-      @block_arg    = block_arg
+      if block
+        # TODO: error if passing both block argument and block literal
+        # Currently, this fails silently and ignores the block argument
+        @arguments ||= ArgumentAssembly.new(line, [])
+        @arguments.block = Iter.new(line, block_params, block)
+      end
     end
     
     def bytecode g
@@ -38,27 +35,12 @@ module CodeTools::AST
     end
     
     def implementation
-      if @block.nil? && @block_arg.nil?
-        if @arguments.nil?
-          if @receiver.nil?
-            LocalVariableAccessAmbiguous.new @line, @name
-          else
-            Send.new @line, @receiver, @name
-          end
-        else
-          rcvr = @receiver || Self.new(@line)
-          send = SendWithArguments.new @line, rcvr, @name, @arguments
-          send
-        end
+      if @receiver.nil? && @arguments.nil?
+        LocalVariableAccessAmbiguous.new(@line, @name)
       else
         rcvr = @receiver || Self.new(@line)
-        send = SendWithArguments.new @line, rcvr, @name, @arguments
-        if @block
-          send.block = Iter.new @line, @block_params, @block
-        elsif @block_arg
-          send.block = @block_arg
-        end
-        send
+        args = @arguments || ArgumentAssembly.new(line, [])
+        InvokeMethod.new @line, rcvr, @name, args
       end
     end
   end

data/lib/myco/parser/ast/invoke_method.rb

@@ -0,0 +1,28 @@
+
+module CodeTools::AST
+  
+  class InvokeMethod < Node
+    attr_accessor :line, :receiver, :name, :arguments
+    
+    def initialize line, receiver, name, arguments
+      @line      = line
+      @receiver  = receiver
+      @name      = name
+      @arguments = arguments
+    end
+    
+    def bytecode(g)
+      @receiver.bytecode(g)
+      @arguments.bytecode(g)
+      
+      pos(g)
+      
+      g.__send__(@arguments.send_op, @name, @arguments.send_count)
+    end
+    
+    def to_sexp
+      [:call, @receiver.to_sexp, @name, @arguments.to_sexp]
+    end
+  end
+  
+end