verneuil 0.1.0 → 0.2.0

data/HISTORY.txt

@@ -1,3 +1,7 @@
+== 0.2.0 / ???
+  
+  * Call 'verneuil' with your code as argument to execute a script in V. 
+
 == 0.1.0 / 8Feb11
 
   * Initial version, supporting a rather large subset of ruby already. 

data/README

@@ -6,7 +6,8 @@ rubies - they are too pure and don't have the characteristics of real ones.
 
 This is a virtual machine that:
   * executes something that is almost Ruby (it looks like it)
-  * and that can store its state to disk. And resume.
+  * and that can store its state to disk. And resume. 
+    Think: Continuations. Serializable.
 
 Is it useful? That depends. You could for example use this to
   * script website interaction with your user
@@ -28,9 +29,6 @@ SYNOPSIS
   
 STATUS
 
-At version pre 0.1 and by no means ready for production. May or may not work, 
-depending on time of day. 
-
 Verneuil currently handles all the programs in spec/programs. The following
 Ruby features should work: 
 
@@ -41,5 +39,14 @@ Ruby features should work:
  * while
  * Masking class methods 
  * correct self
-
+ * fork, join
+ 
+Currently this project lays sleeping for a few months - until I will need it
+again. That day is sure to come. 
+ 
+CONTRIBUTORS
+
+Florian Hanke (florianhanke.com)
+Kaspar Schiess (absurd.li)
+ 
 (c) 2011 Kaspar Schiess

data/Rakefile

@@ -23,7 +23,7 @@ task :default => :spec
 # end
 
 desc 'Clear out RDoc'
-task :clean => [:clobber_rdoc, :clobber_package]
+task :clean => [:clobber_package]
 
 # This task actually builds the gem. 
 spec = eval(File.read('verneuil.gemspec'))

data/bin/verneuil

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.dirname(__FILE__) + "/../lib"
+require 'verneuil'
+
+verbose = false
+if ARGV.first == '-v'
+  verbose = true 
+  ARGV.shift
+end
+
+program = Verneuil::Compiler.compile(ARGF.read).program
+if verbose
+  p program
+  puts
+end
+
+process = Verneuil::Process.new(program, nil)
+retval = process.run
+
+if verbose
+  puts
+  puts "Program returned #{retval.inspect}." 
+end

data/lib/verneuil.rb

@@ -5,6 +5,7 @@ end
 
 require 'verneuil/address'
 require 'verneuil/method'
+require 'verneuil/symbol_table'
 require 'verneuil/block'
 require 'verneuil/program'
 
@@ -13,3 +14,4 @@ require 'verneuil/compiler'
 
 require 'verneuil/scope'
 require 'verneuil/process'
+require 'verneuil/process_group'

data/lib/verneuil/address.rb

@@ -2,7 +2,7 @@
 class Verneuil::Address
   attr_accessor :ip
   
-  def initialize(ip, generator)
+  def initialize(ip, generator=nil)
     @ip = ip
     @generator = generator
   end

data/lib/verneuil/block.rb

@@ -2,18 +2,22 @@
 # Abstracts the notion of a block.
 #
 class Verneuil::Block
-  def initialize(adr, process, scope)
-    @adr      = adr
+  # At what address does the block code start?
+  attr_reader :address
+  attr_reader :scope
+  
+  def initialize(address, process, scope)
+    @address  = address
     @process  = process
     @scope    = scope
   end
   
   def call(*args)
-    @process.enter_block(args, @adr, @scope)
+    @process.enter_block(args, @address, @scope)
     throw :verneuil_code
   end
   
   def inspect
-    "block@#{@adr.ip}(#{@scope.inspect})"
+    "block@#{@address.ip}(#{@scope.inspect})"
   end
 end

data/lib/verneuil/compiler.rb

@@ -13,7 +13,8 @@ class Verneuil::Compiler
   end
   
   def self.compile(*args)
-    new.compile(*args)
+    new.
+      tap { |compiler| compiler.compile(*args) }
   end
     
   # Compiles a piece of code within the current program. This means that any
