heist 0.1.0

data/lib/runtime/callable/macro/expansion.rb

@@ -0,0 +1,15 @@
+module Heist
+  class Runtime
+    class Macro
+      
+      class Expansion
+        attr_reader :expression
+        def initialize(expression)
+          @expression = expression
+        end
+      end
+      
+    end
+  end
+end
+

data/lib/runtime/callable/macro/matches.rb

@@ -0,0 +1,77 @@
+module Heist
+  class Runtime
+    class Macro
+      
+      class Matches
+        def initialize
+          @data  = {}
+          @depth = 0
+          @names = []
+        end
+        
+        def depth=(depth)
+          mark!(depth) if depth < @depth
+          @names[depth] = [] if depth >= @depth
+          @depth = depth
+        end
+        
+        def put(name, expression)
+          name = name.to_s
+          @names[@depth] << name
+          @data[name] ||= Splice.new(name, @depth)
+          @data[name] << expression unless expression.nil?
+        end
+        
+        def inspecting(depth)
+          @inspecting = true
+          self.depth = depth
+        end
+        
+        def get(name)
+          @inspecting ? @names[@depth] << name.to_s :
+                        @data[name.to_s].read
+        end
+        
+        def defined?(name)
+          @data.has_key?(name.to_s)
+        end
+        
+        def expand!
+          @inspecting = false
+          size.times { yield and iterate! }
+        end
+        
+      private
+        
+        def mark!(depth)
+          d = @depth
+          while @names[d]
+            @names[d].uniq.each { |name| @data[name].mark!(depth) }
+            d += 1
+          end
+        end
+        
+        def size
+          names   = @names[@depth].uniq
+          splices = @data.select { |k,v| names.include?(k.to_s) }
+          sizes   = splices.map { |pair| pair.last.size(@depth) }.uniq
+          
+          return 0 if sizes.empty?
+          return sizes.first if sizes.size == 1
+          
+          expressions = splices.map { |pair| '"' + pair.last.to_s(@depth) + '"' } * ', '
+          raise MacroTemplateMismatch.new(
+            "Macro could not be expanded: expressions #{expressions} are of different sizes")
+        end
+        
+        def iterate!
+          @data.each do |name, splice|
+            splice.shift!(@depth) if @names[@depth].include?(name)
+          end
+        end
+      end
+      
+    end
+  end
+end
+

data/lib/runtime/callable/macro/splice.rb

@@ -0,0 +1,56 @@
+module Heist
+  class Runtime
+    class Macro
+      
+      class Splice
+        attr_reader :name, :depth
+        
+        def initialize(name, depth)
+          @name, @depth = name, depth
+          @data  = []
+          (0...@depth).inject(@data) { |list, d| list << []; list.last }
+          @indexes = (0..@depth).map { 0 }
+          @stack = []
+        end
+        
+        def <<(value)
+          @stack.pop.call() while not @stack.empty?
+          tail(@depth) << value
+        end
+        
+        def mark!(depth)
+          @stack << lambda { tail(depth) << [] }
+        end
+        
+        def size(depth)
+          current(depth).size
+        end
+        
+        def read
+          current(@depth)[@indexes[@depth]]
+        end
+        
+        def shift!(depth)
+          @indexes[depth] += 1
+          @indexes[depth] = 0 if @indexes[depth] >= current(depth).size
+        end
+        
+        def to_s(depth = 0)
+          "#{@name}#{' ...' * (@depth - depth)}"
+        end
+        
+      private
+        
+        def tail(depth)
+          (0...depth).inject(@data) { |list, d| list.last }
+        end
+        
+        def current(depth)
+          @indexes[0...depth].inject(@data) { |list, i| list[i] }
+        end
+      end
+      
+    end
+  end
+end
+

data/lib/runtime/data/expression.rb

@@ -0,0 +1,23 @@
+module Heist
+  class Runtime
+    
+    module Expression
+      attr_reader :parent, :index
+      
+      def exists_at!(parent, index)
+        @parent, @index = parent, index
+      end
+      
+      def replace(expression)
+        return unless @parent
+        @parent[@index] = expression
+      end
+      
+      def eval(scope)
+        scope.runtime.stack << Frame.new(self, scope)
+      end
+    end
+    
+  end
+end
+

data/lib/runtime/data/identifier.rb

