rubylisp 0.1.1 → 0.2.0

data/lib/rubylisp/io.rb

@@ -13,9 +13,9 @@ module Lisp
 
 
     def self.load_impl(args, env)
-      raise "'load' requires 1 argument." if args.empty?
+      return Lisp::Debug.process_error("'load' requires 1 argument.", env) if args.empty?
       fname = args.car.evaluate(env)
-      raise "'load' requires a string argument." unless fname.string?
+      return Lisp::Debug.process_error("'load' requires a string argument.", env) unless fname.string?
       filename = fname.value.end_with?(".lsp") ? fname.value : "#{fname.value}.lsp"
       File.open(filename) do |f|
         contents = f.read()
@@ -26,9 +26,9 @@ module Lisp
 
     
     def self.load_library_impl(args, env)
-      raise "'load-library' requires 1 argument." if args.empty?
+      return Lisp::Debug.process_error("'load-library' requires 1 argument.", env) if args.empty?
       library_name = args.car.evaluate(env)
-      raise "'load-library' requires a string or symbol argument." unless library_name.string? || library_name.symbol?
+      return Lisp::Debug.process_error("'load-library' requires a string or symbol argument.", env) unless library_name.string? || library_name.symbol?
       Dir.chdir(File.join(App.documents_path, "libraries", "#{library_name}.lib")) do |d|
         if File.exists?("load.lsp")
           File.open("load.lsp") do |f|
@@ -49,9 +49,9 @@ module Lisp
 
     
     def self.load_project_impl(args, env)
-      raise "'load-project' requires 1 argument." if args.empty?
+      return Lisp::Debug.process_error("'load-project' requires 1 argument.", env) if args.empty?
       project_name = args.car.evaluate(env)
-      raise "'load-project' requires a string or symbol argument." unless project_name.string? || project_name.symbol?
+      return Lisp::Debug.process_error("'load-project' requires a string or symbol argument.", env) unless project_name.string? || project_name.symbol?
       Dir.chdir(File.join(App.documents_path, "projects", "#{project_name}.prj")) do |d|
         if File.exists?("load.lsp")
           File.open("load.lsp") do |f|

data/lib/rubylisp/list_support.rb

@@ -59,7 +59,7 @@ module Lisp
 
 
     def self.cons_impl(args, env)
-      raise "cons requires two arguments." unless args.length == 2
+      return Lisp::Debug.process_error("cons requires two arguments.", env) unless args.length == 2
       left = args.car.evaluate(env)
       right = args.cadr.evaluate(env)
       Lisp::ConsCell.cons(left, right)
@@ -85,9 +85,9 @@ module Lisp
 
 
     def self.make_list_impl(args, env)
-      raise "consmake-list requires one or two arguments." unless args.length == 1 || args.length == 2
+      return Lisp::Debug.process_error("consmake-list requires one or two arguments.", env) unless args.length == 1 || args.length == 2
       arg1 = args.car.evaluate(env)
-      raise "make-list requires an integer for it's first argument, received: #{args.car}" unless arg1.integer?
+      return Lisp::Debug.process_error("make-list requires an integer for it's first argument, received: #{args.car}", env) unless arg1.integer?
       count = arg1.value
       val = if args.length == 1
               nil
@@ -101,16 +101,16 @@ module Lisp
 
 
     def self.iota_impl(args, env)
-      raise "iota requires at least one argument." unless args.length > 0
+      return Lisp::Debug.process_error("iota requires at least one argument.", env) unless args.length > 0
       arg1 = args.car.evaluate(env)
-      raise "iota requires an positive integer for it's first argument, received: #{args.car}" unless arg1.integer? && arg1.positive?
+      return Lisp::Debug.process_error("iota requires an positive integer for it's first argument, received: #{args.car}", env) unless arg1.integer? && arg1.positive?
       count = arg1.value
 
       start = if args.length < 2
                 0
               else
                 arg2 = args.cadr.evaluate(env)
-                raise "iota requires an number for it's second argument, received: #{args.cadr}" unless arg2.number?
+                return Lisp::Debug.process_error("iota requires an number for it's second argument, received: #{args.cadr}", env) unless arg2.number?
                 arg2.value
               end
 
@@ -118,7 +118,7 @@ module Lisp
                 1
               else
                 arg3 = args.caddr.evaluate(env)