@@ -55,11 +56,34 @@ class Verneuil::Compiler
       raise NotImplementedError, "No acceptor for #{sexp}." \
         unless respond_to? sym
 
-      self.send(sym, *args)
+      begin
+        self.send(sym, *args)
+      rescue ArgumentError => ex
+        if md=ex.message.match(/wrong number of arguments \(([^)]+)\)/)
+          sexp_skeleton = s(sexp[0], *sexp[1..-1].map { |e| e && s(e.first, '...') })
+          raise ArgumentError, "wrong number of elements in #{sexp_skeleton} (#{md[1]})."
+        end
+        raise
+      end
     end
     
     #--------------------------------------------------------- visitor methods
     
+    # s(:colon2, s(:const, :Verneuil), :Process) - access something inside
+    # a namespace. Constants are resolved at compile time!
+    #
+    def accept_colon2(left, right)
+      left_const = visit(left)
+      const = left_const.const_get(right)
+      @generator.load const
+    end
+    
+    # s(:const, :Verneuil) - Resolve a constant globally and return it. 
+    #
+    def accept_const(const)
+      eval(const.to_s)
+    end
+    
     # s(:call, RECEIVER, NAME, ARGUMENTS) - Method calls with or without
     # receiver.
     # 
@@ -105,6 +129,14 @@ class Verneuil::Compiler
       @generator.load value
     end
 
+    # s(:array, ELEMENTS) - array literal. 
+    # 
+    def accept_array(*elements)
+      elements.each { |el| visit(el) }
+      @generator.load Array
+      @generator.ruby_call :"[]", elements.size
+    end
+
     # s(:if, COND, THEN, ELSE) - an if statement
     #
     def accept_if(cond, _then, _else)
@@ -157,14 +189,20 @@ class Verneuil::Compiler
     
     # s(:defined, s(:lvar, :a)) - test if a local variable is defined. 
     #
-    def accept_defined(variable)
-      type, var = variable
-      
-      raise NotImplementedError, "defined? only defined for local variables." \
-        unless type == :lvar
-
-      # assert: type == :lvar
-      @generator.test_lvar var
+    def accept_defined(exp)
+      type, * = exp
+      case type
+        when :call
+          # s(:call, nil, :a, s(:arglist))
+          @generator.test_defined exp[2]
+        when :lvar
+          # s(:lvar, :a)
+          @generator.test_defined exp.last
+        when :lit
+          @generator.load 'expression'
+      else
+        fail "Don't know how to implement defined? with #{variable.inspect}."
+      end
     end
     
     # s(:lasgn, VARIABLE, VALUE) - assignment of local variables. 
@@ -195,10 +233,11 @@ class Verneuil::Compiler
       adr_end = @generator.fwd_adr
       @generator.jump adr_end
       
