verneuil 0.1.0

data/Gemfile

@@ -0,0 +1,11 @@
+source "http://rubygems.org"
+
+gem 'ruby_parser', '~> 2.0'
+
+group :development do
+  gem 'rspec'
+  gem 'flexmock'
+  
+  gem 'guard'
+  gem 'growl'
+end

data/HISTORY.txt

@@ -0,0 +1,6 @@
+== 0.1.0 / 8Feb11
+
+  * Initial version, supporting a rather large subset of ruby already. 
+    Getting this out so I can base later releases on something. 
+    
+  * Not production ready, the paint is still fresh on this one. 

data/LICENSE

@@ -0,0 +1,23 @@
+
+ Copyright (c) 2011 Kaspar Schiess
+
+ Permission is hereby granted, free of charge, to any person
+ obtaining a copy of this software and associated documentation
+ files (the "Software"), to deal in the Software without
+ restriction, including without limitation the rights to use,
+ copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the
+ Software is furnished to do so, subject to the following
+ conditions:
+
+ The above copyright notice and this permission notice shall be
+ included in all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,45 @@
+
+A virtual machine for something almost like ruby. 
+
+The verneuil process produces artificial rubies that are somewhat unlike real
+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.
+
+Is it useful? That depends. You could for example use this to
+  * script website interaction with your user
+  * create scripts that run for days/months 
+  * create crash safe programs (checkpoints? transactions?)
+  * transfer running programs over the wire (agents!)?
+  * and perhaps more
+  
+STEREOID-CODE
+
+Verneuil is *eval* on stereoids.
+  
+SYNOPSIS
+
+  code    = "puts 42"
+  program = Verneuil::Compiler.compile(code)
+  process = Verneuil::Process.new(code, self)
+  process.run   # prints 42 to the console.
+  
+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: 
+
+ * Method calls
+ * Local variables
+ * Method definitions
+ * if then else
+ * while
+ * Masking class methods 
+ * correct self
+
+(c) 2011 Kaspar Schiess

data/Rakefile

@@ -0,0 +1,35 @@
+
+require "rubygems"
+require "rake/rdoctask"
+require 'rspec/core/rake_task'
+require "rake/gempackagetask"
+
+desc "Run all examples"
+RSpec::Core::RakeTask.new
+
+task :default => :spec
+
+# require 'sdoc'
+# 
+# # Generate documentation
+# Rake::RDocTask.new do |rdoc|
+#   rdoc.title    = "parslet - construction of parsers made easy"
+#   rdoc.options << '--line-numbers'
+#   rdoc.options << '--fmt' << 'shtml' # explictly set shtml generator
+#   rdoc.template = 'direct' # lighter template used on railsapi.com
+#   rdoc.main = "README"
+#   rdoc.rdoc_files.include("README", "lib/**/*.rb")
+#   rdoc.rdoc_dir = "rdoc"
+# end
+
+desc 'Clear out RDoc'
+task :clean => [:clobber_rdoc, :clobber_package]
+
+# This task actually builds the gem. 
+spec = eval(File.read('verneuil.gemspec'))
+desc "Generate the gem package."
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+task :gem => :spec

data/lib/verneuil/address.rb

@@ -0,0 +1,21 @@
+
+class Verneuil::Address
+  attr_accessor :ip
+  
+  def initialize(ip, generator)
+    @ip = ip
+    @generator = generator
+  end
+  
+  def inspect
+    "-> #{ip}"
+  end
+  
+  def resolve
+    @generator.resolve(self)
+  end
+  
+  def ==(other)
+    self.ip == other.ip
+  end
+end

data/lib/verneuil/block.rb

@@ -0,0 +1,19 @@
+
+# Abstracts the notion of a block.
+#
+class Verneuil::Block
+  def initialize(adr, process, scope)
+    @adr      = adr
+    @process  = process
+    @scope    = scope
+  end
+  
+  def call(*args)
+    @process.enter_block(args, @adr, @scope)
+    throw :verneuil_code
+  end
+  
+  def inspect
+    "block@#{@adr.ip}(#{@scope.inspect})"
+  end
+end

data/lib/verneuil/compiler.rb