-                raise "iota requires an number for it's third argument, received: #{args.caddr}" unless arg3.number?
+                return Lisp::Debug.process_error("iota requires an number for it's third argument, received: #{args.caddr}", env) unless arg3.number?
                 arg3.value
               end
 
@@ -140,22 +140,22 @@ module Lisp
     # in support of all the CxR functions
     def self.ad_impl(args, env, f)
       l = args.car.evaluate(env)
-      raise "list required." unless l.list?
+      return Lisp::Debug.process_error("list required.", env) unless l.list?
       l.send(f)
     end
 
 
     def self.first_impl(args, env)
       l = args.car.evaluate(env)
-      raise "rest requires a list or vector." unless l.list? || l.vector?
-      raise "list index out of bounds" unless l.length >= 1
+      return Lisp::Debug.process_error("rest requires a list or vector.", env) unless l.list? || l.vector?
+      return Lisp::Debug.process_error("list index out of bounds", env) unless l.length >= 1
       l.nth(1)
     end
 
 
     def self.rest_impl(args, env)
       l = args.car.evaluate(env)
-      raise "rest requires a list or vector." unless l.list? || l.vector?
+      return Lisp::Debug.process_error("rest requires a list or vector.", env) unless l.list? || l.vector?
       if l.list?
         l.cdr
       else
@@ -166,82 +166,82 @@ module Lisp
 
     def self.second_impl(args, env)
       l = args.car.evaluate(env)
-      raise "rest requires a list or vector." unless l.list? || l.vector?
-      raise "list index out of bounds" unless l.length >= 2
+      return Lisp::Debug.process_error("rest requires a list or vector.", env) unless l.list? || l.vector?
+      return Lisp::Debug.process_error("list index out of bounds", env) unless l.length >= 2
       l.nth(2)
     end
 
     def self.third_impl(args, env)
       l = args.car.evaluate(env)
-      raise "rest requires a list or vector." unless l.list? || l.vector?
-      raise "list index out of bounds" unless l.length >= 3
+      return Lisp::Debug.process_error("rest requires a list or vector.", env) unless l.list? || l.vector?
+      return Lisp::Debug.process_error("list index out of bounds", env) unless l.length >= 3
       l.nth(3)
     end
 
 
     def self.fourth_impl(args, env)
       l = args.car.evaluate(env)
-      raise "rest requires a list or vector." unless l.list? || l.vector?
-      raise "list index out of bounds" unless l.length >= 4
+      return Lisp::Debug.process_error("rest requires a list or vector.", env) unless l.list? || l.vector?
+      return Lisp::Debug.process_error("list index out of bounds", env) unless l.length >= 4
       l.nth(4)
     end
 
 
     def self.fifth_impl(args, env)
       l = args.car.evaluate(env)
-      raise "rest requires a list or vector." unless l.list? || l.vector?
-      raise "list index out of bounds" unless l.length >= 5
+      return Lisp::Debug.process_error("rest requires a list or vector.", env) unless l.list? || l.vector?
+      return Lisp::Debug.process_error("list index out of bounds", env) unless l.length >= 5
       l.nth(5)
     end
 
 
     def self.sixth_impl(args, env)
       l = args.car.evaluate(env)
-      raise "rest requires a list or vector." unless l.list? || l.vector?
-      raise "list index out of bounds" unless l.length >= 6
+      return Lisp::Debug.process_error("rest requires a list or vector.", env) unless l.list? || l.vector?
+      return Lisp::Debug.process_error("list index out of bounds", env) unless l.length >= 6
       l.nth(6)
     end
 
 
     def self.seventh_impl(args, env)
       l = args.car.evaluate(env)
-      raise "rest requires a list or vector." unless l.list? || l.vector?
-      raise "list index out of bounds" unless l.length >= 7
+      return Lisp::Debug.process_error("rest requires a list or vector.", env) unless l.list? || l.vector?
+      return Lisp::Debug.process_error("list index out of bounds", env) unless l.length >= 7
       l.nth(7)
     end
 
 
     def self.eighth_impl(args, env)
       l = args.car.evaluate(env)
-      raise "rest requires a list or vector." unless l.list? || l.vector?
-      raise "list index out of bounds" unless l.length >= 8
+      return Lisp::Debug.process_error("rest requires a list or vector.", env) unless l.list? || l.vector?
+      return Lisp::Debug.process_error("list index out of bounds", env) unless l.length >= 8
       l.nth(8)
     end
 
 
     def self.ninth_impl(args, env)
       l = args.car.evaluate(env)
