rubymotionlisp 0.1.4 → 0.2.0

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)

data/lib/rubylisp/math.rb

@@ -120,13 +120,13 @@ largest integer less than or equal to `number` is returned.") do |args, env|
     end
 
     def self.add_impl(args, env)
-      raise "add needs at least 1 argument" if args.empty?
+      return Lisp::Debug.process_error("add needs at least 1 argument", env) if args.empty?
 
       acc = 0
       c = args
       while !c.nil?
         n = c.car.evaluate(env)
-        raise "add needs number arguments but was given a #{n.type}: #{n}" unless n.type == :number
+        return Lisp::Debug.process_error("add needs number arguments but was given a #{n.type}: #{n}", env) unless n.type == :number
         acc += n.value
         c = c.cdr
       end
@@ -136,17 +136,17 @@ largest integer less than or equal to `number` is returned.") do |args, env|
 
 
     def self.subtract_impl(args, env)
-      raise "subtract needs at least 1 argument" if args.empty?
+      return Lisp::Debug.process_error("subtract needs at least 1 argument", env) if args.empty?
 
       return Number.with_value(-1 * args.car.evaluate(env).value) if args.length == 1
 
       first = args.car.evaluate(env)
-      raise "subtract needs number arguments, but received #{first}"  unless first.type == :number
+      return Lisp::Debug.process_error("subtract needs number arguments, but received #{first}", env)  unless first.type == :number
       acc = first.value
       c = args.cdr
       while !c.nil?
         n = c.car.evaluate(env)
-        raise "subtract needs number arguments, but received #{n}" unless n.type == :number
+        return Lisp::Debug.process_error("subtract needs number arguments, but received #{n}", env) unless n.type == :number
         acc -= n.value
         c = c.cdr
       end
@@ -156,13 +156,13 @@ largest integer less than or equal to `number` is returned.") do |args, env|
 
 
     def self.multiply_impl(args, env)
-      raise "multiply needs at least 1 argument" if args.empty?
+      return Lisp::Debug.process_error("multiply needs at least 1 argument", env) if args.empty?
 
       acc = 1
       c = args
       while !c.nil?
         n = c.car.evaluate(env)
-        raise "multiply needs number arguments, but received #{n}" unless n.type == :number
+        return Lisp::Debug.process_error("multiply needs number arguments, but received #{n}", env) unless n.type == :number
         acc *= n.value
         c = c.cdr
       end
@@ -172,16 +172,17 @@ largest integer less than or equal to `number` is returned.") do |args, env|
 
 
     def self.quotient_impl(args, env)
-      raise "quotient needs at least 1 argument" if args.empty?
+      return Lisp::Debug.process_error("quotient needs at least 1 argument", env) if args.empty?
 
       first = args.car.evaluate(env)
-      raise "quotient needs number arguments, but received #{first}" unless first.type == :number
+      return Lisp::Debug.process_error("quotient needs number arguments, but received #{first}", env) unless first.type == :number
       return first if args.length == 1
       acc = first.value
       c = args.cdr
       while !c.nil?
         n = c.car.evaluate(env)
-        raise "quotient needs number arguments, but received #{n}" unless n.type == :number
+        return Lisp::Debug.process_error("quotient needs number arguments, but received #{n}", env) unless n.type == :number
+        return Lisp::Debug.process_error("divide by zero", env) if n.value == 0
         acc /= n.value
         c = c.cdr
       end
@@ -191,16 +192,17 @@ largest integer less than or equal to `number` is returned.") do |args, env|
 
 
     def self.remainder_impl(args, env)
-      raise "remainder needs at least 1 argument" if args.empty?
+      return Lisp::Debug.process_error("remainder needs at least 1 argument", env) if args.empty?
 
       first = args.car.evaluate(env)
-      raise "remainder needs number arguments, but received #{first}" unless first.type == :number
+      return Lisp::Debug.process_error("remainder needs number arguments, but received #{first}", env) unless first.type == :number
       return first if args.length == 1
       acc = first.value
       c = args.cdr
       while !c.nil?
         n = c.car.evaluate(env)
