heist 0.2.0 → 0.2.1

data/README.txt

@@ -1,5 +1,7 @@
 = Heist
 
+http://github.com/jcoglan/heist
+
 Heist is a Scheme interpreter written in Ruby. It provides an executable
 for running Scheme code directly, and also allows the interpreter to be
 easily embedded in, and extended using, Ruby applications. It nominally

data/lib/builtin/library.scm

@@ -2,6 +2,7 @@
 ; in Scheme should go here. If at all possible, write
 ; builtins in Scheme rather than Ruby.
 
+
 ; (newline)
 ; prints a new-line character
 (define (newline)
@@ -53,6 +54,19 @@
 ; Returns true iff x is not an exact number
 (define inexact? (negate exact?))
 
+; Returns true iff all arguments are numerically equal
+(define (= . args)
+  (define (iter x rest)
+    (if (null? rest)
+        #t
+        (let ([y (car rest)])
+          (if (or (not (number? x))
+                  (not (number? y))
+                  (not (equal? x y)))
+              #f
+              (iter x (cdr rest))))))
+  (iter (car args) (cdr args)))
+
 ; (zero? x)
 ; Returns true iff x is zero
 (define (zero? x)
@@ -99,6 +113,37 @@
       (- x)
       x))
 
+; (quotient) and (remainder) satisfy
+; 
+; (= n1 (+ (* n2 (quotient n1 n2))
+;          (remainder n1 n2)))
+
+; (quotient x y)
+; Returns the quotient of two numbers, i.e. performs n1/n2
+; and rounds toward zero.
+(define (quotient x y)
+  (let ([result (/ x y)])
+    ((if (positive? result)
+         floor
+         ceiling)
+     result)))
+
+; (remainder x y)
+; Returns the remainder after dividing the first operand
+; by the second
+(define (remainder x y)
+  (- (round x)
+     (* (round y)
+        (quotient x y))))
+
+; (modulo x y)
+; Returns the first operand modulo the second
+(define (modulo x y)
+  (+ (remainder x y)
+     (if (negative? (* x y))
+         (round y)
+         0)))
+
 ; (gcd x y)
 ; Returns the greatest common divisor of two numbers
 ; http://en.wikipedia.org/wiki/Euclidean_algorithm