-      raise "rest requires a list or vector." unless l.list? || l.vector?
-      raise "list index out of bounds" unless l.length >= 9
+      return Lisp::Debug.process_error("rest requires a list or vector.", env) unless l.list? || l.vector?
+      return Lisp::Debug.process_error("list index out of bounds", env) unless l.length >= 9
       l.nth(9)
     end
 
 
     def self.tenth_impl(args, env)
       l = args.car.evaluate(env)
-      raise "rest requires a list or vector." unless l.list? || l.vector?
-      raise "list index out of bounds" unless l.length >= 10
+      return Lisp::Debug.process_error("rest requires a list or vector.", env) unless l.list? || l.vector?
+      return Lisp::Debug.process_error("list index out of bounds", env) unless l.length >= 10
       l.nth(10)
     end
 
 
     def self.nth_impl(args, env)
-      raise "nth requires 2 arguments" unless args.length == 2
+      return Lisp::Debug.process_error("nth requires 2 arguments", env) unless args.length == 2
       n = args.car.evaluate(env)
-      raise "The first argument of nth has to be an number." unless n.number?
-      raise "The first argument of nth has to be positive." unless n.value > 0
+      return Lisp::Debug.process_error("The first argument of nth has to be an number.", env) unless n.number?
+      return Lisp::Debug.process_error("The first argument of nth has to be positive.", env) unless n.value > 0
       l = args.cadr.evaluate(env)
-      raise "rest requires a list or vector." unless l.list? || l.vector?
+      return Lisp::Debug.process_error("rest requires a list or vector.", env) unless l.list? || l.vector?
       l.nth(n.value)
     end
 
@@ -256,78 +256,77 @@ module Lisp
     
 
     def self.sublist_impl(args, env)
-      raise "sublist requires 3 arguments" unless args.length == 3
+      return Lisp::Debug.process_error("sublist requires 3 arguments", env) unless args.length == 3
       l = args.car.evaluate(env)
-      raise "sublist requires it's first argument to be a list or vector, but received #{args.car}" unless l.list? || l.vector?
+      return Lisp::Debug.process_error("sublist requires it's first argument to be a list or vector, but received #{args.car}", env) unless l.list? || l.vector?
       st = args.cadr.evaluate(env)
-      raise "sublist requires it's second argument to be a positive integer, but received #{args.cadr}" unless st.number? && st.positive?
-      raise "sublist requires it's second argument to be <= the list length" unless st.value <= l.length
+      return Lisp::Debug.process_error("sublist requires it's second argument to be a positive integer, but received #{args.cadr}", env) unless st.number? && st.positive?
+      return Lisp::Debug.process_error("sublist requires it's second argument to be <= the list length", env) unless st.value <= l.length
       en = args.caddr.evaluate(env)
-      raise "sublist requires it's third argument to be a positive integer, but received #{args.caddr}" unless en.number? && en.positive?
-      raise "sublist requires it's third argument to be <= the list length" unless en.value <= l.length
-      raise "sublist requires it's second argument to be <= the third argument" unless st.value <= en.value
+      return Lisp::Debug.process_error("sublist requires it's third argument to be a positive integer, but received #{args.caddr}", env) unless en.number? && en.positive?
+      return Lisp::Debug.process_error("sublist requires it's third argument to be <= the list length", env) unless en.value <= l.length
+      return Lisp::Debug.process_error("sublist requires it's second argument to be <= the third argument", env) unless st.value <= en.value
       make_same_kind_as(l, l.to_a[(st.value - 1)...en.value])
     end
 
 
     def self.list_head_impl(args, env)
-      raise "list_head requires 2 arguments" unless args.length == 2
+      return Lisp::Debug.process_error("list_head requires 2 arguments", env) unless args.length == 2
       l = args.car.evaluate(env)
-      raise "list_head requires it's first argument to be a list, but received #{args.car}" unless l.list?
+      return Lisp::Debug.process_error("list_head requires it's first argument to be a list, but received #{args.car}", env) unless l.list?
       k = args.cadr.evaluate(env)