@@ -0,0 +1,303 @@
+
+require 'ruby_parser'
+
+# Compiles verneuil code into a program. 
+#
+class Verneuil::Compiler
+  def initialize
+    @generator = Verneuil::Generator.new
+  end
+  
+  def program
+    @generator.program
+  end
+  
+  def self.compile(*args)
+    new.compile(*args)
+  end
+    
+  # Compiles a piece of code within the current program. This means that any
+  # method definitions that have already been encountered will be used to 
+  # resolve method calls. Returns the program which can also be accessed 
+  # using #program on the compiler instance. 
+  #
+  def compile(code)
+    parser = RubyParser.new
+    sexp = parser.parse(code)
+    # pp sexp
+    
+    visitor   = Visitor.new(@generator, self)
+    visitor.visit(sexp)
+    
+    @generator.program
+  end
+  
+  # Compiler visitor visits sexps and transforms them into executable code
+  # by calling back on its code generator. 
+  #
+  class Visitor
+    NOPOP = [:return, :defn, :class]
+    
+    def initialize(generator, compiler)
+      @generator = generator
+      @compiler = compiler
+      
+      @class_context = []
+    end
+    
+    def visit(sexp)
+      type, *args = sexp
+      
+      sym = "accept_#{type}".to_sym
+      
+      raise ArgumentError, "No sexp given?" unless sexp && type
+      
+      raise NotImplementedError, "No acceptor for #{sexp}." \
+        unless respond_to? sym
+
+      self.send(sym, *args)
+    end
+    
+    #--------------------------------------------------------- visitor methods
+    
+    # s(:call, RECEIVER, NAME, ARGUMENTS) - Method calls with or without
+    # receiver.
+    # 
+    def accept_call(receiver, method_name, args)
+      argc = visit(args)
+      
+      if receiver
+        visit(receiver)
+        @generator.ruby_call method_name, argc
+      else
+        @generator.ruby_call_implicit method_name, argc
+      end
+    end
+    
+    # s(:arglist, ARGUMENT, ARGUMENT) - Argument lists. Needs to return the
+    # actual number of arguments that we've compiled. 
+    #
+    def accept_arglist(*args)
+      args.each do |arg|
+        visit(arg)
+      end
+      return args.size
+    end
+
+    # s(:block, STATEMENT, STATEMENT, ...) - Blocks of code. 
+    #
+    def accept_block(*statements)
+      statements.each_with_index do |statement, idx|
+        type, *rest = statement
+        
+        visit(statement)
+        
+        unless idx+1 == statements.size ||
+          NOPOP.include?(type)
+          @generator.pop 1 
+        end
+      end
+    end
+
+    # s(:lit, LITERAL) - A literal value.
+    #
+    def accept_lit(value)
+      @generator.load value
+    end
+
+    # s(:if, COND, THEN, ELSE) - an if statement
+    #
+    def accept_if(cond, _then, _else)
+      adr_else = @generator.fwd_adr
+      adr_end  = @generator.fwd_adr
+      
+      visit(cond)
+      @generator.jump_if_false adr_else
+      
+      visit(_then)
+      @generator.jump adr_end
+      
+      adr_else.resolve
+      if _else
+        visit(_else)
+      else
+        @generator.load nil
+      end
+      adr_end.resolve
+    end
+
+    # s(:while, test, body, true) - a while statement. 
+    #
+    def accept_while(cond, body, t)
+      fail "What is t for?" unless t
+
+      adr_end = @generator.fwd_adr
+    
+      adr_test = @generator.current_adr
+      visit(cond)
+      @generator.jump_if_false adr_end
+      
+      visit(body)
+      @generator.jump adr_test
+      
+      adr_end.resolve
+    end
+    
+    # s(:op_asgn_or, s(:lvar, :a), s(:lasgn, :a, s(:lit, 1))) - var ||= value.
+    #
+    def accept_op_asgn_or(variable, assign)
+      (*), var, val = assign
+      visit(
+        s(:lasgn, var, 
+          s(:if, 
+            s(:defined, variable), 
+            variable, 
+            val)))
+    end
+    
+    # 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
+    end
+    
+    # s(:lasgn, VARIABLE, VALUE) - assignment of local variables. 
+    # s(:lasgn, VARIABLE) - implicit assignment of local vars.
+    #
+    def accept_lasgn(*args)
+      if args.size == 2
+        val = args.last
+        visit(val)
+      end
+
+      name = args.first
+      @generator.dup 0
+      @generator.lvar_set name
+    end
+    
+    # s(:lvar, VARIABLE) - local variable access.
+    #
+    def accept_lvar(name)
+      visit(
+        s(:call, nil, name, s(:arglist)))
+    end
+
+    # s(:defn, NAME, ARG_NAMES, BODY) - a method definition.
+    #
+    def accept_defn(name, args, body)
+      # Jumping over functions so that definitions don't get executed.
+      adr_end = @generator.fwd_adr
+      @generator.jump adr_end
+      
+      @generator.program.add_method(
+        @class_context.last, 
+        name, 
+        @generator.current_adr)
+
+      # Enters a new local scope and defines arguments
+      visit(args)
+
+      visit(body)
+      @generator.return
+      
+      adr_end.resolve
+    end
+
+    # s(:class, :Fixnum, SUPER, s(:scope, s(:defn, :foo, s(:args), DEF))) - 
+    # a method definition for a class.
+    #
+    # NOTE that verneuils classes don't work like Rubies classes at all. This
+    # is more or less just a method for masking methods on Ruby classes, 
+    # not a way to define classes. 
+    #
+    def accept_class(name, _, scope)
+      @class_context.push name
+      
+      visit(scope)
+    ensure
+      @class_context.pop
+    end
+    
+    # s(:args, ARGUMENT_NAMES) 
+    #
+    def accept_args(*arg_names)
+      arg_names.each do |name|
+        if name.to_s.start_with?('&')
+          stripped_name = name.to_s[1..-1].to_sym
+          @generator.load_block
+          @generator.lvar_set stripped_name
+        else
+          @generator.lvar_set name
+        end
+      end
+    end
+    
+    # s(:scope, BODY) - a new scope.
+    #
+    def accept_scope(body)
+      # For now, we don't know what we'll eventually do with scopes. So here
+      # is this very basic idea...
+      visit(body)
+    end
+    
+    # s(:return, RETVAL) - return from the current method. 
+    #
+    def accept_return(val)
+      visit(val)
+      @generator.return 
+    end
+    
+    # s(:iter, s(:call, RECEIVER, METHOD, ARGUMENTS), ASSIGNS, BLOCK) - call
+    # a method with a block. 
+    #
+    def accept_iter(call, assigns, block)
+      # Jump over the block code
+      adr_end_of_block = @generator.fwd_adr
+      @generator.jump adr_end_of_block
+      
+      adr_start_of_block = @generator.current_adr
+      
+      if assigns
+        type, *names = assigns
+        fail "BUG: Unsupported type of block arguments: #{type}" \
+          unless type == :lasgn
+        accept_args(*names)
+      end
+      visit(block)
+      @generator.return 
+
+      adr_end_of_block.resolve
+      
+      # Compile the call as we would normally, adding a push_block/pop_block
+      # around it. 
+      @generator.push_block adr_start_of_block
+      visit(call)
+      @generator.pop_block
+    end
+
+    # true.
+    #
+    def accept_true
+      @generator.load true
+    end
+    
+    # false.
+    #
+    def accept_false
+      @generator.load false
+    end
+    
+    # self
+    #
+    def accept_self
+      @generator.load_self
+    end
+    
+  end
+end

