rubylisp 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bb83eafd57c37cbb7ef8e45248b31ec8aed7b124
-  data.tar.gz: e9660c1b0bf3b359b18d0ff10af7b21790ef32cd
+  metadata.gz: ed25cdabf9d69adf654828879d800947d2d69624
+  data.tar.gz: cc25906946d3020ead7a82284a65f47796cc16f5
 SHA512:
-  metadata.gz: 6023b05ca6246ea48b013ff1449063925b77d164aa938682d4601a8a7197d00260a582e9bc3d4acc71b14e9517b70259bc09d0557641d1c1722c9cd4050d85cb
-  data.tar.gz: 8a4dcc8eec4c6c0bf60c17a15ee195aa08ca8a4a18fd0080622a0cf0676d56b64be890efd9eff4e781bce4d576f445112b718008ef8a6bd875bba1d43cb23afb
+  metadata.gz: 7984fd29e98ac9c002d515954630d894802c9c2a1e161a3e6cc880033f959b761845a23d9f198b98303bfb10a40c91660c51045d89db09fbb1f9eefe400752a5
+  data.tar.gz: 4f675b07e8f92ac250eeef84eeaf1a7cb8cecd56ca810d9d38b2bd4fa7797a3fd8e417376a7d682b5908569d64bc64532f52bd21e8c3e04782a91f3bb024ed6e

data/README.md

@@ -0,0 +1,82 @@
+## Overview
+
+RubyLisp is a relatively simple Lisp dialect based on Scheme
+implimented using Ruby.
+
+RubyLisp is a lexically scoped Lisp-1:
+
+**Lexically scoped:**  
+The scope of definitions are determined by where they are made in the
+lexical structure of the code. Each `lambda`, `let`, and `do` creates
+a new lexical scope. From [2]:
+
+> Here references to the established entity can occur only within
+> certain program portions that are lexically (that is, textually)
+> contained within the establishing construct. Typically the construct
+> will have a part designated the body, and the scope of all entities
+> established will be (or include) the body.
+
+**Lisp-1:**  
+A Lisp where functions and variables share a single namespace. This
+differs from a Lisp-2 in which functions and variables have separate
+namespaces.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rubylisp'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rubylisp
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (git checkout -b my-new-feature)
+3. Commit your changes (git commit -am 'Add some feature')
+4. Push to the branch (git push origin my-new-feature)
+5. Create new Pull Request
+
+## REPL
+
+RubyLisp includes a very basic REPL that, as expected, lets you type
+in snippets (it does not support multiline snippets) of Lisp code,
+evaluates them, and prints the result.
+
+    >: rubylisp
+
+    RubyLisp REPL
+    > 4
+    4
+    > (+ 2 3)
+    5
+    > (define (fib x) (if (eq? x 0) 1 (* x (fib (- x 1)))))
+    <function: fib>
+    > (fib 4)
+    24
+
+## Integrating
+
+
+The simplist way to integrate RubyLisp is to have it parse and
+evaluate strings of lisp code.
+
+    >: irb
+    2.0.0-p247 :001 > require 'rubylisp'
+     => true
+    2.0.0-p247 :002 > Lisp::Initializer.register_builtins
+     => ...
+    2.0.0-p247 :003 > Lisp::Parser.new.parse_and_eval('(+ 1 2)').to_s
+     => "3"
+    2.0.0-p247 :004 >
+
+But lets say you are using rubylisp to do something more embedded such as provide an extension language to your application. It's easy to provide the Lisp runtime with functions written in Ruby that can be called from Lisp code.
+
+to be continued...
+

data/bin/rubylisp

@@ -4,15 +4,21 @@ require 'rubylisp'
 require 'readline'
 
 Lisp::Initializer.register_builtins
+Lisp::Debug.interactive = true
 
 puts 'RubyLisp REPL'
+puts 'Copyright 2014 David R. Astels'
+puts
 parser = Lisp::Parser.new
 
 while line = Readline.readline('> ', true)
   begin 
     puts parser.parse_and_eval(line)
   rescue Exception => ex
+    exit if ex.to_s == "exit"
     puts "ERROR: #{ex}"
