myco 0.1.0.dev

data/lib/myco/core/Decorator.my

@@ -0,0 +1,18 @@
+
+::Myco::Decorator < ::Myco::BasicObject {
+  # Implement the apply meme to mutate the incoming meme in more custom ways.
+  # This is run after transforms.apply has already mutated the meme.
+  apply: |meme, *args| { }
+  
+  [transforms]
+  # Implement one of the recognized transform memes to
+  # set the corresponding property of the incoming meme.
+  apply: |meme, *args| {
+    # TODO: make order-agnostic by waiting to assign until all have run
+    self .? target(meme) .tap |x| { meme.target  = x }
+    self .? name(meme)   .tap |x| { meme.name    = x }
+    self .? body(meme)   .tap |x| { meme.body    = x }
+    self .? cache(meme)  .tap |x| { meme.cache   = x }
+    self .? expose(meme) .tap |x| { meme.expose  = x }
+  }
+}

data/lib/myco/core/FileToplevel.my

@@ -0,0 +1,23 @@
+
+::Myco::FileToplevel < ::Myco::Object {
+  # TODO: don't use instance_variable_get
+  dirname:  component.instance_variable_get("@dirname")
+  basename: component.instance_variable_get("@basename")
+  filename: component.instance_variable_get("@filename")
+  
+  [decorators]
+  
+  # Run the code in the given file, ignoring the return value but
+  # importing the constants defined therein into the current namespace.
+  import: Decorator {
+    apply: |meme, *args| {
+      # TODO: shouldn't have to use meme.target here;
+      # should be able to use 'parent' to reach the outer objects
+      # while still referring to distinct instances rather than the originals.
+      load_paths = [meme.target.instance.dirname]
+      scope = meme.target.constant_scope
+      component = Myco.eval_file(meme.name.to_s, load_paths, false, scope)
+      meme.target.include(component)
+    }
+  }
+}

data/lib/myco/core/Object.my

@@ -0,0 +1,24 @@
+
+::Myco::Object < ::Myco::BasicObject {
+  # Send the named signal to all handlers for this object
+  __signal__: |name, *args, &block| {
+    component.ancestors.reverse.each |other| {
+      inst = (component == other) && self || other.instance
+      inst.?decorators.?on.?signal_handlers(name).each |meme| {
+        meme.result_for(self, *args, &block)
+      }
+    }
+  }
+  
+  [decorators]
+  
+  # Register a named signal handler
+  var on: Decorator {
+    storage signal_handlers: Array.new
+    
+    apply: |meme| signal_handlers(meme.name).push(meme)
+    
+    [transforms]
+    expose: false
+  }
+}

data/lib/myco/core/Switch.my

@@ -0,0 +1,31 @@
+
+::Myco::Switch < ::Myco::Object {
+  var input: void
+  var output: void
+  var matched: false
+  var comparator: :"=="
+  
+  when: |expected, &blk| {
+    matched || (input.send(comparator, expected) &&
+      ((matched() = true) && (output() = blk.call(input))))
+    self
+  }
+  
+  when_true: |&blk| {
+    matched || (input &&
+      ((matched() = true) && (output() = blk.call(input))))
+    self
+  }
+  
+  when_false: |&blk| {
+    matched || (input ||
+      ((matched() = true) && (output() = blk.call(input))))
+    self
+  }
+  
+  else: |&blk| {
+    matched ||
+      ((matched() = true) && (output() = blk.call(input)))
+    self
+  }
+}

data/lib/myco/eval.rb