data/lib/verneuil/generator.rb

@@ -0,0 +1,60 @@
+
+require 'verneuil/process'
+
+# A generator for VM code. 
+#
+class Verneuil::Generator
+  # Returns the instruction stream as has been assembled to this moment. 
+  #
+  attr_reader :program
+  
+  def initialize
+    @program = Verneuil::Program.new
+  end
+  
+  # Adds an instruction to the current stream.
+  #
+  def add_instruction(*parts)
+    @program.add Verneuil::Instruction.new(*parts)
+  end
+  
+  # Returns an address that hasn't been fixed to an instruction pointer yet. 
+  # 
+  def fwd_adr
+    current_adr
+  end
+  
+  # Returns an address that points at the location given by +ip+. 
+  #
+  def abs_adr(ip)
+    Verneuil::Address.new(ip, self)
+  end
+  
+  # Returns an address that points at the current location in the program. 
+  #
+  def current_adr
+    Verneuil::Address.new(program.size, self)
+  end
+  
+  # Resolves an address to the current location. 
+  #
+  def resolve(adr)
+    adr.ip = program.size
+  end
+    
+  # This implements many of the instruction methods that are just one-to-one
+  # correspondances between methods on the generator and the instructions in
+  # the stream. 
+  # 
+  # Example: 
+  #   generator.foo 1,2,3
+  #   # will add [:foo, 1,2,3] to the instruction stream. 
+  #
+  Verneuil::Process.instance_methods.
+    select { |method| method.to_s =~ /^instr_(.*)/ }.
+    map { |method| method.to_s[6..-1].to_sym }.each do |instruction|
+      define_method(instruction) do |*args|
+        add_instruction instruction, *args
+      end
+    end
+end