+    puts ex.backtrace
   end
 end
 
+

data/lib/rubylisp/alist.rb

@@ -14,12 +14,12 @@ module Lisp
     end
 
     def self.acons_impl(args, env)
-      raise "acons require at least 2 or 3 arguments" unless args.length == 2 || args.length == 3
+      return Lisp::Debug.process_error("acons require at least 2 or 3 arguments", env) unless args.length == 2 || args.length == 3
       key = args.car.evaluate(env)
       value = args.cadr.evaluate(env)
       alist = args.length == 2 ? nil : args.caddr.evaluate(env)
       alist = Lisp::AList.from_list(alist) if !alist.nil? && alist.list? && !alist.alist?
-      raise "the last argument to acons has to be an association list" unless alist.nil? || alist.alist?
+      return Lisp::Debug.process_error("the last argument to acons has to be an association list", env) unless alist.nil? || alist.alist?
 
       if alist.nil?
         Lisp::AList.new({key => value})
@@ -29,44 +29,44 @@ module Lisp
     end
 
     def self.assoc_impl(args, env)
-      raise "assoc require 2 arguments" unless args.length == 2
+      return Lisp::Debug.process_error("assoc require 2 arguments", env) unless args.length == 2
       key = args.car.evaluate(env)
       alist = args.cadr.evaluate(env)
       alist = Lisp::AList.from_list(alist) if alist.list? && !alist.alist?
-      raise "the last argument to assoc has to be an association list" unless alist.alist?
+      return Lisp::Debug.process_error("the last argument to assoc has to be an association list", env) unless alist.alist?
       alist.assoc(key)
     end
 
     def self.rassoc_impl(args, env)
-      raise "assoc require 2 arguments" unless args.length == 2
+      return Lisp::Debug.process_error("assoc require 2 arguments", env) unless args.length == 2
       value = args.car.evaluate(env)
       alist = args.cadr.evaluate(env)
       alist = Lisp::AList.from_list(alist) if alist.list? && !alist.alist?
-      raise "the last argument to rassoc has to be an association list" unless alist.alist?
+      return Lisp::Debug.process_error("the last argument to rassoc has to be an association list", env) unless alist.alist?
       alist.rassoc(value)
     end
 
     def self.dissoc_impl(args, env)
-      raise "assoc require 2 arguments" unless args.length == 2
+      return Lisp::Debug.process_error("assoc require 2 arguments", env) unless args.length == 2
       key = args.car.evaluate(env)
       alist = args.cadr.evaluate(env)
       alist = Lisp::AList.from_list(alist) if alist.list? && !alist.alist?
-      raise "the last argument to dissoc has to be an association list" unless alist.alist?
+      return Lisp::Debug.process_error("the last argument to dissoc has to be an association list", env) unless alist.alist?
       alist.dissoc(key)
     end
 
     def self.zip_impl(args, env)
-      raise "assoc require 2 or 3arguments" unless args.length == 2 || args.length == 3
+      return Lisp::Debug.process_error("assoc require 2 or 3arguments", env) unless args.length == 2 || args.length == 3
       key_list = args.car.evaluate(env)
-      raise "the keys supplied to zip has to be a list" unless key_list.list?
+      return Lisp::Debug.process_error("the keys supplied to zip has to be a list", env) unless key_list.list?
       value_list = args.cadr.evaluate(env)
-      raise "the values supplied to zip has to be a list" unless value_list.list?
-      raise "zip requires the same number of keys and values" unless key_list.length == value_list.length
+      return Lisp::Debug.process_error("the values supplied to zip has to be a list", env) unless value_list.list?
+      return Lisp::Debug.process_error("zip requires the same number of keys and values", env) unless key_list.length == value_list.length
 
       if args.length == 3
         alist = args.caddr.evaluate(env)
         alist = Lisp::AList.from_list(alist) if alist.list? && !alist.alist?
-        raise "the third argument to zip has to be an association list" unless alist.alist?
+        return Lisp::Debug.process_error("the third argument to zip has to be an association list", env) unless alist.alist?
         alist.zip(key_list.to_a, value_list.to_a)
       else
         Lisp::AList.zip(key_list.to_a, value_list.to_a)