@@ -184,10 +229,10 @@
 ; The final argument is not copied and the return value of
 ; (append) shares structure with it.
 (define (append first . rest)
-  (if (null? first)
-      (apply append rest)
-      (if (null? rest)
-          first
+  (if (null? rest)
+      first
+      (if (null? first)
+          (apply append rest)
           (let ([copy (apply list first)])
             (do ([pair copy (cdr pair)])
                 ((null? (cdr pair))

data/lib/builtin/primitives.rb

@@ -32,14 +32,6 @@ syntax('define-syntax') do |scope, cells|
   scope[cells.car] = Heist.evaluate(cells.cdr.car, scope)
 end
 
-syntax('let-syntax') do |*args|
-  call('let', *args)
-end
-
-syntax('letrec-syntax') do |*args|
-  call('letrec', *args)
-end
-
 syntax('syntax-rules') do |scope, cells|
   Macro.new(scope, cells.car, cells.cdr)
 end
@@ -74,7 +66,8 @@ end
 
 # Control structures
 
-# (begin) simply executes a series of lists in the current scope.
+# (begin) simply executes a series of expressions in the
+# current scope and returns the value of the last one
 syntax('begin') do |scope, cells|
   Body.new(cells, scope)
 end
@@ -146,12 +139,6 @@ define('exact?') do |value|
                                call('rational?', value.imag))
 end
 
-# TODO raise an exception if they're not numeric
-# Returns true iff all arguments are numerically equal
-define('=') do |*args|
-  args.all? { |arg| arg == args.first }
-end
-
 # Returns true iff the arguments are monotonically decreasing
 define('>') do |*args|
   result = true
@@ -219,8 +206,7 @@ end
 #----------------------------------------------------------------
 
 # Numerical functions
-# TODO implement exact?, inexact?, numerator, denominator, rationalize,
-#                complex functions, exact->inexact and vice versa
+# TODO implement rationalize, exact->inexact and vice versa
 
 # Returns the sum of all arguments passed
 define('+') do |*args|
@@ -245,29 +231,6 @@ define('/') do |op1, op2|
   op2.nil? ? Heist.divide(1, op1) : Heist.divide(op1, op2)
 end
 
-# (quotient) and (remainder) satisfy
-# 
-# (= n1 (+ (* n2 (quotient n1 n2))
-#          (remainder n1 n2)))
-
-# Returns the quotient of two numbers, i.e. performs n1/n2
-# and rounds toward zero.
-define('quotient') do |op1, op2|
-  result = op1.to_i.to_f / op2.to_i
-  result > 0 ? result.floor : result.ceil
-end
-
-# Returns the remainder after dividing the first operand
-# by the second
-define('remainder') do |op1, op2|
-  op1.to_i - op2.to_i * call('quotient', op1, op2)
-end
-
-# Returns the first operand modulo the second
-define('modulo') do |op1, op2|
-  op1.to_i % op2.to_i
-end
-
 # Returns the numerator of a number
 define('numerator') do |value|
   Rational === value ? value.numerator : value

data/lib/heist.rb

@@ -9,7 +9,7 @@ require 'treetop'
 # utility methods that don't belong anywhere else. See the README for an
 # overview of Heist's features.
 module Heist
-  VERSION = '0.2.0'
+  VERSION = '0.2.1'
   
   ROOT_PATH    = File.expand_path(File.dirname(__FILE__))
   PARSER_PATH  = ROOT_PATH + '/parser/'

data/lib/parser/nodes.rb

@@ -32,7 +32,7 @@ module Heist
       # and raw Ruby data ready for interpretation using a +Runtime+.
       def convert!
         return if @data
-        @data = Runtime::Cons.construct(elements, true) { |c| c.eval }
+        @data = Runtime::Cons.construct(elements[1].elements, true) { |c| c.eval }
       end
     end
     

data/lib/parser/scheme.rb

@@ -6,6 +6,9 @@ module Heist
       @root || :program
     end
 
+    module Program0 #:nodoc:
+    end
+
     def _nt_program
       start_index = index
       if node_cache[:program].has_key?(index)
@@ -14,18 +17,129 @@ module Heist
         return cached
       end
 
-      s0, i0 = [], index
+      i0, s0 = index, []
+      r2 = _nt_shebang
+      if r2
+        r1 = r2
+      else
+        r1 = SyntaxNode.new(input, index...index)
+      end
+      s0 << r1
+      if r1
+        s3, i3 = [], index
+        loop do
+          r4 = _nt_cell
+          if r4
+            s3 << r4
+          else
+            break
+          end
+        end
+        r3 = SyntaxNode.new(input, i3...index, s3)
+        s0 << r3
+      end
+      if s0.last
+        r0 = (Program).new(input, i0...index, s0)
+        r0.extend(Program0)
+      else
+        self.index = i0
+        r0 = nil
+      end
+
+      node_cache[:program][start_index] = r0
+
+      return r0
+    end
+
+    module Shebang0 #:nodoc:
+    end
+
+    module Shebang1 #:nodoc:
+    end
+
+    def _nt_shebang
+      start_index = index
+      if node_cache[:shebang].has_key?(index)
+        cached = node_cache[:shebang][index]
+        @index = cached.interval.end if cached
+        return cached
+      end
+
+      i0, s0 = index, []
+      s1, i1 = [], index
       loop do
-        r1 = _nt_cell
-        if r1
-          s0 << r1
+        r2 = _nt_space
+        if r2
+          s1 << r2
         else
           break
         end
       end
-      r0 = Program.new(input, i0...index, s0)
+      r1 = SyntaxNode.new(input, i1...index, s1)
+      s0 << r1
+      if r1
+        if input.index("#!", index) == index
+          r3 = (SyntaxNode).new(input, index...(index + 2))
+          @index += 2
+        else
+          terminal_parse_failure("#!")
+          r3 = nil
+        end
+        s0 << r3
+        if r3
+          s4, i4 = [], index
+          loop do
+            i5, s5 = index, []
+            i6 = index
+            if input.index(Regexp.new('[\\n\\r]'), index) == index
+              r7 = (SyntaxNode).new(input, index...(index + 1))
+              @index += 1
+            else
+              r7 = nil
+            end
+            if r7
+              r6 = nil
+            else
+              self.index = i6
+              r6 = SyntaxNode.new(input, index...index)
+            end
+            s5 << r6
+            if r6
+              if index < input_length
+                r8 = (SyntaxNode).new(input, index...(index + 1))
+                @index += 1
+              else
+                terminal_parse_failure("any character")
+                r8 = nil
+              end
+              s5 << r8
+            end
+            if s5.last
+              r5 = (SyntaxNode).new(input, i5...index, s5)
+              r5.extend(Shebang0)
+            else
+              self.index = i5
+              r5 = nil
+            end
+            if r5
+              s4 << r5
+            else
+              break
+            end
+          end
+          r4 = SyntaxNode.new(input, i4...index, s4)
+          s0 << r4
+        end
+      end
+      if s0.last
+        r0 = (SyntaxNode).new(input, i0...index, s0)
+        r0.extend(Shebang1)
+      else
+        self.index = i0
+        r0 = nil
+      end
 
-      node_cache[:program][start_index] = r0
+      node_cache[:shebang][start_index] = r0
 
       return r0
     end

data/lib/parser/scheme.tt

@@ -1,7 +1,11 @@
 module Heist
   grammar Scheme
     rule program
-      cell* <Program>
+      shebang? cell* <Program>
+    end
+    
+    rule shebang
+      space* "#!" (![\n\r] .)*
     end
     
     rule cell

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

@@ -140,7 +140,7 @@ module Heist
           return id unless @calling_scope.defined?(id)
           i = 1
           i += 1 while @calling_scope.defined?("#{id}#{i}")
-          Identifier.new("#{id}#{i}")
+          Identifier.new("#{id}#{i}", id)
         end
       end
       

data/lib/runtime/data/identifier.rb

@@ -5,8 +5,9 @@ module Heist
     # code. We might throw it away and use symbols at some point. I had this
     # idea for storing metadata on +Identifier+ objects to speed things up
     # but it pretty much came to nothing. Its one saving grace is that it
-    # needs to be treated as an +Expression+ class and I don't want to
-    # modify core Ruby classes.
+    # needs to be treated as an +Expression+ class, and also that we need
+    # to store some extra metadata on +Identifier+ objects, and I don't want
+    # to modify core Ruby classes
     class Identifier
       include Expression
       
@@ -15,14 +16,21 @@ module Heist
       alias :inspect :to_s
       
       # An +Identifier+ is initialized using a string that becomes the
-      # name of the identifier.
-      def initialize(name)
+      # name of the identifier. The optional second parameter is used to
+      # specify the original name of an identifier if it has been renamed
+      # during a macro expansion.
+      def initialize(name, orginal_name = nil)
         @name = name.to_s
+        @orginal_name = (orginal_name || name).to_s
+      end
+      
+      def name
+        @orginal_name
       end
       
       # Returns +true+ if the receiver has the same name as the argument.
       def ==(other)
-        Identifier === other and @name == other.to_s
+        Identifier === other and @orginal_name == other.name
       end
       
       # Returns a raw Ruby representation of the identifier, for which

data/test/hygienic.scm

@@ -37,3 +37,10 @@
 (set! plus -)
 (assert-equal -1 (dyn-plus-call))
 
+(let-syntax ([ok? (syntax-rules ()
+                    [(_ expr)
+                     (cond [expr 'ok]
+                           [else 'no])])])
+  (let ([else #t])
+    (assert-equal 'no (ok? #f))))
+

data/test/lists.scm

@@ -56,6 +56,11 @@
 (assert-equal '(a (b) (c))  (append '(a (b)) '((c))))
 (assert-equal '(a b c . d)  (append '(a b) '(c . d)))
 (assert-equal 'a            (append '() 'a))
+(assert-equal '(a b)        (append '(a b) '()))
+(assert-equal '(a (b) (c) (1 2) 3)  (append '(a (b)) '((c)) '() '((1 2) 3)))
+
+(let ([base '(a b)])
+  (assert (eqv? (cddr (append '(1 2) base)) base)))
 
 (assert-equal '(4 3 2 1) (reverse '(1 2 3 4)))
 (assert-equal '(4 (3 5) 2 1) (reverse '(1 2 (3 5) 4)))

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: heist
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors: 
 - James Coglan
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-01 00:00:00 +01:00
+date: 2009-05-19 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -40,7 +40,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.8.2
+        version: 1.12.2
     version: 
 description: ""
 email: 
@@ -53,7 +53,6 @@ extra_rdoc_files:
 - History.txt
 - Manifest.txt
 - README.txt
-- test/plt-macros.txt
 files: 
 - History.txt
 - Manifest.txt
@@ -112,7 +111,9 @@ files:
 - test/unhygienic.scm
 - test/vars.scm
 has_rdoc: true
-homepage: Heist is a Scheme interpreter written in Ruby. It provides an executable
+homepage: http://github.com/jcoglan/heist
+licenses: []
+
 post_install_message: 
 rdoc_options: 
 - --main
@@ -134,9 +135,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: heist
-rubygems_version: 1.3.1
+rubygems_version: 1.3.3
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: ""
 test_files: 
 - test/test_heist.rb