data/lib/verneuil/instruction.rb

@@ -0,0 +1,10 @@
+
+# A single instruction for the verneuil processor. This is like sexp a thin
+# wrapper around array.
+#
+class Verneuil::Instruction < Array
+  def initialize(*parts)
+    super(parts.size)
+    replace(parts)
+  end
+end

data/lib/verneuil/method.rb

@@ -0,0 +1,5 @@
+
+# Represents a method that can be called. 
+#
+class Verneuil::Method < Struct.new(:receiver, :name, :address)
+end

data/lib/verneuil/process.rb

@@ -0,0 +1,282 @@
+
+# Processor state of one process. 
+#
+class Verneuil::Process
+  # Create a process, giving it a program to run and a context to run in. 
+  #
+  def initialize(program, context)
+    # p program
+    
+    # The program that is being executed.
+    @program = program
+    # Keeps the current scope and the ones before it.
+    @scopes  = [scope(context)]
+    # Keeps implicit blocks when executing iteration code. 
+    @blocks  = []
+    # Value stack
+    @stack = []
+    # Return address stack
+    @call_stack = []
+    # Instruction pointer
+    @ip = 0
+    # Should we stop immediately? Cannot restart after setting this. 
+    @halted = false
+  end
+  
+  # Runs the program until it completes and returns the last expression
+  # in the program.
+  #
+  def run
+    until halted?
+      step
+    end
+    
+    @stack.last
+  end
+  
+  # Runs one instruction and returns nil. If this was the last instruction, 
+  # it returns the programs return value. 
+  #
+  def step
+    # old_ip = @ip
+
+    instruction = fetch_and_advance
+    dispatch(instruction)
+  
+    # p [old_ip, instruction, @stack, current_scope, @call_stack]
+    
+    instr_halt if @ip >= @program.size
+    
+    halted? ? @stack.last : nil
+  end
+  
+  # Returns true if the process has halted because it has reached its end.
+  #
+  def halted?
+    !!@halted
+  end
+  
+  # Fetches the next instruction and advances @ip.
+  #
+  def fetch_and_advance
+    # Pretends that the memory beyond the current space is filled with :halt
+    # instructions.
+    return :halt if @ip >= @program.size
+    
+    instruction = @program[@ip]
+    @ip += 1
+    
+    instruction
+  end
+  
+  # Decodes the instruction into opcode and arguments and calls a method
+  # on this instance called opcode_OPCODE giving the arguments as method 
+  # arguments. 
+  #
+  def dispatch(instruction)
+    opcode, *rest = instruction
+    sym = "instr_#{opcode}"
+
+    begin
+      self.send(sym, *rest)
+    rescue NoMethodError => ex
+      # Catch our own method error, but not those that happen inside an 
+      # instruction that exists..
+      if ex.message.match(/#{sym}/)
+        warn @program
+        exception "Unknown opcode #{opcode} (missing ##{sym})."
+      else
+        raise
+      end
+    end
+  end
+  
+  # Raises an exception that contains useful information about where the 
+  # process stopped. 
+  #
+  def exception(message)
+    fail message
+  end
+  
+  # Produces a new scope that links to the given context. 
+  #
+  def scope(context)
+    Verneuil::Scope.new(context)
+  end
+  
+  # Returns the currently active scope. 
+  #
+  def current_scope
+    @scopes.last
+  end
+  
+  # Enters a block. This pushes args to the stack, installs the scope given
+  # and jumps to adr. 
+  #
+  def enter_block(args, adr, scope)
+    args.each { |arg| @stack.push arg }
+    
+    @scopes.push scope
+    
+    @call_stack.push @ip
+    jump adr
+  end
+  
+  # Jumps to the given address. 
+  #
+  def jump(adr)
+    @ip = adr.ip
+  end
+
+  # Calls the given address. (like a jump, but puts something on the return
+  # stack)
+  #
+  def call(adr, context=nil)
+    @scopes.push scope(context || current_scope.context)
+    @call_stack.push @ip
+    jump adr
+  end
+
+  # VM Implementation --------------------------------------------------------
+  
+  # A call to an implicit target (self).
+  #
+  def instr_ruby_call_implicit(name, argc)
+    # Local variable
+    if argc==0 && current_scope.lvar_exist?(name)
+      @stack.push current_scope.lvar_get(name)
+      return
+    end
+    
+    # Verneuil method?
+    v_method = @program.lookup_method(nil, name)
+    if v_method
+      call v_method.address
+      return
+    end
+    
+    # Ruby method! (or else)
+    args = @stack.pop(argc)
+    @stack.push current_scope.method_call(name, *args)
+  end
+  
+  # A call to an explicit receiver. The receiver should be on top of the stack. 
+  #
+  def instr_ruby_call(name, argc)
+    receiver = @stack.pop
+
+    # 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
+    
+    # Must be a Ruby method then. The catch allows internal classes like 
+    # Verneuil::Block to skip the stack.push.
+    args     = @stack.pop(argc)
+    catch(:verneuil_code) {
+      retval = receiver.send(name, *args)
+      @stack.push retval
+    }
+  end
+  
+  # ------------------------------------------------------------ STACK CONTROL 
+  
+  # Pops n elements off the internal stack
+  #
+  def instr_pop(n)
+    @stack.pop(n)
+  end
+  
+  # Loads a literal value to the stack. 
+  # 
+  def instr_load(val)
+    @stack.push val
+  end
+  
+  # Duplicates the value given by stack_idx (from the top) and pushes it 
+  # to the stack. 
+  #
+  def instr_dup(stack_idx)
+    @stack.push @stack[-stack_idx-1]
+  end
+  
+  # ----------------------------------------------------------------- JUMPS !!
+  
+  # Jumps to the given address if the top of the stack contains a false value.
+  #
+  def instr_jump_if_false(adr)
+    val = @stack.pop
+    @ip = adr.ip unless val
+  end
+  
+  # Unconditional jump
+  #
+  def instr_jump(adr)
+    jump adr
+  end
+  
+  # Returning from a method (pops the call_stack.)
+  # 
+  def instr_return
+    exception "Nothing to return to on the call stack." if @call_stack.empty?
+    @ip = @call_stack.pop
+    @scopes.pop
+  end
+  
+  # ---------------------------------------------------------------- VARIABLES
+
+  # Tests if the local variable exists. Puts true/false to the stack. 
+  #
+  def instr_test_lvar(name)
+    @stack.push current_scope.defined?(name)
+  end
+
+  # Sets the local variable given by name. 
+  #
+  def instr_lvar_set(name)
+    current_scope.lvar_set(name, @stack.pop)
+  end
+    
+  # ------------------------------------------------------------------- BLOCKS 
+  
+  # Pushes a block context to the block stack. 
+  #
+  def instr_push_block(block_adr)
+    @blocks.push Verneuil::Block.new(block_adr, self, current_scope)
+  end
+
+  # Loads the currently set implicit block to the stack. This is used when
+  # turning an implicit block into an explicit block by storing it to a 
+  # local variable. 
+  #
+  def instr_load_block
+    fail "BUG: No implicit block!" if @blocks.empty?
+    @stack.push @blocks.last
+  end
+  
+  # Unloads a block
+  #
+  def instr_pop_block
+    @blocks.pop
+  end
+
+  # Halts the processor and returns the last value on the stack. 
+  # 
+  def instr_halt
+    @halted = true
+  end
+
+  # ------------------------------------------------------ METHODS FOR CLASSES 
+  
+  # Loads the self on the stack. Toplevel self is the context you give, later
+  # on this may change to the class we're masking a method of. 
+  #
+  def instr_load_self
+    @stack.push current_scope.context
+  end
+  
+end

data/lib/verneuil/program.rb

@@ -0,0 +1,71 @@
+
+require 'verneuil/instruction'
+
+# A program is a sequence of instructions that can be run inside a process.
+# You can use the compiler (Verneuil::Compiler) to create programs.
+#
+class Verneuil::Program
+  # Gives access to the internal array of instructions (the program memory)
+  attr_reader :instructions
+  
+  def initialize
+    @instructions = []
+    @functions = {}
+  end
+    
+  # Make programs behave nicely with respect to comparison. 
+  def hash # :nodoc: 
+    instructions.hash
+  end
+  def eql?(program) # :nodoc: 
+    instructions.eql? program.instructions
+  end
+  def ==(program)
+    instructions == program.instructions
+  end
+  
+  # Retrieves instruction at idx
+  # 
+  def [](idx)
+    instructions[idx]
+  end
+  
+  # Returns the size of the current program
+  #
+  def size
+    instructions.size
+  end
+    
+  # Adds an instruction to the program. (at the end)
+  #
+  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 }
+        m = entry.last
+        method_label = [m.receiver, m.name].inspect
+      end
+      s << sprintf("%20s %04d %s\n", method_label, idx, instruction)
+    end
+    s
+  end
+end