@@ -0,0 +1,63 @@
+
+module Myco
+  
+  # Most of method is stolen from Rubinius implementation of Kernel#eval
+  def self.eval(string, scope=nil, filename=nil, lineno=nil)
+    string = StringValue(string)
+    filename = StringValue(filename) if filename
+    lineno = Rubinius::Type.coerce_to lineno, Fixnum, :to_i if lineno
+    lineno = 1 if filename && !lineno
+    
+    binding = ::Binding.setup(Rubinius::VariableScope.of_sender,
+                              Rubinius::CompiledCode.of_sender,
+                              (scope||Rubinius::ConstantScope.of_sender),
+                              self)
+    
+    filename ||= "(eval)"
+    
+    lineno ||= binding.line_number
+    
+    existing_scope = binding.constant_scope
+    binding.constant_scope = existing_scope.dup
+    
+    c = Myco::ToolSet::Compiler
+    be = c.construct_block string, binding, filename, lineno
+    
+    result = be.call_on_instance(binding.self)
+    binding.constant_scope = existing_scope
+    result
+  end
+  
+  # TODO: replace with proper import set of functions
+  def self.eval_file path, load_paths=nil, get_last=true, scope=nil
+    load_paths ||= [File.dirname(Rubinius::VM.backtrace(1).first.file)]
+    
+    tmp_path = File.expand_path(path)
+    use_path = File.file?(tmp_path) && tmp_path
+    load_paths.each do |load_path|
+      break if use_path
+      tmp_path = File.expand_path(path, load_path)
+      use_path = File.file?(tmp_path) && tmp_path
+    end
+    
+    raise ArgumentError, "Couldn't resolve file: #{path.inspect} \n" \
+                         "in load_paths: #{load_paths.inspect}" \
+      unless use_path
+    
+    file_toplevel = Myco.eval File.read(use_path), scope, use_path, 1
+    get_last ? file_toplevel.component.__last__ : file_toplevel.component
+  end
+  
+  def self.rescue
+    begin
+      yield
+    rescue Exception=>e
+      unless e.is_a? SystemExit
+        puts e.awesome_backtrace.show
+        puts e.awesome_backtrace.first_color + e.message + "\033[0m"
+        puts
+        exit(1)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+
+module CodeTools::AST
+  
+  # Monkey patch original to use methods of ::Myco to lookup 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_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
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+
+module CodeTools::AST
+  
+  module ProcessorMethods
+    def process_cdefn line, name, object
+      ConstantDefine.new line, name, object
+    end
+  end
+  
+  class ConstantDefine < Node
+    attr_accessor :name, :object
+    
+    def initialize line, name, object
+      @line   = line
+      @name   = name
+      @object = object
+      @object.create = false
+    end
+    
+    def to_sexp
+      [:cdefn, @name.name, @object.to_sexp]
+    end
+    
+    def implementation
+      ConstantAssignment.new @line, @name, @object
+    end
+    
+    def bytecode g
+      pos(g)
+      
+      implementation.bytecode g
+      
+      g.dup_top
+        g.push_literal @name.name
+      g.send :__name__=, 1
+      g.pop
+    end
+  end
+  
+end

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

@@ -0,0 +1,47 @@
+
+module CodeTools::AST
+  
+  module ProcessorMethods
+    def process_copen line, name, body
+      ConstantReopen.new 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)
+      
+      attach_and_call g, :__component_init__, true
+    end
+  end
+  
+  class ConstantReopen < Node
+    attr_accessor :name, :body
+    
+    def initialize line, name, body
+      @line   = line
+      @name   = name
+      @body   = body
+    end
+    
+    def to_sexp
+      [:copen, @name.name, @body.to_sexp]
+    end
+    
+    def bytecode g
+      pos(g)
+      
+      scope = ConstantReopenScope.new @line, @body
+      
+      @name.bytecode g
+      scope.bytecode g
+    end
+  end
+  
+end

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

@@ -0,0 +1,51 @@
+
+require_relative 'myco_module_scope'
+
+
+module CodeTools::AST
+  
+  module ProcessorMethods
+    def process_category line, name, body
+      DeclareCategory.new line, name, body
+    end
+  end
+  
+  class DeclareCategoryScope < MycoModuleScope
+    def body_bytecode g
+      g.push_scope
+      g.send :set_myco_category, 0
+      g.pop
+      
+      @body.bytecode g
+    end
+  end
+  
+  class DeclareCategory < Node
+    attr_accessor :name, :body
+    
+    def initialize line, name, body
+      @line = line
+      @name = name
+      @body = body
+    end
+    
+    def to_sexp
+      [:category, @name.value, @body.to_sexp]
+    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
+    end
+  end
+  
+end

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

@@ -0,0 +1,35 @@
+
+module CodeTools::AST
+  
+  module ProcessorMethods
+    def process_deco line, name, arguments
+      DeclareDecorator.new line, name, arguments
+    end
+  end
+  
+  class DeclareDecorator < Node
+    attr_accessor :line, :name, :arguments
+    
+    def initialize line, name, arguments
+      @line      = line
+      @name      = name
+      @arguments = arguments || ArrayLiteral.new(@line, [])
+    end
+    
+    def to_sexp
+      args_sexp = @arguments.to_sexp
+      args_sexp[0] = :arglist
+      sexp = [:deco, @name.value]
+      sexp.push args_sexp unless @arguments.body.empty?
+      sexp
+    end
+    
+    def bytecode g
+      pos(g)
+      
+      ary = ArrayLiteral.new @line, [@name, @arguments]
+      ary.bytecode g
+    end
+  end
+  
+end

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

@@ -0,0 +1,54 @@
+
+module CodeTools::AST
+  
+  module ProcessorMethods
+    def process_declfile line, body
+      DeclareFile.new line, body
+    end
+  end
+  
+  class DeclareFileScope < MycoModuleScope
+    def body_bytecode g
+      g.push_scope
+      g.send :set_myco_file, 0
+      g.pop
+      
+      @body.bytecode g
+    end
+  end
+  
+  class DeclareFile < Node
+    attr_accessor :body
+    
+    # Use minimal inspect to avoid huge inspect output for inner AST nodes
+    # that store a reference to a DeclareFile in an instance variable. 
+    def inspect
+      to_s
+    end
+    
+    def initialize line, body
+      @line = line
+      @body = body
+    end
+    
+    def to_sexp
+      [:declfile, @body.to_sexp]
+    end
+    
+    def implementation
+      myco = ToplevelConstant.new @line, :Myco
+      type = ScopedConstant.new @line, myco, :FileToplevel
+      types = ArrayLiteral.new @line, [type]
+      decl = DeclareObject.new @line, types, @body
+      decl.scope_type = DeclareFileScope
+      decl
+    end
+    
+    def bytecode g
+      pos(g)
+      
+      implementation.bytecode g
+    end
+  end
+  
+end

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

