heist 0.1.0

data/lib/parser/scheme.tt

@@ -0,0 +1,80 @@
+module Heist
+  grammar Scheme
+    rule program
+      cell* <Program>
+    end
+    
+    rule cell
+      ignore quote? ignore (list / atom) ignore <Cell>
+    end
+    
+    rule quote
+      "'" / "`" / ",@" / ","
+    end
+    
+    rule list
+      ("(" cell* ")" / "[" cell* "]") <List>
+    end
+    
+    rule atom
+      datum / identifier
+    end
+    
+    rule datum
+      (boolean / number / string) !(!delimiter .) <Datum>
+    end
+    
+    rule boolean
+      ("#t" / "#f") <Boolean>
+    end
+    
+    rule number
+      complex / real / rational / integer
+    end
+    
+    rule complex
+      real "+" real "i" <Complex>
+    end
+    
+    rule real
+      integer ("." digit+) <Real>
+    end
+    
+    rule rational
+      numerator:integer "/" denominator:integer <Rational>
+    end
+    
+    rule integer
+      "-"? ("0" / [1-9] digit*) <Integer>
+    end
+    
+    rule string
+      '"' ('\\"' / [^"])* '"' <String>
+    end
+    
+    rule identifier
+      (!delimiter .)+ <Identifier>
+    end
+    
+    rule digit
+      [0-9]
+    end
+    
+    rule delimiter
+      [\(\)\[\]] / space
+    end
+    
+    rule space
+      [\s\n\r\t]
+    end
+    
+    rule ignore
+      space* comment?
+    end
+    
+    rule comment
+      ";" (![\n\r] .)* ignore
+    end
+  end
+end
+

data/lib/repl.rb

@@ -0,0 +1,112 @@
+require 'readline'
+
+module Heist
+  class REPL
+    
+    def initialize(options = {})
+      @runtime = Runtime.new(options)
+      @scope = Runtime::FileScope.new(@runtime.top_level, File.expand_path('.'))
+      reset!
+    end
+    
+    def run
+      Heist.info(@runtime)
+      
+      Readline.completion_append_character = nil
+      Readline.completion_proc = lambda do |prefix|
+        return nil if prefix == ''
+        matches = @runtime.top_level.grep(%r[^#{prefix}]i).
+                           sort_by { |r| r.length }
+        return nil unless word = matches.first
+        while word.length > prefix.length
+          break if matches.all? { |m| m =~ %r[^#{word}]i }
+          word = word.gsub(/.$/, '')
+        end
+        return nil if word == prefix
+        word + (matches.size == 1 ? ' ' : '')
+      end
+      
+      loop do
+        input  = Readline.readline(prompt)
+        exit if input.nil?
+        
+        push(input)
+        tree = Heist.parse(@buffer * ' ')
+        next if tree.nil?
+        
+        reset!
+        begin
+          result = @scope.eval(tree)
+          puts "; => #{ result }\n\n" unless result.nil?
+        rescue Exception => ex
+          return if SystemExit === ex
+          puts "; [error] #{ ex.message }\n\n"
+          puts "; backtrace: " + ex.backtrace.join("\n;            ") +
+            "\n\n" unless Heist::RuntimeError === ex
+        end
+      end
+    end
+    
+  private
+  
+    INDENT  = 2
+    SPECIAL = %w[define lambda let let* letrec
+                 define-syntax syntax-rules
+                 let-syntax letrec-syntax]
+    
+    def reset!
+      @buffer = []
+      @open   = []
+      @indent = 0
+    end
+    
+    def push(line)
+      old_depth = depth
+      @buffer << line
+      Readline::HISTORY.push(line)
+      new_depth = depth
+      
+      return if new_depth == old_depth
+      return @open.slice!(new_depth..-1) if new_depth < old_depth
+      
+      code = line.dup
+      while code == code.gsub!(/\([^\(\)\[\]]*\)|\[[^\(\)\[\]]*\]/, ''); end
+      calls = code.scan(/[\(\[](?:[^\(\)\[\]\s]*\s*)/).flatten
+      
+      calls.pop while calls.size > 1 and
+                      SPECIAL.include?(calls.last[1..-1].strip) and
+                      SPECIAL.include?(calls[-2][1..-1].strip)
+      
+      offsets  = calls.inject([]) do |list, call|
+        index  = list.empty? ? 0 : list.last.last - @indent
+        index  = @indent + (line.index(call, index) || 0)
+        rindex = index + call.length
+        eol    = (rindex == line.length + @indent)
+        list << [call[1..-1], eol, index, rindex]
+        list
+      end
+      
+      @open = @open + offsets
+    end
+    
+    def indent
+      return 0 if @buffer.empty? or @open.empty?
+      open = @open.last
+      @indent = (SPECIAL.include?(open[0].strip) or open[1]) ?
+                open[2] + INDENT :
+                open[3]
+    end
+    
+    def prompt
+      " " * indent
+    end
+    
+    def depth
+      source = @buffer * ' '
+      [/[\(\[]/, /[\)\]]/].map { |p| source.scan(p).size }.
+                           inject { |a,b| a - b }
+    end
+    
+  end
+end
+

data/lib/runtime/binding.rb

@@ -0,0 +1,31 @@
+module Heist
+  class Runtime
+    
+    class Binding
+      include Expression
+      
+      attr_reader :expression, :scope
+      
+      def initialize(expression, scope, memoized = true)
+        @expression = expression
+        @scope      = scope
+        @memoized   = !!memoized
+      end
+      
+      def extract
+        return @value if defined?(@value) and @memoized
+        @value = Heist.evaluate(@expression, @scope)
+      end
+      
+      def eval(scope)
+        extract
+      end
+      
+      def to_s
+        @expression.to_s
+      end
+    end
+    
+  end
+end
+

data/lib/runtime/callable/continuation.rb

@@ -0,0 +1,24 @@
+module Heist
+  class Runtime
+    
+    class Continuation < Function
+      def initialize(stack)
+        @stack  = stack.copy(false)
+        @target = stack.last.target
+      end
+      
+      def call(scope, cells)
+        filler = Heist.evaluate(cells.first, scope)
+        stack = @stack.copy
+        stack.fill!(@target, filler)
+        stack
+      end
+      
+      def to_s
+        "#<continuation>"
+      end
+    end
+    
+  end
+end
+

data/lib/runtime/callable/function.rb

@@ -0,0 +1,55 @@
+module Heist
+  class Runtime
+    
+    class Function
+      attr_reader :body, :name
+      
+      def initialize(scope, formals = [], body = nil, &block)
+        @scope   = scope
+        @body    = body ? List.from(body) : block
+        @formals = formals.map { |id| id.to_s }
+        @lazy    = scope.runtime.lazy?
+        @eager   = !scope.runtime.stackless?
+      end
+      
+      def name=(name)
+        @name ||= name.to_s
+      end
+      
+      def call(scope, cells)
+        params, closure = [], Scope.new(@scope)
+        cells.each_with_index do |arg, i|
+          params[i] = closure[@formals[i]] = lazy? ?
+              Binding.new(arg, scope) :
+              (@eager ? arg : Heist.evaluate(arg, scope))
+        end
+        return @body.call(*params) if primitive?
+        Body.new(@body, closure)
+      end
+      
+      def primitive?
+        Proc === @body
+      end
+      
+      def lazy?
+        @lazy and not primitive?
+      end
+      
+      def to_s
+        "#<procedure:#{ @name }>"
+      end
+    end
+    
+    class Syntax < Function
+      def call(scope, cells)
+        @body.call(scope, *cells)
+      end
+      
+      def to_s
+        "#<syntax:#{ @name }>"
+      end
+    end
+    
+  end
+end
+

data/lib/runtime/callable/macro.rb

@@ -0,0 +1,170 @@
+# Quotations taken from the R5RS spec
+# http://www.schemers.org/Documents/Standards/R5RS/HTML/r5rs-Z-H-7.html
+module Heist
+  class Runtime
+    
+    class Macro < Syntax
+      ELLIPSIS = '...'
+      
+      %w[expansion splice matches].each do |klass|
+        require RUNTIME_PATH + 'callable/macro/' + klass
+      end
+      
+      def initialize(scope, *args)
+        super
+        @hygienic = scope.runtime.hygienic?
+      end
+      
+      def call(scope, cells)
+        @calling_scope = scope
+        rule, matches = *rule_for(cells)
+        
+        return Expansion.new(expand_template(rule.last, matches)) if rule
+        
+        # TODO include macro name in error message,
+        # and be more specific about which pattern failed
+        input = cells.map { |c| c.to_s } * ' '
+        raise SyntaxError.new(
+          "Bad syntax: no macro expansion found for (#{@name} #{input})")
+      end
+      
+      def to_s
+        "#<macro:#{ @name }>"
+      end
+      
+    private
+      
+      def rule_for(cells)
+        @body.each do |rule|
+          matches = rule_matches(rule.first.rest, cells)
+          return [rule, matches] if matches
+        end
+        nil
+      end
+      
+      # More formally, an input form F matches a pattern P if and only if:
+      # 
+      #     * P is a non-literal identifier; or
+      #     * P is a literal identifier and F is an identifier with the
+      #       same binding; or
+      #     * P is a list (P1 ... Pn) and F is a list of n forms that match
+      #       P1 through Pn, respectively; or
+      #     * P is an improper list (P1 P2 ... Pn . Pn+1) and F is a list
+      #       or improper list of n or more forms that match P1 through Pn,
+      #       respectively, and whose nth 'cdr' matches Pn+1; or
+      #     * P is of the form (P1 ... Pn Pn+1 <ellipsis>) where <ellipsis>
+      #       is the identifier '...' and F is a proper list of at least n forms,
+      #       the first n of which match P1 through Pn, respectively, and
+      #       each remaining element of F matches Pn+1; or
+      #     * P is a vector of the form #(P1 ... Pn) and F is a vector of n
+      #       forms that match P1 through Pn; or
+      #     * P is of the form #(P1 ... Pn Pn+1 <ellipsis>) where <ellipsis>
+      #       is the identifier '...' and F is a vector of n or more forms the
+      #       first n of which match P1 through Pn, respectively, and each
+      #       remaining element of F matches Pn+1; or
+      #     * P is a datum and F is equal to P in the sense of the 'equal?'
+      #       procedure.
+      # 
+      # It is an error to use a macro keyword, within the scope of its
+      # binding, in an expression that does not match any of the patterns.
+      # 
+      def rule_matches(pattern, input, matches = Matches.new, depth = 0)
+        case pattern
+        
+          when List then
+            return nil unless List === input
+            idx = 0
+            pattern.each_with_index do |token, i|
+              followed_by_ellipsis = (pattern[i+1].to_s == ELLIPSIS)
+              dx = followed_by_ellipsis ? 1 : 0
+              
+              matches.depth = depth + dx
+              next if token.to_s == ELLIPSIS
+              
+              consume = lambda { rule_matches(token, input[idx], matches, depth + dx) }
+              return nil unless value = consume[] or followed_by_ellipsis
+              next unless value
+              idx += 1
+              
+              idx += 1 while idx < input.size and
+                             followed_by_ellipsis and
+                             consume[]
+            end
+            return nil unless idx == input.size
+        
+          when Identifier then
+            return (pattern.to_s == input.to_s) if @formals.include?(pattern.to_s)
+            matches.put(pattern, input)
+            return nil if input.nil?
+        
+          else
+            return pattern == input ? true : nil
+        end
+        matches
+      end
+      
+      # When a macro use is transcribed according to the template of the
+      # matching <syntax rule>, pattern variables that occur in the template
+      # are replaced by the subforms they match in the input. Pattern variables
+      # that occur in subpatterns followed by one or more instances of the
+      # identifier '...' are allowed only in subtemplates that are followed
+      # by as many instances of '...'. They are replaced in the output by all
+      # of the subforms they match in the input, distributed as indicated. It
+      # is an error if the output cannot be built up as specified.
+      # 
+      # Identifiers that appear in the template but are not pattern variables
+      # or the identifier '...' are inserted into the output as literal
+      # identifiers. If a literal identifier is inserted as a free identifier
+      # then it refers to the binding of that identifier within whose scope
+      # the instance of 'syntax-rules' appears. If a literal identifier is
+      # inserted as a bound identifier then it is in effect renamed to prevent
+      # inadvertent captures of free identifiers.
+      # 
+      def expand_template(template, matches, depth = 0, inspection = false)
+        case template
+        
+          when List then
+            result = List.new
+            template.each_with_index do |cell, i|
+              followed_by_ellipsis = (template[i+1].to_s == ELLIPSIS)
+              dx = followed_by_ellipsis ? 1 : 0
+              
+              matches.inspecting(depth + 1) if followed_by_ellipsis and
+                                               not inspection
+              
+              if cell.to_s == ELLIPSIS and not inspection
+                repeater = template[i-1]
+                matches.expand! { result << expand_template(repeater, matches, depth + 1) }
+                matches.depth = depth
+              else
+                inspect = inspection || (followed_by_ellipsis && depth + 1)
+                value = expand_template(cell, matches, depth + dx, inspect)
+                result << value unless inspect
+              end
+            end
+            result
+        
+          when Identifier then
+            return matches.get(template) if matches.defined?(template)
+            return Identifier.new(template) unless @hygienic
+            
+            @scope.defined?(template) ?
+                Binding.new(template, @scope, false) :
+                rename(template)
+        
+          else
+            template
+        end
+      end
+      
+      def rename(id)
+        return id unless @calling_scope.defined?(id)
+        i = 1
+        i += 1 while @calling_scope.defined?("#{id}#{i}")
+        Identifier.new("#{id}#{i}")
+      end
+    end
+    
+  end
+end
+