-      raise "list_head requires it's second argument to be a positive integer, but received #{args.cadr}" unless k.number? && k.positive?
-      raise "list_head requires it's second argument to be <= the list length" unless k.value <= l.length
+      return Lisp::Debug.process_error("list_head requires it's second argument to be a positive integer, but received #{args.cadr}", env) unless k.number? && k.positive?
+      return Lisp::Debug.process_error("list_head requires it's second argument to be <= the list length", env) unless k.value <= l.length
       Lisp::ConsCell.array_to_list(l.to_a[0...k.value])
     end
 
 
     def self.take_impl(args, env)
-      raise "take requires 2 arguments" unless args.length == 2
+      return Lisp::Debug.process_error("take requires 2 arguments", env) unless args.length == 2
       k = args.car.evaluate(env)
-      raise "take requires it's first argument to be an integer >= 0, but received #{args.car}" unless k.number? && !k.negative?
+      return Lisp::Debug.process_error("take requires it's first argument to be an integer >= 0, but received #{args.car}", env) unless k.number? && !k.negative?
       l = args.cadr.evaluate(env)
-      raise "take requires it's second argument to be a list or vector, but received #{args.cadr}" unless l.list? || l.vector?
-      raise "take requires it's first argument to be <= the list length" unless k.value <= l.length
-      puts l
+      return Lisp::Debug.process_error("take requires it's second argument to be a list or vector, but received #{args.cadr}", env) unless l.list? || l.vector?
+      return Lisp::Debug.process_error("take requires it's first argument to be <= the list length", env) unless k.value <= l.length
       make_same_kind_as(l, l.to_a[0...k.value])
     end
 
 
     def self.list_tail_impl(args, env)
-      raise "list_head requires 2 arguments" unless args.length == 2
+      return Lisp::Debug.process_error("list_head requires 2 arguments", env) unless args.length == 2
       l = args.car.evaluate(env)
-      raise "list_head requires it's first argument to be a list, but received #{args.car}" unless l.list?
+      return Lisp::Debug.process_error("list_head requires it's first argument to be a list, but received #{args.car}", env) unless l.list?
       k = args.cadr.evaluate(env)
-      raise "list_head requires it's second argument to be a positive integer, but received #{args.cadr}" unless k.number? && k.positive?
-      raise "list_head requires it's second argument to be <= the list length" unless k.value <= l.length
+      return Lisp::Debug.process_error("list_head requires it's second argument to be a positive integer, but received #{args.cadr}", env) unless k.number? && k.positive?
+      return Lisp::Debug.process_error("list_head requires it's second argument to be <= the list length", env) unless k.value <= l.length
       l.nth_tail(k.value + 1)
     end
 
 
     def self.drop_impl(args, env)
-      raise "drop requires 2 arguments" unless args.length == 2
+      return Lisp::Debug.process_error("drop requires 2 arguments", env) unless args.length == 2
       k = args.car.evaluate(env)
-      raise "drop requires it's first argument to be an integer >= 0, but received #{args.car}" unless k.number? && !k.negative?
+      return Lisp::Debug.process_error("drop requires it's first argument to be an integer >= 0, but received #{args.car}", env) unless k.number? && !k.negative?
       l = args.cadr.evaluate(env)
-      raise "drop requires it's second argument to be a list or vector, but received #{args.cadr}" unless l.list? || l.vector?
-      raise "drop requires it's first argument to be <= the list length" unless k.value <= l.length
+      return Lisp::Debug.process_error("drop requires it's second argument to be a list or vector, but received #{args.cadr}", env) unless l.list? || l.vector?
+      return Lisp::Debug.process_error("drop requires it's first argument to be <= the list length", env) unless k.value <= l.length
       l.nth_tail(k.value + 1)
     end
 
 
     def self.last_pair_impl(args, env)
-      raise "last_pair requires 1 arguments" unless args.length == 1
+      return Lisp::Debug.process_error("last_pair requires 1 arguments", env) unless args.length == 1
       l = args.car.evaluate(env)
-      raise "last_pair requires it's argument to be a list, but received #{args.car}" unless l.list?
+      return Lisp::Debug.process_error("last_pair requires it's argument to be a list, but received #{args.car}", env) unless l.list?
       l.last
     end
 
 
     def self.memq_impl(args, env)
-      raise "memq requires 2 arguments but received #{args.length}." unless args.length == 2
+      return Lisp::Debug.process_error("memq requires 2 arguments but received #{args.length}.", env) unless args.length == 2
       item = args.car.evaluate(env)
       collection = args.cadr.evaluate(env)