-        raise "remainder needs number arguments, but received #{n}" unless n.type == :number
+        return Lisp::Debug.process_error("remainder needs number arguments, but received #{n}", env) unless n.type == :number
+        return Lisp::Debug.process_error("divide by zero", env) if n.value == 0
         acc %= n.value
         c = c.cdr
       end
@@ -209,17 +211,17 @@ largest integer less than or equal to `number` is returned.") do |args, env|
     end
 
     def self.truncate_impl(args, env)
-      raise "truncate needs 1 argument, but received #{args.length}" if args.length != 1
+      return Lisp::Debug.process_error("truncate needs 1 argument, but received #{args.length}", env) if args.length != 1
       arg = args.car.evaluate(env)
-      raise "truncate needs a number argument, but received #{arg}" unless arg.type == :number
+      return Lisp::Debug.process_error("truncate needs a number argument, but received #{arg}", env) unless arg.type == :number
       Number.with_value(arg.value.truncate)
     end
 
 
     def self.round_impl(args, env)
-      raise "round needs 1 argument, but received #{args.length}" if args.length != 1
+      return Lisp::Debug.process_error("round needs 1 argument, but received #{args.length}", env) if args.length != 1
       arg = args.car.evaluate(env)
-      raise "round needs a number argument, but received #{arg}" unless arg.type == :number
+      return Lisp::Debug.process_error("round needs a number argument, but received #{arg}", env) unless arg.type == :number
       num = arg.value
       int = num.to_i
       Number.with_value(if (num - int).abs == 0.5
@@ -235,121 +237,121 @@ largest integer less than or equal to `number` is returned.") do |args, env|
 
 
     def self.ceiling_impl(args, env)
-      raise "ceiling needs 1 argument, but received #{args.length}" if args.length != 1
+      return Lisp::Debug.process_error("ceiling needs 1 argument, but received #{args.length}", env) if args.length != 1
       arg = args.car.evaluate(env)
-      raise "ceiling needs a number argument, but received #{arg}" unless arg.type == :number
+      return Lisp::Debug.process_error("ceiling needs a number argument, but received #{arg}", env) unless arg.type == :number
       Number.with_value(arg.value.ceil)
     end
 
 
     def self.floor_impl(args, env)
-      raise "floor needs 1 argument, but received #{args.length}" if args.length != 1
+      return Lisp::Debug.process_error("floor needs 1 argument, but received #{args.length}", env) if args.length != 1
       arg = args.car.evaluate(env)
-      raise "floor needs a number argument, but received #{arg}" unless arg.type == :number
+      return Lisp::Debug.process_error("floor needs a number argument, but received #{arg}", env) unless arg.type == :number
       Number.with_value(arg.value.floor)
     end
 
 
     def self.even_impl(args, env)
-      raise "even? needs 1 argument, but received #{args.length}" if args.length != 1
+      return Lisp::Debug.process_error("even? needs 1 argument, but received #{args.length}", env) if args.length != 1
       arg = args.car.evaluate(env)
-      raise "even? needs a number argument, but received #{arg}" unless arg.type == :number
+      return Lisp::Debug.process_error("even? needs a number argument, but received #{arg}", env) unless arg.type == :number
       Boolean.with_value(arg.value.even?)
     end
 
 
     def self.odd_impl(args, env)
-      raise "odd? needs 1 argument, but received #{args.length}" if args.length != 1
+      return Lisp::Debug.process_error("odd? needs 1 argument, but received #{args.length}", env) if args.length != 1
       arg = args.car.evaluate(env)
-      raise "odd? needs a number argument, but received #{arg}" unless arg.type == :number
+      return Lisp::Debug.process_error("odd? needs a number argument, but received #{arg}", env) unless arg.type == :number
       Boolean.with_value(arg.value.odd?)
     end
 
 
     def self.zero_impl(args, env)
-      raise "zero? needs 1 argument, but received #{args.length}" if args.length != 1
+      return Lisp::Debug.process_error("zero? needs 1 argument, but received #{args.length}", env) if args.length != 1
       arg = args.car.evaluate(env)
-      raise "zero? needs a number argument, but received #{arg}" unless arg.type == :number
+      return Lisp::Debug.process_error("zero? needs a number argument, but received #{arg}", env) unless arg.type == :number
       Boolean.with_value(arg.value.zero?)
     end
 
 
     def self.positive_impl(args, env)
-      raise "positive? needs 1 argument, but received #{args.length}" if args.length != 1
+      return Lisp::Debug.process_error("positive? needs 1 argument, but received #{args.length}", env) if args.length != 1
       arg = args.car.evaluate(env)
-      raise "positive? needs a number argument, but received #{arg}" unless arg.type == :number
+      return Lisp::Debug.process_error("positive? needs a number argument, but received #{arg}", env) unless arg.type == :number
       Boolean.with_value(arg.value > 0)
     end
 
 
     def self.negative_impl(args, env)
-      raise "negative? needs 1 argument, but received #{args.length}" if args.length != 1
+      return Lisp::Debug.process_error("negative? needs 1 argument, but received #{args.length}", env) if args.length != 1
       arg = args.car.evaluate(env)
-      raise "negative? needs a number argument, but received #{arg}" unless arg.type == :number
+      return Lisp::Debug.process_error("negative? needs a number argument, but received #{arg}", env) unless arg.type == :number
       Boolean.with_value(arg.value < 0)
     end
 
 
     def self.interval_impl(args, env)
-      raise "interval needs 2 arguments, but received #{args.length}" if args.length != 2
+      return Lisp::Debug.process_error("interval needs 2 arguments, but received #{args.length}", env) if args.length != 2
       initial = args.car.evaluate(env)
-      raise "interval needs number arguments, but received #{initial}" unless initial.type == :number
+      return Lisp::Debug.process_error("interval needs number arguments, but received #{initial}", env) unless initial.type == :number
       final = args.cadr.evaluate(env)
-      raise "interval needs number arguments, but received #{final}" unless final.type == :number
-      raise "interval's arguments need to be in natural order" unless initial.value <= final.value
+      return Lisp::Debug.process_error("interval needs number arguments, but received #{final}", env) unless final.type == :number
+      return Lisp::Debug.process_error("interval's arguments need to be in natural order", env) unless initial.value <= final.value
       Lisp::ConsCell.array_to_list((initial.value..final.value).to_a.map {|n| Number.with_value(n)})
     end
 
 
     def self.random_impl(args, env)
       arg = args.car.evaluate(env)
-      raise "random needs a number argument, but received #{arg}" unless arg.nil? || arg.type == :number
+      return Lisp::Debug.process_error("random needs a number argument, but received #{arg}", env) unless arg.nil? || arg.type == :number
       Number.with_value(arg.nil? ? rand() : rand(arg.value))
     end
 
 
     def self.float_impl(args, env)
-      raise "float needs 1 argument, but received #{args.length}" if args.length != 1
+      return Lisp::Debug.process_error("float needs 1 argument, but received #{args.length}", env) if args.length != 1
       arg = args.car.evaluate(env)
-      raise "float needs a numeric or string argument, but received #{arg}" unless arg.number? || arg.string?
+      return Lisp::Debug.process_error("float needs a numeric or string argument, but received #{arg}", env) unless arg.number? || arg.string?
       Number.with_value(arg.value.to_f)
     end
 
 
     def self.integer_impl(args, env)
-      raise "integer needs 1 argument, but received #{args.length}" if args.length != 1
+      return Lisp::Debug.process_error("integer needs 1 argument, but received #{args.length}", env) if args.length != 1
       arg = args.car.evaluate(env)
-      raise "integer needs a numeric or string argument, but received #{arg}" unless arg.number? || arg.string?
+      return Lisp::Debug.process_error("integer needs a numeric or string argument, but received #{arg}", env) unless arg.number? || arg.string?
       Number.with_value(arg.value.to_i)
     end
 
 
     def self.abs_impl(args, env)
-      raise "abs needs 1 argument, but received #{args.length}" if args.length != 1
+      return Lisp::Debug.process_error("abs needs 1 argument, but received #{args.length}", env) if args.length != 1
       arg = args.car.evaluate(env)
-      raise "abs needs a numeric argument, but received #{arg}" unless arg.number?
+      return Lisp::Debug.process_error("abs needs a numeric argument, but received #{arg}", env) unless arg.number?
       Number.with_value(arg.value.abs)
     end
 
 
     def self.sqrt_impl(args, env)
-      raise "sqrt needs 1 argument, but received #{args.length}" if args.length != 1
+      return Lisp::Debug.process_error("sqrt needs 1 argument, but received #{args.length}", env) if args.length != 1
       arg = args.car.evaluate(env)
-      raise "sqrt needs a numeric argument, but received #{arg}" unless arg.number?
+      return Lisp::Debug.process_error("sqrt needs a numeric argument, but received #{arg}", env) unless arg.number?
       Number.with_value(::Math.sqrt(arg.value).round(5))
     end
 
 
     def self.min_impl(args, env)
-      raise "min needs at least 1 argument" if args.length == 0
+      return Lisp::Debug.process_error("min needs at least 1 argument", env) if args.length == 0
 
       initial = args.car.evaluate(env)
-      raise "min requires numeric arguments, but received #{initial}" unless initial.type ==:number
+      return Lisp::Debug.process_error("min requires numeric arguments, but received #{initial}", env) unless initial.type ==:number
       acc = initial.value
       c = args.cdr
       while !c.nil?
         n = c.car.evaluate(env)
-        raise "min needs number arguments, but received #{n}" unless n.type == :number
+        return Lisp::Debug.process_error("min needs number arguments, but received #{n}", env) unless n.type == :number
         acc = n.value if n.value < acc
         c = c.cdr
       end
@@ -359,14 +361,14 @@ largest integer less than or equal to `number` is returned.") do |args, env|
 
 
     def self.max_impl(args, env)
-      raise "max needs at least 1 argumenta" if args.length == 0
+      return Lisp::Debug.process_error("max needs at least 1 argumenta", env) if args.length == 0
       initial = args.car.evaluate(env)
-      raise "max requires numeric arguments, but received #{initial}" unless initial.type ==:number
+      return Lisp::Debug.process_error("max requires numeric arguments, but received #{initial}", env) unless initial.type ==:number
       acc = initial.value
       c = args.cdr
       while !c.nil?
         n = c.car.evaluate(env)
-        raise "max needs number arguments, but received #{n}" unless n.type == :number
+        return Lisp::Debug.process_error("max needs number arguments, but received #{n}", env) unless n.type == :number
         acc = n.value if n.value > acc
         c = c.cdr
       end
@@ -376,25 +378,25 @@ largest integer less than or equal to `number` is returned.") do |args, env|
 
 
     def self.sin_impl(args, env)
-      raise "sin needs 1 argument, but received #{args.length}" if args.length != 1
+      return Lisp::Debug.process_error("sin needs 1 argument, but received #{args.length}", env) if args.length != 1
       arg = args.car.evaluate(env)
-      raise "sin needs a numeric argument, but received #{arg}" unless arg.number?
+      return Lisp::Debug.process_error("sin needs a numeric argument, but received #{arg}", env) unless arg.number?
       Number.with_value(::Math.sin(arg.value).round(5))
     end
 
 
     def self.cos_impl(args, env)
-      raise "cos needs 1 argument, but received #{args.length}" if args.length != 1
+      return Lisp::Debug.process_error("cos needs 1 argument, but received #{args.length}", env) if args.length != 1
       arg = args.car.evaluate(env)
-      raise "cos needs a numeric argument, but received #{arg}" unless arg.number?
+      return Lisp::Debug.process_error("cos needs a numeric argument, but received #{arg}", env) unless arg.number?
       Number.with_value(::Math.cos(arg.value).round(5))
     end
 
 
     def self.tan_impl(args, env)
-      raise "tan needs 1 argument, but received #{args.length}" if args.length != 1
+      return Lisp::Debug.process_error("tan needs 1 argument, but received #{args.length}", env) if args.length != 1
       arg = args.car.evaluate(env)
-      raise "tan needs a numeric argument, but received #{arg}" unless arg.number?
+      return Lisp::Debug.process_error("tan needs a numeric argument, but received #{arg}", env) unless arg.number?
       Number.with_value(::Math.tan(arg.value).round(5))
     end
 

data/lib/rubylisp/object.rb

@@ -7,7 +7,7 @@ module Lisp
     end
 
     def self.wrap_impl(args, env)
-      raise "wrap-object requires 1 argument" unless args.length == 1
+      return Lisp::Debug.process_error("wrap-object requires 1 argument", env) unless args.length == 1
       raw_val = args.car.evaluate(env)
       val = if raw_val.list?
               raw_val.to_a

data/lib/rubylisp/parser.rb

@@ -45,12 +45,12 @@ module Lisp
           cdr = self.parse_sexpr(tokens)
           return nil if tokens.next_token[0] == :EOF
           tok, lit = tokens.next_token
-          raise "Expected ')'  on line #{tokens.line_number}" if tok != :RPAREN
+          return Lisp::Debug.process_error("Expected ')' to follow a dotted tail on line #{tokens.line_number}", env) if tok != :RPAREN
           tokens.consume_token
           return Lisp::ConsCell.array_to_list(cells, cdr)
         else
           car = self.parse_sexpr(tokens)
-          raise "Unexpected EOF (expected closing parenthesis) on line #{tokens.line_number}" if tokens.next_token[0] == :EOF
+          return Lisp::Debug.process_error("Unexpected EOF (expected ')') on line #{tokens.line_number}", env) if tokens.next_token[0] == :EOF
           cells << car
         end
         tok, lit = tokens.next_token
@@ -71,7 +71,7 @@ module Lisp
       cells = []
       while tok != :RBRACE
         item = self.parse_sexpr(tokens)
-        raise "Unexpected EOF (expected closing brace) on line #{tokens.line_number}" if tokens.next_token[0] == :EOF
+        return Lisp::Debug.process_error("Unexpected EOF (expected '}') on line #{tokens.line_number}", env) if tokens.next_token[0] == :EOF
         cells << item
         tok, lit = tokens.next_token
       end
@@ -92,7 +92,7 @@ module Lisp
       cells = []
       while tok != :RBRACKET
         item = self.parse_sexpr(tokens)
-        raise "Unexpected EOF (expected closing bracket) on line #{tokens.line_number}" if tokens.next_token[0] == :EOF
+        return Lisp::Debug.process_error("Unexpected EOF (expected ']') on line #{tokens.line_number}", env) if tokens.next_token[0] == :EOF
         cells << item
         tok, lit = tokens.next_token
       end
@@ -152,7 +152,7 @@ module Lisp
           expr = parse_sexpr(tokens)
           return ConsCell.array_to_list([Symbol.named('unquote-splicing'), expr])
         when :ILLEGAL
-          raise "Illegal token: #{lit} on line #{tokens.line_number}"
+          return Lisp::Debug.process_error("Illegal token: #{lit} on line #{tokens.line_number}", Lisp::EnvironmentFrame.global)
         else
           return make_symbol(lit)
         end

data/lib/rubylisp/primitive.rb

@@ -2,7 +2,7 @@ module Lisp
 
   class Primitive < Atom
     
-    attr_reader :doc
+    attr_reader :doc, :name
     
     def self.register(name, doc="", special=false, env=Lisp::EnvironmentFrame.global, &implementation)
       instance = self.new(name, doc, special, &implementation)

data/lib/rubylisp/relational.rb

@@ -22,22 +22,22 @@ module Lisp
 
 
     def self.lt_impl(args, env)
-      raise "< needs at least 2 arguments" unless args.length > 1
+      return Lisp::Debug.process_error("< needs at least 2 arguments", env) unless args.length > 1
       return Lisp::Boolean.with_value(args.car.evaluate(env).value < args.cadr.evaluate(env).value)
     end
 
     def self.gt_impl(args, env)
-      raise "> needs at least 2 arguments" unless args.length > 1
+      return Lisp::Debug.process_error("> needs at least 2 arguments", env) unless args.length > 1
       return Lisp::Boolean.with_value(args.car.evaluate(env).value > args.cadr.evaluate(env).value)
     end
 
     def self.lteq_impl(args, env)
-      raise "<= needs at least 2 arguments" unless args.length > 1
+      return Lisp::Debug.process_error("<= needs at least 2 arguments", env) unless args.length > 1
       return Lisp::Boolean.with_value(args.car.evaluate(env).value <= args.cadr.evaluate(env).value)
     end
 
     def self.gteq_impl(args, env)
-      raise ">= needs at least 2 arguments" unless args.length > 1
+      return Lisp::Debug.process_error(">= needs at least 2 arguments", env) unless args.length > 1
       return Lisp::Boolean.with_value(args.car.evaluate(env).value >= args.cadr.evaluate(env).value)
     end
 

data/lib/rubylisp/special_forms.rb

@@ -161,7 +161,7 @@ useful in macros when you need a unique name for something.") do |args, env|
             return result
           end
         else
-          raise "Case requires non-atomic clauses"
+          return Lisp::Debug.process_error("Case requires non-atomic clauses", env)
         end
       end
       return nil
@@ -169,7 +169,7 @@ useful in macros when you need a unique name for something.") do |args, env|
 
 
     def self.if_impl(args, env)
-      raise "IF requires a condition, true action, and possibly an else action" unless args.length == 2 || args.length == 3
+      return Lisp::Debug.process_error("IF requires a condition, true action, and possibly an else action", env) unless args.length == 2 || args.length == 3
       condition = args.car.evaluate(env)
       if condition.true?
         args.cadr.evaluate(env)
@@ -182,7 +182,7 @@ useful in macros when you need a unique name for something.") do |args, env|
 
 
     def self.when_impl(args, env)
-      raise "WHEN requires a condition and sexprs to evaluate." unless args.length >= 2
+      return Lisp::Debug.process_error("WHEN requires a condition and sexprs to evaluate.", env) unless args.length >= 2
       condition = args.car.evaluate(env)
       return args.cdr.evaluate_each(env) if condition.true?
       nil
@@ -190,7 +190,7 @@ useful in macros when you need a unique name for something.") do |args, env|
 
 
     def self.unless_impl(args, env)
-      raise "UNLESS requires a condition and sexprs to evaluate." unless args.length >= 2
+      return Lisp::Debug.process_error("UNLESS requires a condition and sexprs to evaluate.", env) unless args.length >= 2
       condition = args.car.evaluate(env)
       return args.cdr.evaluate_each(env) unless condition.true?
       nil
@@ -205,7 +205,7 @@ useful in macros when you need a unique name for something.") do |args, env|
 
 
     def self.define_variable(definition, value, env)
-      raise "Variable names must be literal symbols." unless definition.symbol?
+      return Lisp::Debug.process_error("Variable names must be literal symbols.", env) unless definition.symbol?
 
       ev = value.evaluate(env)
       Lisp::EnvironmentFrame.global.bind(definition, ev)
@@ -215,7 +215,7 @@ useful in macros when you need a unique name for something.") do |args, env|
     
     def self.define_function(definition, body, env)
       name = definition.car
-      raise "Function name must be a symbol" unless name.symbol?
+      return Lisp::Debug.process_error("Function name must be a symbol", env) unless name.symbol?
       arguments = definition.cdr
       doc = nil
       if body.car.string?
@@ -230,7 +230,7 @@ useful in macros when you need a unique name for something.") do |args, env|
 
     def self.defun_impl(args, env)
       definition = args.car
-      raise("Function definition must specify name and parameters in a list") unless definition.list?
+      return Lisp::Debug.process_error("Function definition must specify name and parameters in a list", env) unless definition.list?
       define_function(definition, args.cdr, env)
     end
     
@@ -240,16 +240,16 @@ useful in macros when you need a unique name for something.") do |args, env|
       if definition.list?
         define_function(definition, args.cdr, env)
       else
-        raise "A symbol can be bound to only a single value." unless args.cdr.length == 1
+        return Lisp::Debug.process_error("A symbol can be bound to only a single value.", env) unless args.cdr.length == 1
         define_variable(definition, args.cadr, env)
       end
     end
 
 
     def self.defmacro_impl(args, env)
-      raise "defmacro requires 2 or 3 arguments: a name and argument list, and a template expression." unless args.length == 2 || args.length == 3
+      return Lisp::Debug.process_error("defmacro requires 2 or 3 arguments: a name and argument list, and a template expression.", env) unless args.length == 2 || args.length == 3
       definition = args.car
-      raise "defmacro requires macro name and args in a list as it's first argument." if definition.nil? || !definition.list?
+      return Lisp::Debug.process_error("defmacro requires macro name and args in a list as it's first argument.", env) if definition.nil? || !definition.list?
       name = definition.car
       arguments = definition.cdr
       doc = nil
@@ -270,11 +270,11 @@ useful in macros when you need a unique name for something.") do |args, env|
 
 
     def self.gensym_impl(args, env)
-      raise "gensym requires 0 or 1 argument" if args.length > 1
+      return Lisp::Debug.process_error("gensym requires 0 or 1 argument", env) if args.length > 1
       prefix = if args.length == 0
                  "GENSYM"
                else
-                 raise "gensym's argument must be a string" unless args.car.string?
+                 return Lisp::Debug.process_error("gensym's argument must be a string", env) unless args.car.string?
                  args.car.to_s
                end
       sym = Lisp::Symbol.named("#{prefix}-#{@@SYMBOL_COUNT}")
@@ -285,7 +285,7 @@ useful in macros when you need a unique name for something.") do |args, env|
     
     def self.expand_impl(args, env)
       macro = args.car.evaluate(env)
-      raise "The first argument to expand must be a macro" unless macro.macro?
+      return Lisp::Debug.process_error("The first argument to expand must be a macro", env) unless macro.macro?
       macro.expand(args.cdr, env, true)
     end
     
@@ -321,9 +321,9 @@ useful in macros when you need a unique name for something.") do |args, env|
 
     def self.do_let_bindings(bindings, binding_env, local_env)
       bindings.each do |binding_pair|
-        raise "let requires a list of bindings (that are 2 element lists) as it's first argument" unless binding_pair.list?
+        return Lisp::Debug.process_error("let requires a list of bindings (that are 2 element lists) as it's first argument", env) unless binding_pair.list?
         name = binding_pair.car
-        raise "the first part of a let binding pair must be a symbol" unless name.symbol?
+        return Lisp::Debug.process_error("the first part of a let binding pair must be a symbol", env) unless name.symbol?
         value = binding_pair.cadr.evaluate(binding_env)
         local_env.bind_locally(name, value)
       end
@@ -332,8 +332,9 @@ useful in macros when you need a unique name for something.") do |args, env|
 
     def self.let_impl(args, env)
       bindings = args.car || Lisp::ConsCell.new
-      raise "let requires a list of bindings as it's firest argument" unless bindings.list?
+      return Lisp::Debug.process_error("let requires a list of bindings as it's firest argument", env) unless bindings.list?
       local_frame = EnvironmentFrame.extending(env)
+      local_frame.previous = env
       do_let_bindings(bindings, env, local_frame)
       args.cdr.evaluate_each(local_frame)
     end
@@ -341,7 +342,7 @@ useful in macros when you need a unique name for something.") do |args, env|
 
     def self.letstar_impl(args, env)
       bindings = args.car || Lisp::ConsCell.new
-      raise "let requires a list of bindings as it's firest argument" unless bindings.list?
+      return Lisp::Debug.process_error("let requires a list of bindings as it's firest argument", env) unless bindings.list?
       local_frame = EnvironmentFrame.extending(env)
       do_let_bindings(bindings, local_frame, local_frame)
       args.cdr.evaluate_each(local_frame)
@@ -354,19 +355,20 @@ useful in macros when you need a unique name for something.") do |args, env|
 
 
     def self.do_impl(args, env)
-      raise "Do requires at least a list of bindings and a test clause" if args.length < 2
+      return Lisp::Debug.process_error("Do requires at least a list of bindings and a test clause", env) if args.length < 2
       bindings = args.car
-      raise "Do requires a list of bindings as it's first argument" unless bindings.list?
+      return Lisp::Debug.process_error("Do requires a list of bindings as it's first argument", env) unless bindings.list?
       test_clause = args.cadr
-      raise "Do requires a list of termination condition and result expressions as it's second argument" unless test_clause.list?
+      return Lisp::Debug.process_error("Do requires a list of termination condition and result expressions as it's second argument", env) unless test_clause.list?
       body = args.cddr
 
       local_frame = EnvironmentFrame.extending(env)
+      local_frame.previous = env
 
       bindings.each do |binding|
-        raise "do bindings must be (name initial next)" unless binding.list?
+        return Lisp::Debug.process_error("do bindings must be (name initial next)", env) unless binding.list?
         name = binding.car
-        raise "binding name must be a symbol" unless name.symbol?
+        return Lisp::Debug.process_error("binding name must be a symbol", env) unless name.symbol?
         value = binding.cadr.evaluate(local_frame)
         local_frame.bind_locally(name, value)
       end
@@ -391,16 +393,16 @@ useful in macros when you need a unique name for something.") do |args, env|
 
 
     def self.eval_impl(args, env)
-      raise "eval expects a single argument, received #{args.length}." if args.length != 1
+      return Lisp::Debug.process_error("eval expects a single argument, received #{args.length}.", env) if args.length != 1
       arg = args.car.evaluate(env)
-      raise "eval expect a list argument, received a #{arg.type}." unless arg.list?
+      return Lisp::Debug.process_error("eval expect a list argument, received a #{arg.type}.", env) unless arg.list?
       arg.evaluate(env)
     end
 
 
     def self.apply_impl(args, env)
       func = args.car.evaluate(env)
-      raise "Expected #{args.car} to evaluate to a function." unless func.primitive? || func.function?
+      return Lisp::Debug.process_error("Expected #{args.car} to evaluate to a function.", env) unless func.primitive? || func.function?
 
       a = args.cdr.to_a.collect {|sexpr| sexpr.evaluate(env)}
       arg_list = if a[-1].list?
@@ -413,7 +415,7 @@ useful in macros when you need a unique name for something.") do |args, env|
 
 
     def self.chain_impl(args, env)
-      raise "-> requires at the very least an initial value." unless args.length > 0
+      return Lisp::Debug.process_error("-> requires at the very least an initial value.", env) unless args.length > 0
       value = args.car.evaluate(env)
       cell = args.cdr
       while !cell.nil?
@@ -432,7 +434,7 @@ useful in macros when you need a unique name for something.") do |args, env|
 
 
     def self.tap_impl(args, env)
-      raise "tap requires at the very least an initial value." unless args.length > 0
+      return Lisp::Debug.process_error("tap requires at the very least an initial value.", env) unless args.length > 0
       value = args.car.evaluate(env)
       cell = args.cdr
       while !cell.nil?