@@ -0,0 +1,20 @@
+module Heist
+  class Runtime
+    
+    class Identifier
+      include Expression
+      
+      extend Forwardable
+      def_delegators(:@metadata, :[], :[]=)
+      def_delegators(:@name, :to_s)
+      alias :inspect :to_s
+      
+      def initialize(name)
+        @name = name.to_s
+        @metadata = {}
+      end
+    end
+    
+  end
+end
+

data/lib/runtime/data/list.rb

@@ -0,0 +1,36 @@
+module Heist
+  class Runtime
+    
+    class List < Array
+      include Expression
+      
+      def self.from(array)
+        list = new
+        array.each { |item| list << item }
+        list
+      end
+      
+      def <<(element)
+        element.exists_at!(self, self.size) if Expression === element
+        super
+      end
+      
+      def []=(index, value)
+        super
+        value.exists_at!(self, index) if Expression === value
+      end
+      
+      def rest
+        self[1..-1]
+      end
+      
+      def to_s
+        '(' + collect { |cell| cell.to_s } * ' ' + ')'
+      end
+      
+      alias :inspect :to_s
+    end
+    
+  end
+end
+

data/lib/runtime/frame.rb

@@ -0,0 +1,118 @@
+module Heist
+  class Runtime
+    
+    class Frame
+      attr_reader :expression, :scope
+      
+      def initialize(expression, scope)
+        reset!(expression)
+        @scope = scope
+      end
+      
+      def complete?
+        @complete
+      end
+      
+      def process!
+        case @expression
+        
+          when List then
+            if Syntax === @values.first or @values.size == @expression.size
+              @complete = true
+              merge!
+              raise SyntaxError.new("Invalid expression: #{@expression}") unless Function === @data.first
+              result = @data.first.call(@scope, @data[1..-1])
+              return result unless Macro::Expansion === result
+              return reset!(result.expression, true)
+            end
+            
+            stack = @scope.runtime.stack
+            stack << Frame.new(@expression[@values.size], @scope)
+        
+          when Identifier then
+            @complete = true
+            @scope[@expression]
+        
+          else
+            @complete = true
+            Heist.evaluate(@expression, @scope)
+        end
+      end
+      
+      def dup
+        copy, values = super, @values.dup
+        copy.instance_eval { @values = values }
+        copy
+      end
+      
+      def fill!(subexpr, value)
+        subexpr ||= @expression[@values.size]
+        @values << value
+        @subexprs << subexpr
+      end
+      
+      def replaces(expression)
+        @target = expression
+      end
+      
+      def target
+        @target || @expression
+      end
+      
+    private
+      
+      def merge!
+        return @data = @values unless Syntax === @values.first
+        @data = @expression.dup
+        @expression.each_with_index do |expr, i|
+          index = @subexprs.index(expr)
+          @data[i] = @values[index] if index
+        end
+      end
+      
+      def reset!(expression, replace = false)
+        @expression.replace(expression) if replace
+        @expression = expression
+        @values     = []
+        @subexprs   = []
+        @complete   = false
+      end
+    end
+    
+    class Body < Frame
+      def initialize(expressions, scope)
+        @expression  = expressions
+        @scope       = scope
+        @values      = []
+        @index       = 0
+      end
+      
+      def complete?
+        @index == @expression.size
+      end
+      
+      def process!
+        expression = @expression[@index]
+        @index += 1   # increment before evaluating the expression
+                      # so that when a continuation is saved we
+                      # resume from the following statement
+        
+        return Frame.new(expression, @scope) if @index == @expression.size
+        
+        stack = @scope.runtime.stack
+        stack << Frame.new(expression, @scope)
+        stack.value
+      end
+      
+      def fill!(value, subexpr = nil)
+        @values << value
+      end
+      
+      def to_s
+        @expression.map { |e| e.to_s } * ' '
+      end
+    end
+    
+  end
+end
+

data/lib/runtime/runtime.rb