-      raise "memq requires a list as it's second argument." unless collection.list?
+      return Lisp::Debug.process_error("memq requires a list as it's second argument.", env) unless collection.list?
       collection.length.times do |i|
         if Lisp::Equivalence.eq_check(item, collection.nth(i + 1)).value
           return collection.nth_tail(i + 1)
@@ -338,10 +337,10 @@ module Lisp
 
 
     def self.memv_impl(args, env)
-      raise "memv requires 2 arguments but received #{args.length}." unless args.length == 2
+      return Lisp::Debug.process_error("memv requires 2 arguments but received #{args.length}.", env) unless args.length == 2
       item = args.car.evaluate(env)
       collection = args.cadr.evaluate(env)
-      raise "memv requires a list as it's second argument." unless collection.list?
+      return Lisp::Debug.process_error("memv requires a list as it's second argument.", env) unless collection.list?
       collection.length.times do |i|
         if Lisp::Equivalence.eqv_check(item, collection.nth(i + 1)).value
           return collection.nth_tail(i + 1)
@@ -352,10 +351,10 @@ module Lisp
 
 
     def self.member_impl(args, env)
-      raise "member requires 2 arguments but received #{args.length}." unless args.length == 2
+      return Lisp::Debug.process_error("member requires 2 arguments but received #{args.length}.", env) unless args.length == 2
       item = args.car.evaluate(env)
       collection = args.cadr.evaluate(env)
-      raise "member requires a list as it's second argument." unless collection.list?
+      return Lisp::Debug.process_error("member requires a list as it's second argument.", env) unless collection.list?
       collection.length.times do |i|
         if Lisp::Equivalence.equal_check(item, collection.nth(i + 1)).value
           return collection.nth_tail(i + 1)
@@ -366,33 +365,33 @@ module Lisp
 
 
     def self.filter_impl(args, env)
-      raise "filter requires 2 arguments but received #{args.length}." unless args.length == 2
+      return Lisp::Debug.process_error("filter requires 2 arguments but received #{args.length}.", env) unless args.length == 2
       f = args.car.evaluate(env)
-      raise "filter requires a function as it's first argument but received #{args.car}." unless f.function? || f.primitive?
+      return Lisp::Debug.process_error("filter requires a function as it's first argument but received #{args.car}.", env) unless f.function? || f.primitive?
       collection = args.cadr.evaluate(env)
-      raise "filter requires a list or vector as it's second argument but received #{args.cadr}." unless collection.list? || collection.vector?
+      return Lisp::Debug.process_error("filter requires a list or vector as it's second argument but received #{args.cadr}.", env) unless collection.list? || collection.vector?
       results = collection.to_a.select {|item| f.apply_to_without_evaluating(Lisp::ConsCell.cons(item, nil), env).value }
       make_same_kind_as(collection, results)
     end
 
 
     def self.remove_impl(args, env)
-      raise "remove requires 2 arguments but received #{args.length}." unless args.length == 2
+      return Lisp::Debug.process_error("remove requires 2 arguments but received #{args.length}.", env) unless args.length == 2
       f = args.car.evaluate(env)
-      raise "remove requires a function as it's first argument but received #{args.car}." unless f.function? || f.primitive?
+      return Lisp::Debug.process_error("remove requires a function as it's first argument but received #{args.car}.", env) unless f.function? || f.primitive?
       collection = args.cadr.evaluate(env)
-      raise "remove requires a list or vector as it's second argument but received #{args.cadr}." unless collection.list? || collection.vector?
+      return Lisp::Debug.process_error("remove requires a list or vector as it's second argument but received #{args.cadr}.", env) unless collection.list? || collection.vector?
       results = collection.to_a.reject {|item| f.apply_to_without_evaluating(Lisp::ConsCell.cons(item, nil), env).value }
       make_same_kind_as(collection, results)
     end
 
 
     def self.partition_impl(args, env)
-      raise "partition requires 2 arguments but received #{args.length}." unless args.length == 2
+      return Lisp::Debug.process_error("partition requires 2 arguments but received #{args.length}.", env) unless args.length == 2
       f = args.car.evaluate(env)
-      raise "partition requires a function as it's first argument." unless f.function? || f.primitive?
+      return Lisp::Debug.process_error("partition requires a function as it's first argument.", env) unless f.function? || f.primitive?
       collection = args.cadr.evaluate(env)