@@ -74,18 +74,18 @@ module Lisp
     end
 
     def self.alist_to_list_impl(args, env)
-      raise "alist-to-list requires 1 arguments" unless args.length == 1
+      return Lisp::Debug.process_error("alist-to-list requires 1 arguments", env) unless args.length == 1
       alist = args.car.evaluate(env)
       return alist if alist.list? && !alist.alist?
-      raise "the argument to alist-to-list has to be an association list" unless alist.alist?
+      return Lisp::Debug.process_error("the argument to alist-to-list has to be an association list", env) unless alist.alist?
             
       alist.to_list
     end
     
     def self.list_to_alist_impl(args, env)
-      raise "list-to-alist requires 1 arguments" unless args.length == 1
+      return Lisp::Debug.process_error("list-to-alist requires 1 arguments", env) unless args.length == 1
       list = args.car.evaluate(env)
-      raise "the argument to list-to-alist has to be a list" unless list.list?
+      return Lisp::Debug.process_error("the argument to list-to-alist has to be a list", env) unless list.list?
             
       Lisp::AList.from_list(list)
     end

data/lib/rubylisp/assignment.rb

@@ -25,7 +25,7 @@ The `new-value` sexpr is evaluated to arrive at the new value to be bound to. Us
     
     def self.setbang_impl(args, env)
       sym = args.car
-      raise "set! requires a raw (unevaluated) symbol as it's first argument." unless sym.symbol?
+      return Lisp::Debug.process_error("set! requires a raw (unevaluated) symbol as it's first argument.", env) unless sym.symbol?
       value = args.cadr.evaluate(env)
       env.set(sym, value)
     end
@@ -33,7 +33,7 @@ The `new-value` sexpr is evaluated to arrive at the new value to be bound to. Us
     
     def self.setcarbang_impl(args, env)
       pair = args.car.evaluate(env)
-      raise "set-car! requires a pair as it's first argument." unless pair.pair?
+      return Lisp::Debug.process_error("set-car! requires a pair as it's first argument.", env) unless pair.pair?
       value = args.cadr.evaluate(env)
       pair.set_car!(value)
     end
@@ -41,20 +41,20 @@ The `new-value` sexpr is evaluated to arrive at the new value to be bound to. Us
     
     def self.setcdrbang_impl(args, env)
       pair = args.car.evaluate(env)
-      raise "set-cdr! requires a pair as it's first argument." unless pair.pair?
+      return Lisp::Debug.process_error("set-cdr! requires a pair as it's first argument.", env) unless pair.pair?
       value = args.cadr.evaluate(env)
       pair.set_cdr!(value)
     end
 
 
     def self.setnthbang_impl(args, env)
-      raise "set-nth! requires 3 arguments." unless args.length == 3
+      return Lisp::Debug.process_error("set-nth! requires 3 arguments.", env) unless args.length == 3
       n = args.car.evaluate(env)
-      raise "The first argument of set-nth! has to be an number." unless n.number?
-      raise "The first argument of set-nth! has to be positive." unless n.value > 0
+      return Lisp::Debug.process_error("The first argument of set-nth! has to be an number.", env) unless n.number?
+      return Lisp::Debug.process_error("The first argument of set-nth! has to be positive.", env) unless n.value > 0
 
       l = args.cadr.evaluate(env)
-      raise "set-nth! requires a list or vector as it's first argument." unless l.list? || l.vector?
+      return Lisp::Debug.process_error("set-nth! requires a list or vector as it's first argument.", env) unless l.list? || l.vector?
       value = args.caddr.evaluate(env)
       l.set_nth!(n.value, value)
       l

data/lib/rubylisp/builtins.rb

@@ -25,6 +25,7 @@ module Lisp
       Lisp::ClassObject.register
       Lisp::System.register
       Lisp::Vector.register
+      Lisp::Debug.register
     end
   end
 

data/lib/rubylisp/character.rb

@@ -99,39 +99,40 @@ module Lisp
 
 
     def self.char_name_impl(args, env)