data/lib/verneuil/scope.rb

@@ -0,0 +1,44 @@
+
+# The execution scope for verneuil code. This maintains a link to the external
+# context given when starting the process to be able to delegate method calls
+# to user code. 
+#
+class Verneuil::Scope
+  attr_reader :context
+  
+  def initialize(context, local_vars={}, parent=nil)
+    @local_vars = local_vars
+    @context = context
+    @parent = parent
+  end
+  
+  def enter
+    Verneuil::Scope.new(context, {}, nil)
+  end
+  
+  def lvar_exist?(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)
+    @local_vars[name]
+  end
+  def lvar_set(name, value)
+    @local_vars[name] = value
+  end
+  def defined?(name)
+    return 'local-variable' if lvar_exist?(name)
+    return 'method' if context.respond_to?(name)
+    nil
+  end
+
+  def method_call(name, *args)
+    context.send(name, *args)
+  end
+  
+  def inspect
+    "scope(#{@local_vars.inspect[2..-2]})" + 
+      (@parent ? "-> #{@parent.inspect}" : '')
+  end
+end

data/lib/verneuil.rb

@@ -0,0 +1,15 @@
+
+module Verneuil
+  class NameError < StandardError; end
+end
+
+require 'verneuil/address'
+require 'verneuil/method'
+require 'verneuil/block'
+require 'verneuil/program'
+
+require 'verneuil/generator'
+require 'verneuil/compiler'
+
+require 'verneuil/scope'
+require 'verneuil/process'

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification 
+name: verneuil
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Kaspar Schiess
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-02 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ruby_parser
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 0
+        version: "2.0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: flexmock
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+description: 
+email: kaspar.schiess@absurd.li
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- Gemfile
+- HISTORY.txt
+- LICENSE
+- Rakefile
+- README
+- lib/verneuil/address.rb
+- lib/verneuil/block.rb
+- lib/verneuil/compiler.rb
+- lib/verneuil/generator.rb
+- lib/verneuil/instruction.rb
+- lib/verneuil/method.rb
+- lib/verneuil/process.rb
+- lib/verneuil/program.rb
+- lib/verneuil/scope.rb
+- lib/verneuil.rb
+has_rdoc: true
+homepage: http://kschiess.github.com/verneuil
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Artificial Rubies. Using a fusion process.
+test_files: []
+