-      raise "partition requires a list as it's second argument." unless collection.list? | collection.vector?
+      return Lisp::Debug.process_error("partition requires a list as it's second argument.", env) unless collection.list? | collection.vector?
       results = collection.to_a.partition {|item| f.apply_to_without_evaluating(Lisp::ConsCell.cons(item, nil), env).value }
       matches = make_same_kind_as(collection, results[0])
       non_matches = make_same_kind_as(collection, results[1])
@@ -401,11 +400,11 @@ module Lisp
 
 
     def self.map_impl(args, env)
-      raise "map requires at least 2 arguments but received #{args.length}." if args.length < 2
+      return Lisp::Debug.process_error("map requires at least 2 arguments but received #{args.length}.", env) if args.length < 2
       f = args.car.evaluate(env)
-      raise "map requires a function as it's first argument but received #{args.car}." unless f.function? || f.primitive?
+      return Lisp::Debug.process_error("map requires a function as it's first argument but received #{args.car}.", env) unless f.function? || f.primitive?
       collections = args.cdr.to_a.collect {|a| a.evaluate(env)}
-      raise "all requires all subsequent arguments to be lists or vectors" unless collections.all? {|l| l.list? || l.vector?}
+      return Lisp::Debug.process_error("all requires all subsequent arguments to be lists or vectors", env) unless collections.all? {|l| l.list? || l.vector?}
       all_vectors = collections.all? {|i| i.vector?}
       lists = collections.collect {|l| l.to_a }
       
@@ -430,12 +429,12 @@ module Lisp
 
 
     def self.reduce_left_impl(args, env)
-      raise "reduce requires 3 arguments but received #{args.length}." unless args.length == 3
+      return Lisp::Debug.process_error("reduce requires 3 arguments but received #{args.length}.", env) unless args.length == 3
       f = args.car.evaluate(env)
-      raise "map requires a function as it's first argument but received #{args.car}." unless f.function? || f.primitive?
+      return Lisp::Debug.process_error("map requires a function as it's first argument but received #{args.car}.", env) unless f.function? || f.primitive?
       initial = args.cadr.evaluate(env)
       collection = args.caddr.evaluate(env)
-      raise "reduce requires a list or vector as it's third argument but received #{args.caddr}." unless collection.list? || collection.vector?
+      return Lisp::Debug.process_error("reduce requires a list or vector as it's third argument but received #{args.caddr}.", env) unless collection.list? || collection.vector?
       return initial if collection.empty?
       return collection.nth(1) if collection.length == 1
       result = collection.to_a.inject do |acc, item|
@@ -446,11 +445,11 @@ module Lisp
 
 
     def self.any_impl(args, env)
-      raise "any requires at least two arguments" unless args.length >= 2
+      return Lisp::Debug.process_error("any requires at least two arguments", env) unless args.length >= 2
       p = args.car.evaluate(env)
-      raise "any requires a function as it's first argument" unless p.function? || p.primitive?
+      return Lisp::Debug.process_error("any requires a function as it's first argument", env) unless p.function? || p.primitive?
       lists = args.cdr.to_a.collect {|a| a.evaluate(env)}
-      raise "any requires all subsequent arguments to be lists or vectors" unless lists.all? {|l| l.list? || l.vector?}
+      return Lisp::Debug.process_error("any requires all subsequent arguments to be lists or vectors", env) unless lists.all? {|l| l.list? || l.vector?}
 
       while true
         cars = lists.collect {|l| l.nth(1)}
@@ -463,11 +462,11 @@ module Lisp
 
 
     def self.every_impl(args, env)
-      raise "all requires at least two arguments" unless args.length >= 2
+      return Lisp::Debug.process_error("all requires at least two arguments", env) unless args.length >= 2
       p = args.car.evaluate(env)
-      raise "all requires a function as it's first argument" unless p.function? || p.primitive?
+      return Lisp::Debug.process_error("all requires a function as it's first argument", env) unless p.function? || p.primitive?
       lists = args.cdr.to_a.collect {|a| a.evaluate(env)}
-      raise "all requires all subsequent arguments to be lists or vectors" unless lists.all? {|l| l.list? || l.vector?}
+      return Lisp::Debug.process_error("all requires all subsequent arguments to be lists or vectors", env) unless lists.all? {|l| l.list? || l.vector?}
 
       while true
         cars = lists.collect {|l| l.nth(1)}