-      raise "char->name requires a single argument, found #{args.length}" unless args.length == 1
+      return Lisp::Debug.process_error("char->name requires a single argument, found #{args.length}", env) unless args.length == 1
       char = args.car.evaluate(env)
-      raise "char->name requires a character argument" unless char.character?
+      return Lisp::Debug.process_error("char->name requires a character argument", env) unless char.character?
       kv = @@character_constants.rassoc(char)
       return Lisp::String.with_value(kv[0]) unless kv.nil?
-      raise "char->name was passed an invalid character"
+      return Lisp::Debug.process_error("char->name was passed an invalid character", env)
     end
 
 
     def self.name_char_impl(args, env)
-      raise "name->char requires a single argument, found #{args.length}" unless args.length == 1
+      return Lisp::Debug.process_error("name->char requires a single argument, found #{args.length}", env) unless args.length == 1
       name = args.car.evaluate(env)
-      raise "name->char requires a string argument" unless name.string?
+      return Lisp::Debug.process_error("name->char requires a string argument", env) unless name.string?
       ch = find_character_for_name(name.value)
       return ch unless ch.nil?
-      raise "There is no character with the name #{name}"
+      return Lisp::Debug.process_error("There is no character with the name #{name}", env)
     end
 
 
     def self.get_one_character_arg(func, args, env)
-      raise "#{func} requires a character argument, found no args" unless args.length >= 1
+      return Lisp::Debug.process_error("#{func} requires a character argument, found no args", env) unless args.length >= 1
       char1 = args.car.evaluate(env)
-      raise "#{func} requires a character argument, found #{char1}" unless char1.character?
+      return Lisp::Debug.process_error("#{func} requires a character argument, found #{char1}", env) unless char1.character?
       return char1
     end
 
 
     def self.get_two_character_args(func, args, env)