@@ -0,0 +1,44 @@
+
+module CodeTools::AST
+  
+  module ProcessorMethods
+    def process_meme line, name, decorations, arguments, body
+      DeclareMeme.new line, name, decorations, arguments, body
+    end
+  end
+  
+  class DeclareMeme < Define
+    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)
+      @body        = body || NilLiteral.new(line)
+    end
+    
+    def to_sexp
+      [:meme, @name, @decorations.to_sexp, @arguments.to_sexp, @body.to_sexp]
+    end
+    
+    def bytecode(g)
+      pos(g)
+      
+      ##
+      # module = scope.for_method_definition
+      # module.send :declare_meme, @name, @decorations,
+      #   CompiledCode(@body), const_scope, var_scope
+      #
+      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
+    end
+  end
+  
+end

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

@@ -0,0 +1,75 @@
+
+require_relative 'myco_module_scope'
+
+
+module CodeTools::AST
+  
+  module ProcessorMethods
+    def process_declobj line, types, body
+      DeclareObject.new line, types, body
+    end
+  end
+  
+  class DeclareObjectScope < MycoModuleScope
+    def body_bytecode g
+      g.push_scope
+      g.send :set_myco_component, 0
+      g.pop
+      
+      @body.bytecode g
+    end
+  end
+  
+  class DeclareObject < Node
+    attr_accessor :types, :body
+    attr_accessor :create
+    
+    attr_accessor :scope_type
+    
+    def initialize line, types, body
+      @line   = line
+      @types  = types
+      @body   = body
+      
+      @create = true
+      @scope_type = DeclareObjectScope
+    end
+    
+    def to_sexp
+      [:declobj, @types.to_sexp, @body.to_sexp]
+    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
+      g.find_const :Component
+        @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.send :new, 4
+      
+      # The return value of Component.new at the top of the stack
+      # will be consumed by @scope.bytecode, so save two copies of it.
+      g.dup_top # One for sending :__last__= to
+      g.dup_top # One for sending :instance to (or returning, if !@create)
+      
+      # Compile the inner scope,
+      # leaving the last object in the scope at the top of the stack.
+      scope.bytecode g
+      
+      # component.__last__ = (value left on stack from @scope.bytecode)
+      g.send :__last__=, 1
+      g.pop
+      
+      # return (@create ? component.instance : component)
+      g.send :instance, 0 if @create
+    end
+  end
+  
+end

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

@@ -0,0 +1,37 @@
+
+module CodeTools::AST
+  
+  module ProcessorMethods
+    def process_declstr line, types, string
+      DeclareString.new line, types, string
+    end
+  end
+  
+  class DeclareString < Node
+    attr_accessor :types, :string
+    
+    def initialize line, types, string
+      @line   = line
+      @types  = types
+      @string = string
+    end
+    
+    def to_sexp
+      [:declstr, @types.to_sexp, @string.to_sexp]
+    end
+    
+    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
+    end
+    
+    def bytecode g
+      pos(g)
+      
+      implementation.bytecode g
+    end
+  end
+  
+end

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

@@ -0,0 +1,66 @@
+
+module CodeTools::AST
+  
+  module ProcessorMethods
+    def process_invoke line, receiver, name, arguments, *rest
+      Invoke.new line, receiver, name, arguments, *rest
+    end
+  end
+  
+  class Invoke < Node
+    attr_accessor :receiver, :name, :arguments, :block_params, :block
+    
+    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
+      @block_params = block_params
+      @block        = block
+      @block_arg    = block_arg
+    end
+    
+    def bytecode g
+      pos(g)
+      
+      implementation.bytecode(g)
+    end
+    
+    def to_sexp
+      implementation.to_sexp
+    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
+      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
+      end
+    end
+  end
+  
+end

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

@@ -0,0 +1,38 @@
+
+module CodeTools::AST
+  
+  module ProcessorMethods
+    def process_lambig line, name
+      LocalVariableAccessAmbiguous.new line, name
+    end
+  end
+  
+  class LocalVariableAccessAmbiguous < Node
+    attr_accessor :name
+    
+    def initialize line, name
+      @line = line
+      @name = name
+    end
+    
+    def bytecode g
+      pos(g)
+      
+      implementation(g).bytecode(g)
+    end
+    
+    def to_sexp
+      [:lambig, @name]
+    end
+    
+    def implementation g
+      if g.state.scope.variables.has_key? @name
+        LocalVariableAccess.new @line, @name
+      else
+        rcvr = Self.new @line
+        Send.new @line, rcvr, @name, true, true
+      end
+    end
+  end
+  
+end