-      @generator.program.add_method(
+      method = Verneuil::Method.new(
         @class_context.last, 
         name, 
         @generator.current_adr)
+      @generator.program.symbols.add(method)
 
       # Enters a new local scope and defines arguments
       visit(args)
@@ -256,7 +295,7 @@ class Verneuil::Compiler
     # s(:iter, s(:call, RECEIVER, METHOD, ARGUMENTS), ASSIGNS, BLOCK) - call
     # a method with a block. 
     #
-    def accept_iter(call, assigns, block)
+    def accept_iter(call, assigns, block=nil)
       # Jump over the block code
       adr_end_of_block = @generator.fwd_adr
       @generator.jump adr_end_of_block
@@ -269,7 +308,7 @@ class Verneuil::Compiler
           unless type == :lasgn
         accept_args(*names)
       end
-      visit(block)
+      visit(block) if block
       @generator.return 
 
       adr_end_of_block.resolve
@@ -298,6 +337,11 @@ class Verneuil::Compiler
     def accept_self
       @generator.load_self
     end
-    
+   
+    # nil
+    #
+    def accept_nil
+      @generator.load nil
+    end
   end
 end

data/lib/verneuil/kernel/fork.rb

@@ -0,0 +1,14 @@
+
+# Fork the current Verneuil process. Returns the new process instance to the
+# caller; never exits the block in the child. 
+#
+# Example: (V-code)
+#   child = fork do 
+#     # do forked stuff here
+#   end
+#
+Verneuil::Process.kernel_method nil, :fork do |process, _|
+  block = process.current_block
+
+  process.fork_child(block)
+end

data/lib/verneuil/kernel/process_join.rb

@@ -0,0 +1,15 @@
+
+# Joins the V-process. This means that the joining process will be stopped
+# until the joinee halts. Returns the process return value. 
+#
+# Running this method only makes sense on childs of the current process. 
+#
+# Example: 
+#   child = fork { ...; 42 }
+#   child.join # waits and eventually returns 42
+#
+Verneuil::Process.kernel_method :'Verneuil::Process', :join do |parent, child|
+  parent.joining << child
+  
+  nil
+end

data/lib/verneuil/method.rb

@@ -2,4 +2,12 @@
 # Represents a method that can be called. 
 #
 class Verneuil::Method < Struct.new(:receiver, :name, :address)
+  def invoke(process, recv_obj)
+    if receiver
+      process.call address, recv_obj
+    else
+      process.call address
+    end
+    throw :verneuil_code
+  end
 end

data/lib/verneuil/process.rb

@@ -21,7 +21,20 @@ class Verneuil::Process
     @ip = 0
     # Should we stop immediately? Cannot restart after setting this. 
     @halted = false
+    # This process' children
+    @children = []
+    # The list of processes that this process waits for currently. 
+    @joining = []
   end
+
+  # Instruction pointer
+  attr_accessor :ip
+  
+  # A process is also a process group, containing its children. 
+  attr_reader :children
+  
+  # The list of processes that this process waits for currently. 
+  attr_reader :joining
   
   # Runs the program until it completes and returns the last expression
   # in the program.
@@ -31,29 +44,64 @@ class Verneuil::Process
       step
     end
     
-    @stack.last
+    value
   end
   
-  # Runs one instruction and returns nil. If this was the last instruction, 
-  # it returns the programs return value. 
+  # Runs one instruction. If the current process waits on another process
+  # (joining not empty), it will run an instruction in the other process
+  # instead.
   #
   def step
-    # old_ip = @ip
-
+    verify_wait_conditions if waiting?
+    
+    # If we're still waiting for someone, let's give them a little shove. 
+    if waiting?
+      joining.first.step
+      return 
+    end
+    
     instruction = fetch_and_advance
     dispatch(instruction)
   
-    # p [old_ip, instruction, @stack, current_scope, @call_stack]
+    # p [self, instruction, @stack, @call_stack, current_scope]
     
-    instr_halt if @ip >= @program.size
-    
-    halted? ? @stack.last : nil
+    # If we just ran into uncharted memory - and we're not still waiting
+    # for someone - we'll just stop the machine.
+    instr_halt if !waiting? && !instruction_pointer_valid?
   end
   
   # Returns true if the process has halted because it has reached its end.
   #
   def halted?
-    !!@halted
+    @halted
+  end
+
+  # Returns true if the process waits for something to happen.
+  #
+  def waiting?
+    not @joining.empty?
+  end
+  
+  # Once the process has halted?, this returns the top of the stack. This is 
+  # like the return value of the process. 
+  #
+  def value
+    @stack.last
+  end
+  
+  # Internal helper methods --------------------------------------------------
+  
+  # Checks if the conditions that make this process wait still apply. This may
+  # clear up the wait state so that waiting? changes value after this method.
+  #
+  def verify_wait_conditions
+    @joining.delete_if { |process| process.halted? }
+  end
+  
+  # Returns the process group having this process as root node. 
+  #
+  def group
+    @group ||= Verneuil::ProcessGroup.new(self)
   end
   
   # Fetches the next instruction and advances @ip.
@@ -61,7 +109,7 @@ class Verneuil::Process
   def fetch_and_advance
     # Pretends that the memory beyond the current space is filled with :halt
     # instructions.
-    return :halt if @ip >= @program.size
+    return :halt unless instruction_pointer_valid?
     
     instruction = @program[@ip]
     @ip += 1
@@ -70,7 +118,7 @@ class Verneuil::Process
   end
   
   # Decodes the instruction into opcode and arguments and calls a method
-  # on this instance called opcode_OPCODE giving the arguments as method 
+  # on this instance called instr_OPCODE giving the arguments as method 
   # arguments. 
   #
   def dispatch(instruction)
@@ -103,7 +151,7 @@ class Verneuil::Process
   def scope(context)
     Verneuil::Scope.new(context)
   end
-  
+    
   # Returns the currently active scope. 
   #
   def current_scope
@@ -129,13 +177,92 @@ class Verneuil::Process
   end
 
   # Calls the given address. (like a jump, but puts something on the return
-  # stack)
+  # stack) If context is left empty, it will call inside the current context.
   #
   def call(adr, context=nil)
     @scopes.push scope(context || current_scope.context)
     @call_stack.push @ip
     jump adr
   end
+    
+  # Looks up a method in internal tables. 
+  #
+  def lookup_method(receiver, name)
+    [
+      @program.symbols, 
+      self.class.symbols
+    ].each do |table|
+      method = table.lookup_method(receiver, name)
+      return method if method
+    end
+    return nil
+  end
+
+  # Returns the currently active block or nil if no such block is available. 
+  #
+  def current_block
+    @blocks.last
+  end
+  
+  # Forks a new process that starts its execution at address and that halts 
+  # when encountering a 'return' instruction. Returns that new process 
+  # instance. 
+  #
+  # The newly created child process is also stored in this process' children
+  # array. You can run the process and all of its children by calling 
+  #
+  #   process.group.run
+  #
+  def fork_child(block)
+    child = Verneuil::Process.new(@program, nil)
+    child.run_block(block)
+    
+    @children << child
+    
+    return child
+  end
+  
+  # Confines execution to a single method. This means setting up the return
+  # stack to return into nirvana once the VM reaches a 'return' instruction. 
+  #
+  def run_block(block)
+    @call_stack.push(-1)
+    jump block.address
+
+    @scopes = [block.scope]
+  end
+  
+  # True if the current instruction pointer is valid. 
+  #
+  def instruction_pointer_valid?
+    @ip >= 0 && 
+      @ip < @program.size
+  end
+
+  # Inspection of processes
+  #
+  def inspect
+    "process(#{object_id}, #{@ip}, #{@call_stack}, w:#{@joining.size}, c:#{children.size}, h:#{halted?})"
+  end
+
+  # Try to dispatch a method call to a method defined inside the Verneuil 
+  # VM. There are currently two kinds of methods in this category: 
+  #
+  #   * Kernel methods
+  #   * Methods implemented in V
+  #
+  def dispatch_to_verneuil(receiver, name)
+    if v_method = lookup_method(receiver, name)
+      catch(:verneuil_code) {
+        retval = v_method.invoke(self, receiver)
+        @stack.push retval
+      } 
+      return true
+    end
+    
+    return false
+  end
+  
 
   # VM Implementation --------------------------------------------------------
   
@@ -149,11 +276,7 @@ class Verneuil::Process
     end
     
     # Verneuil method?
-    v_method = @program.lookup_method(nil, name)
-    if v_method
-      call v_method.address
-      return
-    end
+    return if dispatch_to_verneuil(nil, name)
     
     # Ruby method! (or else)
     args = @stack.pop(argc)
@@ -164,15 +287,14 @@ class Verneuil::Process
   #
   def instr_ruby_call(name, argc)
     receiver = @stack.pop
+    
+    # TODO Fix argument count handling
+    # Currently the caller decides with how many arguments he calls the
+    # block and the callee pops off the stack what he wants. This is not a
+    # good situation.
 
     # Verneuil method? (class method mask)
-    v_method = @program.lookup_method(
-      receiver.class.name.to_sym, 
-      name)
-    if v_method
-      call v_method.address, receiver
-      return
-    end
+    return if dispatch_to_verneuil(receiver, name)
     
     # Must be a Ruby method then. The catch allows internal classes like 
     # Verneuil::Block to skip the stack.push.
@@ -231,7 +353,7 @@ class Verneuil::Process
 
   # Tests if the local variable exists. Puts true/false to the stack. 
   #
-  def instr_test_lvar(name)
+  def instr_test_defined(name)
     @stack.push current_scope.defined?(name)
   end
 
@@ -246,7 +368,10 @@ class Verneuil::Process
   # Pushes a block context to the block stack. 
   #
   def instr_push_block(block_adr)
-    @blocks.push Verneuil::Block.new(block_adr, self, current_scope)
+    @blocks.push Verneuil::Block.new(
+      block_adr, 
+      self, 
+      current_scope.child)
   end
 
   # Loads the currently set implicit block to the stack. This is used when
@@ -255,7 +380,7 @@ class Verneuil::Process
   #
   def instr_load_block
     fail "BUG: No implicit block!" if @blocks.empty?
-    @stack.push @blocks.last
+    @stack.push current_block
   end
   
   # Unloads a block
@@ -279,4 +404,9 @@ class Verneuil::Process
     @stack.push current_scope.context
   end
   
-end
+end
+
+require 'verneuil/process/kernel_methods'
+
+require 'verneuil/kernel/fork'
+require 'verneuil/kernel/process_join'

data/lib/verneuil/process/kernel_methods.rb

@@ -0,0 +1,30 @@
+class Verneuil::Process
+  # A kernel method points to a Ruby method somewhere.
+  #
+  class KernelMethod < Struct.new(:receiver, :name, :method)
+    def invoke(process, receiver)
+      method.call(process, receiver)
+    end
+  end
+  
+  # Extends the Process' class with methods that allow managing kernel methods. 
+  #
+  class <<self
+    # The VMs own kernel method table. 
+    # 
+    def symbols
+      @symbols ||= Verneuil::SymbolTable.new
+    end
+    
+    # Registers a kernel method. These methods have precedence over the 
+    # Ruby bridge, but can still be overridden by user methods. 
+    #
+    def kernel_method(klass_name, method_name, &method_definition)
+      symbols.add(
+        KernelMethod.new(
+          klass_name, 
+          method_name, 
+          method_definition))
+    end
+  end
+end

data/lib/verneuil/process_group.rb

@@ -0,0 +1,57 @@
+# A group of processes identified by their root process. 
+#
+class Verneuil::ProcessGroup
+  def initialize(root)
+    @root = root
+    @counter = 0
+  end
+  
+  # Make our root conform to the interface group#step implements.
+  class Root < Struct.new(:process)
+    def step
+      process.step
+      return true
+    end
+    
+    def halted?
+      process.halted?
+    end
+  end
+  
+  # Steps one of the processes in this group once. Returns true if all child 
+  # process groups have made one step. 
+  #
+  def step
+    list = processes
+    idx =  @counter % list.size
+    
+    if list[idx].step
+      # Child tree has finished 'one round' of stepping, carry over 
+      @counter += 1
+    end
+    
+    # Should we return a carry to our parent?
+    if @counter >= list.size
+      @counter = 0
+      return true
+    end
+    
+    return false
+  end
+  
+  # Runs this process group until all processes have halted.
+  #
+  def run
+    until halted?
+      step
+    end
+  end
+
+  def halted?
+    processes.all? { |p| p.halted? }
+  end
+  
+  def processes
+    [Root.new(@root)] + @root.children.map { |p| p.group }
+  end
+end

data/lib/verneuil/program.rb

@@ -7,10 +7,12 @@ require 'verneuil/instruction'
 class Verneuil::Program
   # Gives access to the internal array of instructions (the program memory)
   attr_reader :instructions
+  # Access to the programs symbol table.
+  attr_reader :symbols
   
   def initialize
     @instructions = []
-    @functions = {}
+    @symbols = Verneuil::SymbolTable.new
   end
     
   # Make programs behave nicely with respect to comparison. 
@@ -41,26 +43,14 @@ class Verneuil::Program
   def add(instruction)
     @instructions << instruction
   end
-  
-  # Defines a function. 
-  #
-  def add_method(klass, name, adr)
-    @functions[[klass, name]] = Verneuil::Method.new(klass, name, adr)
-  end
-  
-  # Returns the function that matches the given receiver and method name. 
-  #
-  def lookup_method(recv, name)
-    @functions[[recv, name]]
-  end
-  
+    
   # Printing
   # 
   def inspect
     s = ''
     @instructions.each_with_index do |instruction, idx|
       method_label = ''
-      if entry=@functions.find { |(r,n), m| m.address.ip == idx }
+      if entry=symbols.methods.find { |(r,n), m| m.address.ip == idx }
         m = entry.last
         method_label = [m.receiver, m.name].inspect
       end

data/lib/verneuil/scope.rb

@@ -4,6 +4,7 @@
 # to user code. 
 #
 class Verneuil::Scope
+  # In Ruby, we also call this the 'self'.
   attr_reader :context
   
   def initialize(context, local_vars={}, parent=nil)
@@ -12,19 +13,26 @@ class Verneuil::Scope
     @parent = parent
   end
   
-  def enter
-    Verneuil::Scope.new(context, {}, nil)
-  end
-  
   def lvar_exist?(name)
+    lvar_exist_locally?(name) || @parent && @parent.lvar_exist?(name)
+  end
+  def lvar_exist_locally?(name)
     @local_vars.has_key?(name)
   end
   def lvar_get(name)
-    raise Verneuil::NameError, "No such local variable #{name.inspect}." \
-      unless @local_vars.has_key?(name)
+    unless lvar_exist_locally? name
+      return @parent.lvar_get(name) if @parent
+      
+      raise Verneuil::NameError, "No such local variable #{name.inspect}."
+    end
+
     @local_vars[name]
   end
   def lvar_set(name, value)
+    unless lvar_exist_locally? name
+      return @parent.lvar_set(name, value) if @parent && @parent.lvar_exist?(name)
+    end
+
     @local_vars[name] = value
   end
   def defined?(name)
@@ -33,6 +41,13 @@ class Verneuil::Scope
     nil
   end
 
+  # Returns a nested scope that has access to the current scope in a Ruby 1.9
+  # fashion. 
+  #
+  def child(local_vars={})
+    self.class.new(context, local_vars, self)
+  end
+
   def method_call(name, *args)
     context.send(name, *args)
   end

data/lib/verneuil/symbol_table.rb

@@ -0,0 +1,35 @@
+
+# A registry for methods. 
+#
+class Verneuil::SymbolTable
+  attr_reader :methods
+  
+  def initialize
+    @methods = {}
+  end
+  
+  # Defines a function. This function will override the default of calling
+  # back to Ruby. Methods added here must support at least #receiver, 
+  # #name and #invoke. 
+  #
+  # Example: 
+  #   # Replaces Foo#bar with the V method at address 15.
+  #   add(method_obj)
+  #
+  def add(method)
+    key = [method.receiver, method.name]
+    @methods[key] = method
+  end
+  
+  # Returns the function that matches the given receiver and method name. 
+  #
+  def lookup_method(recv, name)
+    key = if recv
+      [recv.class.name.to_sym, name]
+    else
+      [nil, name]
+    end
+    
+    @methods[key]
+  end
+end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 1
+  - 2
   - 0
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Kaspar Schiess
@@ -71,15 +71,21 @@ files:
 - LICENSE
 - Rakefile
 - README
+- bin/verneuil
 - lib/verneuil/address.rb
 - lib/verneuil/block.rb
 - lib/verneuil/compiler.rb
 - lib/verneuil/generator.rb
 - lib/verneuil/instruction.rb
+- lib/verneuil/kernel/fork.rb
+- lib/verneuil/kernel/process_join.rb
 - lib/verneuil/method.rb
+- lib/verneuil/process/kernel_methods.rb
 - lib/verneuil/process.rb
+- lib/verneuil/process_group.rb
 - lib/verneuil/program.rb
 - lib/verneuil/scope.rb
+- lib/verneuil/symbol_table.rb
 - lib/verneuil.rb
 has_rdoc: true
 homepage: http://kschiess.github.com/verneuil