-      raise "#{func} requires two arguments, found #{args.length}" unless args.length == 2
+      return Lisp::Debug.process_error("#{func} requires two arguments, found
+                                ##{args.length}", env) unless args.length == 2
       char1 = args.car.evaluate(env)
-      raise "#{func} requires character arguments, found #{char1}" unless char1.character?
+      return Lisp::Debug.process_error("#{func} requires character arguments, found #{char1}", env) unless char1.character?
       char2 = args.cadr.evaluate(env)
-      raise "#{func} requires character arguments, found #{char2}" unless char2.character?
+      return Lisp::Debug.process_error("#{func} requires character arguments, found #{char2}", env) unless char2.character?
       return [char1, char2]
     end
 
@@ -197,7 +198,7 @@ module Lisp
 
 
     def self.charp_impl(args, env)
-      raise "char->name requires a single argument, found #{args.length}" unless args.length == 1
+      return Lisp::Debug.process_error("char->name requires a single argument, found #{args.length}", env) unless args.length == 1
       char = args.car.evaluate(env)
       Lisp::Boolean.with_value(char.character?)
     end
@@ -221,8 +222,8 @@ module Lisp
                10
              else
                b = args.cadr.evaluate(env)
-               raise "Base for char->digit has to be an integer" unless b.integer?
-               raise "Base for char->digit has to be between 2 and 36" unless b.value >=2 && b.value <= 36
+               return Lisp::Debug.process_error("Base for char->digit has to be an integer", env) unless b.integer?
+               return Lisp::Debug.process_error("Base for char->digit has to be between 2 and 36", env) unless b.value >=2 && b.value <= 36
                b.value
              end
       ch = char.value.upcase
@@ -246,13 +247,13 @@ module Lisp
 
     def self.digit_char_impl(args, env)
       d = args.car.evaluate(env)
-      raise "Digit value for digit->char has to be an integer" unless d.integer?
+      return Lisp::Debug.process_error("Digit value for digit->char has to be an integer", env) unless d.integer?
       base = if args.length == 1
                10
              else
                b = args.cadr.evaluate(env)
-               raise "Base for char->digit has to be an integer" unless b.integer?
-               raise "Base for char->digit has to be between 2 and 36" unless b.value >=2 && b.value <= 36
+               return Lisp::Debug.process_error("Base for char->digit has to be an integer", env) unless b.integer?
+               return Lisp::Debug.process_error("Base for char->digit has to be between 2 and 36", env) unless b.value >=2 && b.value <= 36
                b.value
              end
       val = d.value
@@ -269,7 +270,7 @@ module Lisp
 
     def self.int_char_impl(args, env)
       i = args.car.evaluate(env)
-      raise "Integer value for int->char has to be an integer" unless i.integer?
+      return Lisp::Debug.process_error("Integer value for int->char has to be an integer", env) unless i.integer?
       find_character_for_chr(i.value.chr)
     end
 
@@ -374,10 +375,10 @@ module Lisp
       elsif n[0..1] == "U+"
         find_character_for_chr(n[2..-1].to_i(16).chr)
       else
-        raise "Invalid character name: #{n}"
+        return Lisp::Debug.process_error("Invalid character name: #{n}", env)
       end
     end
 
-end
+  end
 
 end

data/lib/rubylisp/cons_cell.rb

@@ -123,6 +123,8 @@ module Lisp
     def to_s
       return "()" if self.empty?
       return "'#{@cdr.car.to_s}" if @car.symbol? && @car.name == "quote"
+      return "{#{@cdr.to_s_helper}}" if @car.symbol? && @car.name == "make-frame"
+      return "[#{@cdr.to_s_helper}]" if @car.symbol? && @car.name == "make-vector"
       return "(#{@car.to_s} . #{@cdr.to_s})" if !@cdr.nil? && !@cdr.pair?
       return "(#{self.to_s_helper})"
     end
@@ -134,6 +136,8 @@ module Lisp
     def print_string
       return "()" if self.empty?
       return "'#{@cdr.car.print_string}" if @car.symbol? && @car.name == "quote"
+      return "{#{@cdr.print_string_helper}}" if @car.symbol? && @car.name == "make-frame"
+      return "[#{@cdr.print_string_helper}]" if @car.symbol? && @car.name == "make-vector"
       return "(#{@car.print_string} . #{@cdr.print_string})" if !@cdr.nil? && !@cdr.pair?
       return "(#{self.print_string_helper})"
     end
@@ -203,13 +207,52 @@ module Lisp
       return nil unless obj.object?
       return obj.value
     end
+
+    
+
+    def inner_eval(env)
+      func = @car.evaluate(env)
+      return Lisp::Debug.process_error("There is no function or macro named #{@car}", env) if func.nil?
+      env.current_code.unshift(self.print_string()) if !Lisp::Debug.eval_in_debug_repl && Lisp::Debug.interactive
+
+      Lisp::Debug.log_eval(self, env)
       
+      unless Lisp::Debug.eval_in_debug_repl
+        if !Lisp::Debug.target_env.nil? && env == Lisp::Debug.target_env.previous
+          Lisp::Debug.target_env = nil
+          Lisp::Debug.debug_repl(env)
+        elsif Lisp::Debug.single_step || (func.function? && Lisp::Debug.on_entry.include?(func.name))
+          Lisp::Debug.debug_repl(env)
+        end
+      end
+      result = func.apply_to(@cdr, env)
+      env.current_code.shift() if !Lisp::Debug.eval_in_debug_repl && Lisp::Debug.interactive
+      Lisp::Debug.log_result(result, env)
+      result
+    end
+    
 
     def evaluate(env)
       return self if empty?
-      func = @car.evaluate(env)
-      raise "There is no function or macro named #{@car}" if func.nil?
-      func.apply_to(@cdr, env)
+      sexpr = if @car.symbol?
+                key = @car
+                frame = nth(2)
+                value = nth(3)
+                
+                s = key.name
+                if s.end_with?(":")
+                  ConsCell.array_to_list([Symbol.named("get-slot"), frame, key])
+                elsif s.end_with?(":!")
+                  ConsCell.array_to_list([Symbol.named("set-slot!"), frame, Symbol.named(s[0..-2]), value])
+                elsif s.end_with?(":?")
+                  ConsCell.array_to_list([Symbol.named("has-slot?"), frame, Symbol.named(s[0..-2])])
+                else
+                  self
+                end
+              else
+                self
+              end
+      sexpr.inner_eval(env)
     end
 
     def evaluate_each(env)