@@ -0,0 +1,61 @@
+require 'forwardable'
+
+module Heist
+  class Runtime
+    
+    %w[ data/expression     data/identifier   data/list
+        callable/function   callable/macro    callable/continuation
+        scope               binding           frame
+        stack               stackless
+        
+    ].each do |file|
+      require RUNTIME_PATH + file
+    end
+    
+    extend Forwardable
+    def_delegators(:@top_level, :[], :eval, :define, :syntax, :call)
+    
+    attr_reader :order
+    attr_accessor :stack, :top_level
+    
+    def initialize(options = {})
+      @lazy          = !!options[:lazy]
+      @continuations = !!options[:continuations]
+      @hygienic      = !options[:unhygienic]
+      
+      @top_level = Scope.new(self)
+      @stack = create_stack
+      
+      syntax_type = (lazy? or not @hygienic) ? 'rb' : 'scm'
+      
+      run("#{ BUILTIN_PATH }primitives.rb")
+      run("#{ BUILTIN_PATH }syntax.#{syntax_type}")
+      run("#{ BUILTIN_PATH }library.scm")
+      
+      @start_time = Time.now.to_f
+    end
+    
+    def run(path)
+      return instance_eval(File.read(path)) if File.extname(path) == '.rb'
+      @top_level.run(path)
+    end
+    
+    def elapsed_time
+      (Time.now.to_f - @start_time) * 1000000
+    end
+    
+    def lazy?; @lazy; end
+    
+    def hygienic?; @hygienic; end
+    
+    def stackless?
+      lazy? or not @continuations
+    end
+    
+    def create_stack
+      stackless? ? Stackless.new : Stack.new
+    end
+    
+  end
+end
+

data/lib/runtime/scope.rb

@@ -0,0 +1,121 @@
+module Heist
+  class Runtime
+    
+    class Scope
+      attr_reader :runtime
+      
+      def initialize(parent = {})
+        @symbols = {}
+        is_runtime = (Runtime === parent)
+        @parent = is_runtime ? {} : parent
+        @runtime = is_runtime ? parent : parent.runtime
+      end
+      
+      def [](name)
+        name = to_name(name)
+        bound = @symbols.has_key?(to_name(name))
+        
+        raise UndefinedVariable.new(
+          "Variable '#{name}' is not defined") unless bound or Scope === @parent
+            
+        value = bound ? @symbols[name] : @parent[name]
+        value = value.extract if Binding === value
+        value
+      end
+      
+      def []=(name, value)
+        @symbols[to_name(name)] = value
+        value.name = name if Function === value
+        value
+      end
+      
+      def defined?(name)
+        @symbols.has_key?(to_name(name)) or
+            (Scope === @parent and @parent.defined?(name))
+      end
+      
+      def set!(name, value)
+        name = to_name(name)
+        bound = @symbols.has_key?(name)
+        
+        raise UndefinedVariable.new(
+          "Cannot set undefined variable '#{name}'") unless bound or Scope === @parent
+        
+        return @parent.set!(name, value) unless bound
+        self[name] = value
+      end
+      
+      def define(name, *args, &block)
+        self[name] = Function.new(self, *args, &block)
+      end
+      
+      def syntax(name, holes = [], &block)
+        self[name] = Syntax.new(self, holes,&block)
+      end
+      
+      def grep(pattern)
+        base = (Scope === @parent) ? @parent.grep(pattern) : []
+        @symbols.each do |key, value|
+          base << key if key =~ pattern
+        end
+        base.uniq
+      end
+      
+      # TODO: this isn't great, figure out a way for functions
+      # to transparently handle inter-primitive calls so Ruby can
+      # call Scheme code as well as other Ruby code
+      def call(name, *params)
+        self[name].body.call(*params)
+      end
+      
+      def run(path)
+        path   = path + FILE_EXT unless File.file?(path)
+        source = Heist.parse(File.read(path))
+        scope  = FileScope.new(self, path)
+        source.eval(scope)
+      end
+      
+      def eval(source)
+        source = Heist.parse(source) if String === source
+        source.eval(self)
+      end
+      
+      def load(path)
+        dir = load_path.find do |dir|
+          File.file?("#{dir}/#{path}") or File.file?("#{dir}/#{path}#{FILE_EXT}")
+        end
+        return false unless dir
+        runtime.run("#{dir}/#{path}")
+        true
+      end
+      
+      def current_file
+        @path || @parent.current_file rescue nil
+      end
+      
+    private
+      
+      def to_name(name)
+        name.to_s.downcase
+      end
+      
+      def load_path
+        paths, file = [], current_file
+        paths << File.dirname(file) if file
+        paths + LOAD_PATH
+      end
+    end
+    
+    class FileScope < Scope
+      extend Forwardable
+      def_delegators(:@parent, :[]=)
+      
+      def initialize(parent, path)
+        super(parent)
+        @path = File.directory?(path) ? path + '/repl.scm' : path
+      end
+    end
+    
+  end
+end
+