@@ -480,17 +479,17 @@ module Lisp
 
 
     def self.reverse_impl(args, env)
-      raise "reverse requires a single argument." unless args.length == 1
+      return Lisp::Debug.process_error("reverse requires a single argument.", env) unless args.length == 1
       l = args.car.evaluate(env)
-      raise "reverse requires a list or vector" unless l.list? || l.vector?
+      return Lisp::Debug.process_error("reverse requires a list or vector", env) unless l.list? || l.vector?
       make_same_kind_as(l, l.to_a.reverse)
     end
 
 
     def self.append_impl(args, env)
-      raise "append requires at least 1 argument." unless args.length >= 1
+      return Lisp::Debug.process_error("append requires at least 1 argument.", env) unless args.length >= 1
       l = args.map {|i| i.evaluate(env)}
-      raise "append requires lists or vectors" unless l.all? {|i| i.list? || i.vector?}
+      return Lisp::Debug.process_error("append requires lists or vectors", env) unless l.all? {|i| i.list? || i.vector?}
       all_vectors = l.all? {|i| i.vector?}
       new_items = []
       l.each do |sublist|
@@ -506,9 +505,9 @@ module Lisp
 
 
     def self.appendbang_impl(args, env)
-      raise "append! requires at least 1 argument." unless args.length >= 1
+      return Lisp::Debug.process_error("append! requires at least 1 argument.", env) unless args.length >= 1
       arg_array = args.to_a.map {|i| i.evaluate(env)}
-      raise "append! requires lists" unless arg_array.all? {|i| i.list?}
+      return Lisp::Debug.process_error("append! requires lists", env) unless arg_array.all? {|i| i.list?}
       (0...(arg_array.length-1)). each do |i|
         arg_array[i].last.set_cdr!(arg_array[i+1])
       end
@@ -517,9 +516,9 @@ module Lisp
 
 
     def self.flatten_impl(args, env)
-      raise "flatten requires 1 argument." unless args.length != 1
+      return Lisp::Debug.process_error("flatten requires 1 argument.", env) unless args.length != 1
       l = args.car.evaluate(env)
-      raise "flatten requires a list argument" unless l.list?
+      return Lisp::Debug.process_error("flatten requires a list argument", env) unless l.list?
       l.flatten
     end
 

data/lib/rubylisp/logical.rb

@@ -18,19 +18,19 @@ module Lisp
 
 
     def self.or_impl(args, env)
-      raise "or needs at least 2 arguments" unless args.length > 1
+      return Lisp::Debug.process_error("or needs at least 2 arguments", env) unless args.length > 1
       value = !!args.inject(false) {|acc, item| acc || item.evaluate(env).value}
       return Lisp::Boolean.with_value(value)
     end
 
     def self.and_impl(args, env)
-      raise "and needs at least 2 arguments" unless args.length > 1
+      return Lisp::Debug.process_error("and needs at least 2 arguments", env) unless args.length > 1
       value = !!args.inject(true) {|acc, item| acc && item.evaluate(env).value}
       return Lisp::Boolean.with_value(value)
     end
 
     def self.not_impl(args, env)
-      raise "not needs a single argument" unless args.length == 1
+      return Lisp::Debug.process_error("not needs a single argument", env) unless args.length == 1
       return Lisp::Boolean.with_value(!(args.car.evaluate(env).value))
     end
 

data/lib/rubylisp/macro.rb

@@ -33,9 +33,11 @@ module Lisp
 
     def expand(parameters, env, should_eval)
       if @var_args
-        raise "#{@name} expected at least #{@required_argument_count} parameters, received #{parameters.length}." if parameters.length < @required_argument_count
+        return Lisp::Debug.process_error("#{@name} expected at least
+                                ##{@required_argument_count} parameters, received #{parameters.length}.", env) if parameters.length < @required_argument_count
       else
-        raise "#{@name} expected #{@required_argument_count} parameters, received #{parameters.length}." unless parameters.length == @required_argument_count        
+        return Lisp::Debug.process_error("#{@name} expected
+                                ##{@required_argument_count} parameters, received #{parameters.length}.", env) unless parameters.length == @required_argument_count        
       end
       
       local_env = EnvironmentFrame.extending(@env, env.frame)