rubymotionlisp 0.1.4 → 0.2.0

data/lib/rubylisp/string.rb

@@ -83,20 +83,20 @@ end
     
 
     def self.stringp_impl(args, env)
-      raise "string? requires 1 argument" unless args.length == 1
+      return Lisp::Debug.process_error("string? requires 1 argument", env) unless args.length == 1
       return Lisp::Boolean.with_value(args.car.evaluate(env).string?)
     end
 
 
     def self.make_string_impl(args, env)
-      raise "make-string need requires at least 1 argument" unless args.length > 0
-      raise "make-string accepts at most 2 arguments, but was passed #{args.length}" if args.length > 2
+      return Lisp::Debug.process_error("make-string need requires at least 1 argument", env) unless args.length > 0
+      return Lisp::Debug.process_error("make-string accepts at most 2 arguments, but was passed #{args.length}", env) if args.length > 2
       k_arg = args.car.evaluate(env)
-      raise "make-string requires an integer as it's first argument." unless k_arg.integer?
+      return Lisp::Debug.process_error("make-string requires an integer as it's first argument.", env) unless k_arg.integer?
       k = k_arg.value
       c = if args.length == 2
             c_arg = args.cadr.evaluate(env)
-            raise "make-string requires a character as it's second argument, but received #{c_arg}." unless c_arg.character?
+            return Lisp::Debug.process_error("make-string requires a character as it's second argument, but received #{c_arg}.", env) unless c_arg.character?
             c_arg.value
           else
             " "
@@ -108,7 +108,7 @@ end
     def self.string_impl(args, env)
       chars = args.to_a.map do |a|
         ea = a.evaluate(env)
-        raise "string requires character args, but was passed #{ea}." unless ea.character?
+        return Lisp::Debug.process_error("string requires character args, but was passed #{ea}.", env) unless ea.character?
         ea.value
       end
       self.with_value(chars.join)
@@ -116,12 +116,12 @@ end
 
 
     def self.list_string_impl(args, env)
-      raise "list->string requires 1 argument, but received #{args.length}" unless args.length == 1      
+      return Lisp::Debug.process_error("list->string requires 1 argument, but received #{args.length}", env) unless args.length == 1      
       list_of_chars = args.car.evaluate(env)
-      raise "list->string requires a list argument, but received #{str_arg}" unless list_of_chars.list?      
+      return Lisp::Debug.process_error("list->string requires a list argument, but received #{str_arg}", env) unless list_of_chars.list?      
       chars = list_of_chars.to_a.map do |a|
         ea = a.evaluate(env)
-        raise "string requires a list of characters, but it contained #{ea}." unless ea.character?
+        return Lisp::Debug.process_error("string requires a list of characters, but it contained #{ea}.", env) unless ea.character?
         ea.value
       end
       self.with_value(chars.join)
@@ -129,45 +129,45 @@ end
 
 
     def self.string_list_impl(args, env)
-      raise "string->list requires 1 argument, but received #{args.length}" unless args.length == 1      
+      return Lisp::Debug.process_error("string->list requires 1 argument, but received #{args.length}", env) unless args.length == 1      
       str_arg = args.car.evaluate(env)
-      raise "string->list requires a string argument, but received #{str_arg}" unless str_arg.string?
+      return Lisp::Debug.process_error("string->list requires a string argument, but received #{str_arg}", env) unless str_arg.string?
       chars = str_arg.value.each_char.map {|c| Lisp::Character.find_character_for_chr(c) }
       Lisp::ConsCell.array_to_list(chars)
     end
 
 
     def self.string_copy_impl(args, env)
-      raise "string-copy requires 1 argument, but received #{args.length}" unless args.length == 1      
+      return Lisp::Debug.process_error("string-copy requires 1 argument, but received #{args.length}", env) unless args.length == 1      
       str_arg = args.car.evaluate(env)
-      raise "string-copy requires a string argument, but received #{str_arg}" unless str_arg.string?
+      return Lisp::Debug.process_error("string-copy requires a string argument, but received #{str_arg}", env) unless str_arg.string?
       self.with_value(str_arg.value)
     end
 
 
     def self.string_length_impl(args, env)
-      raise "string-length requires 1 argument, but received #{args.length}" unless args.length == 1      
+      return Lisp::Debug.process_error("string-length requires 1 argument, but received #{args.length}", env) unless args.length == 1      
       str_arg = args.car.evaluate(env)
-      raise "string-length requires a string argument, but received #{str_arg}" unless str_arg.string?
+      return Lisp::Debug.process_error("string-length requires a string argument, but received #{str_arg}", env) unless str_arg.string?
       Lisp::Number.with_value(str_arg.value.length)
     end
 
 
     def self.string_nullp_impl(args, env)
-      raise "string-length requires 1 argument, but received #{args.length}" unless args.length == 1      
+      return Lisp::Debug.process_error("string-length requires 1 argument, but received #{args.length}", env) unless args.length == 1      
       str_arg = args.car.evaluate(env)
-      raise "string-length requires a string argument, but received #{str_arg}" unless str_arg.string?
+      return Lisp::Debug.process_error("string-length requires a string argument, but received #{str_arg}", env) unless str_arg.string?
       Lisp::Boolean.with_value(str_arg.value.length == 0)
     end
 
 
     def self.string_ref_impl(args, env)
-      raise "string-ref requires 2 arguments, but received #{args.length}" unless args.length == 2      
+      return Lisp::Debug.process_error("string-ref requires 2 arguments, but received #{args.length}", env) unless args.length == 2      
       str_arg = args.car.evaluate(env)
-      raise "string-ref requires a string as it's first argument, but received #{arg.car}" unless str_arg.string?
+      return Lisp::Debug.process_error("string-ref requires a string as it's first argument, but received #{arg.car}", env) unless str_arg.string?
       str = str_arg.value
       k_arg = args.cadr.evaluate(env)
-      raise "string-ref requires it's second argument to be an integer, but received #{k_arg}" unless k_arg.integer?
+      return Lisp::Debug.process_error("string-ref requires it's second argument to be an integer, but received #{k_arg}", env) unless k_arg.integer?
       k = k_arg.value
       return Lisp::FALSE if k < 0 || k >= str.length
       Lisp::Character.find_character_for_chr(str[k])
@@ -175,16 +175,16 @@ end
 
 
     def self.string_set_impl(args, env)
-      raise "string-set! needs 3 arguments, but received #{args.length}" unless args.length == 3
+      return Lisp::Debug.process_error("string-set! needs 3 arguments, but received #{args.length}", env) unless args.length == 3
       str_arg = args.car.evaluate(env)
-      raise "string-set! needs a string as it's first argument, but received #{str_arg}" unless str_arg.string?
+      return Lisp::Debug.process_error("string-set! needs a string as it's first argument, but received #{str_arg}", env) unless str_arg.string?
       str = str_arg.value
       k_arg = args.cadr.evaluate(env)
-      raise "string-set! requires an integer as it's second argument, but received #{k_arg}" unless k_arg.integer?
+      return Lisp::Debug.process_error("string-set! requires an integer as it's second argument, but received #{k_arg}", env) unless k_arg.integer?
       k = k_arg.value
       return Lisp::FALSE if k < 0 || k >= str.length
       replacement_arg = args.caddr.evaluate(env)
-      raise "string-set! requires a character as it's third argument, but received #{replacement_arg}" unless replacement_arg.character?
+      return Lisp::Debug.process_error("string-set! requires a character as it's third argument, but received #{replacement_arg}", env) unless replacement_arg.character?
       replacement = replacement_arg.value
       str[k] = replacement
       self.with_value(str)
@@ -192,20 +192,20 @@ end
 
 
     def self.get_substring(func, str, start_index, end_index)
-      raise "#{func} requires a string, but received #{str}" unless str.string?
+      return Lisp::Debug.process_error("#{func} requires a string, but received #{str}", env) unless str.string?
       s = str.value
-      raise "#{func} requires an integer start index, but received #{start_index}" unless start_index.integer?
+      return Lisp::Debug.process_error("#{func} requires an integer start index, but received #{start_index}", env) unless start_index.integer?
       si = start_index.value
-      raise "#{func} received an invalid substring start index: #{si}" if si < 0 || si > s.length
-      raise "#{func} requires an integer end index, but received #{end_index}" unless end_index.integer?
+      return Lisp::Debug.process_error("#{func} received an invalid substring start index: #{si}", env) if si < 0 || si > s.length
+      return Lisp::Debug.process_error("#{func} requires an integer end index, but received #{end_index}", env) unless end_index.integer?
       ei = end_index.value
-      raise "#{func} received an invalid substring end index: #{ei}" if ei < 0 || ei > s.length
+      return Lisp::Debug.process_error("#{func} received an invalid substring end index: #{ei}", env) if ei < 0 || ei > s.length
       s[si...ei]
     end
 
 
     def self.extract_substrings(func, args, env)
-      raise "#{func} requires 6 arguments, but received #{args.length}" unless args.length == 6      
+      return Lisp::Debug.process_error("#{func} requires 6 arguments, but received #{args.length}", env) unless args.length == 6      
       substr1 = get_substring(func, args.nth(1).evaluate(env), args.nth(2).evaluate(env), args.nth(3).evaluate(env))
       substr2 = get_substring(func, args.nth(4).evaluate(env), args.nth(5).evaluate(env), args.nth(6).evaluate(env))
       return [substr1, substr2]
@@ -213,13 +213,13 @@ end
 
     
     def self.get_string(func, str)
-      raise "#{func} requires a string, but received #{str}" unless str.string?
+      return Lisp::Debug.process_error("#{func} requires a string, but received #{str}", env) unless str.string?
       str.value
     end
 
 
     def self.extract_strings(func, args, env)
-      raise "#{func} requires 2 arguments, but received #{args.length}" unless args.length == 2
+      return Lisp::Debug.process_error("#{func} requires 2 arguments, but received #{args.length}", env) unless args.length == 2
       str1 = get_string(func, args.nth(1).evaluate(env))
       str2 = get_string(func, args.nth(2).evaluate(env))
       return [str1, str2]
@@ -347,7 +347,7 @@ end
 
     
     def self.string_compare_impl(args, env)
-      raise "string-compare requires 5 arguments, but received #{args.length}" unless args.length == 5
+      return Lisp::Debug.process_error("string-compare requires 5 arguments, but received #{args.length}", env) unless args.length == 5
       str1 = get_string("string-compare", args.nth(1).evaluate(env))
       str2 = get_string("string-compare", args.nth(2).evaluate(env))
       f_number = case str1 <=> str2
@@ -359,13 +359,13 @@ end
                    5
                  end
       f = args.nth(f_number).evaluate(env)
-      raise "string-compare requires functions for argument #{f_number}, but received #{f}" unless f.function?
+      return Lisp::Debug.process_error("string-compare requires functions for argument #{f_number}, but received #{f}", env) unless f.function?
       f.apply_to(Lisp::ConsCell.cons, env)
     end
 
 
     def self.string_compare_ci_impl(args, env)
-      raise "string-compare-ci requires 5 arguments, but received #{args.length}" unless args.length == 5
+      return Lisp::Debug.process_error("string-compare-ci requires 5 arguments, but received #{args.length}", env) unless args.length == 5
       str1 = get_string("string-compare-ci", args.nth(1).evaluate(env))
       str2 = get_string("string-compare-ci", args.nth(2).evaluate(env))
       f_number = case str1.downcase <=> str2.downcase
@@ -377,7 +377,7 @@ end
                    5
                  end
       f = args.nth(f_number).evaluate(env)
-      raise "string-compare-ci requires functions for argument #{f_number}, but received #{f}" unless f.function?
+      return Lisp::Debug.process_error("string-compare-ci requires functions for argument #{f_number}, but received #{f}", env) unless f.function?
       f.apply_to(Lisp::ConsCell.cons, env)
     end
 
@@ -391,7 +391,7 @@ end
     def self.string_hash_mod_impl(args, env)
       str = get_string("string-hash-mod", args.nth(1).evaluate(env))
       k_arg = args.cadr.evaluate(env)
-      raise "string-hash-mod requires it's second argument to be an integer, but received #{k_arg}" unless k_arg.integer?
+      return Lisp::Debug.process_error("string-hash-mod requires it's second argument to be an integer, but received #{k_arg}", env) unless k_arg.integer?
       k = k_arg.value
       Lisp::Number.with_value(str.hash % k)
     end
@@ -489,9 +489,9 @@ end
 
 
     def self.string_capitalize_bang_impl(args, env)
-      raise "string-capitalize! requires 1 argument, but received #{args.length}" unless args.length == 1
+      return Lisp::Debug.process_error("string-capitalize! requires 1 argument, but received #{args.length}", env) unless args.length == 1
       str = args.nth(1).evaluate(env)
-      raise "string-capitalize! requires a string, but received #{str}" unless str.string?
+      return Lisp::Debug.process_error("string-capitalize! requires a string, but received #{str}", env) unless str.string?
       new_chars = capitalize_string(str.value)
       new_str = ""
       new_chars.each {|c| new_str << c}
@@ -501,20 +501,20 @@ end
 
 
     def self.substring_capitalize_bang_impl(args, env)
-      raise "substring-capitalize! requires 3 arguments, but received #{args.length}" unless args.length == 3
+      return Lisp::Debug.process_error("substring-capitalize! requires 3 arguments, but received #{args.length}", env) unless args.length == 3
       s = args.nth(1).evaluate(env)
-      raise "substring-capitalize! requires a string as it's first argument, but received #{s}" unless s.string?
+      return Lisp::Debug.process_error("substring-capitalize! requires a string as it's first argument, but received #{s}", env) unless s.string?
       str = s.value
       
       start_index = args.nth(2).evaluate(env)
-      raise "substring-capitalize! requires an integer start index, but received #{start_index}" unless start_index.integer?
+      return Lisp::Debug.process_error("substring-capitalize! requires an integer start index, but received #{start_index}", env) unless start_index.integer?
       si = start_index.value
-      raise "substring-capitalize! received an invalid substring start index: #{si}" if si < 0 || si > str.length
+      return Lisp::Debug.process_error("substring-capitalize! received an invalid substring start index: #{si}", env) if si < 0 || si > str.length
 
       end_index = args.nth(3).evaluate(env)
-      raise "substring-capitalize! requires an integer end index, but received #{end_index}" unless end_index.integer?
+      return Lisp::Debug.process_error("substring-capitalize! requires an integer end index, but received #{end_index}", env) unless end_index.integer?
       ei = end_index.value
-      raise "substring-capitalize! received an invalid substring end index: #{ei}" if ei < 0 || ei > str.length
+      return Lisp::Debug.process_error("substring-capitalize! received an invalid substring end index: #{ei}", env) if ei < 0 || ei > str.length
 
       prefix = str[0...si]
       substr = str[si...ei]
@@ -535,29 +535,29 @@ end
 
 
     def self.string_downcase_bang_impl(args, env)
-      raise "string-downcase! requires 1 argument, but received #{args.length}" unless args.length == 1
+      return Lisp::Debug.process_error("string-downcase! requires 1 argument, but received #{args.length}", env) unless args.length == 1
       str = args.nth(1).evaluate(env)
-      raise "string-downcase! requires a string, but received #{str}" unless str.string?
+      return Lisp::Debug.process_error("string-downcase! requires a string, but received #{str}", env) unless str.string?
       str.set!(str.value.downcase)
       str
     end
 
 
     def self.substring_downcase_bang_impl(args, env)
-      raise "substring-downcase! requires 3 arguments, but received #{args.length}" unless args.length == 3
+      return Lisp::Debug.process_error("substring-downcase! requires 3 arguments, but received #{args.length}", env) unless args.length == 3
       s = args.nth(1).evaluate(env)
-      raise "substring-downcase! requires a string as it's first argument, but received #{s}" unless s.string?
+      return Lisp::Debug.process_error("substring-downcase! requires a string as it's first argument, but received #{s}", env) unless s.string?
       str = s.value
       
       start_index = args.nth(2).evaluate(env)
-      raise "substring-downcase! requires an integer start index, but received #{start_index}" unless start_index.integer?
+      return Lisp::Debug.process_error("substring-downcase! requires an integer start index, but received #{start_index}", env) unless start_index.integer?
       si = start_index.value
-      raise "substring-downcase! received an invalid substring start index: #{si}" if si < 0 || si > str.length
+      return Lisp::Debug.process_error("substring-downcase! received an invalid substring start index: #{si}", env) if si < 0 || si > str.length
 
       end_index = args.nth(3).evaluate(env)
-      raise "substring-downcase! requires an integer end index, but received #{end_index}" unless end_index.integer?
+      return Lisp::Debug.process_error("substring-downcase! requires an integer end index, but received #{end_index}", env) unless end_index.integer?
       ei = end_index.value
-      raise "substring-downcase! received an invalid substring end index: #{ei}" if ei < 0 || ei > str.length
+      return Lisp::Debug.process_error("substring-downcase! received an invalid substring end index: #{ei}", env) if ei < 0 || ei > str.length
 
       prefix = str[0...si]
       substr = str[si...ei]
@@ -578,29 +578,29 @@ end
 
 
     def self.string_upcase_bang_impl(args, env)
-      raise "string-upcase! requires 1 argument, but received #{args.length}" unless args.length == 1
+      return Lisp::Debug.process_error("string-upcase! requires 1 argument, but received #{args.length}", env) unless args.length == 1
       str = args.nth(1).evaluate(env)
-      raise "string-upcase! requires a string, but received #{str}" unless str.string?
+      return Lisp::Debug.process_error("string-upcase! requires a string, but received #{str}", env) unless str.string?
       str.set!(str.value.upcase)
       str
     end
 
 
     def self.substring_upcase_bang_impl(args, env)
-      raise "substring-upcase! requires 3 arguments, but received #{args.length}" unless args.length == 3
+      return Lisp::Debug.process_error("substring-upcase! requires 3 arguments, but received #{args.length}", env) unless args.length == 3
       s = args.nth(1).evaluate(env)
-      raise "substring-upcase! requires a string as it's first argument, but received #{s}" unless s.string?
+      return Lisp::Debug.process_error("substring-upcase! requires a string as it's first argument, but received #{s}", env) unless s.string?
       str = s.value
       
       start_index = args.nth(2).evaluate(env)
-      raise "substring-upcase! requires an integer start index, but received #{start_index}" unless start_index.integer?
+      return Lisp::Debug.process_error("substring-upcase! requires an integer start index, but received #{start_index}", env) unless start_index.integer?
       si = start_index.value
-      raise "substring-upcase! received an invalid substring start index: #{si}" if si < 0 || si > str.length
+      return Lisp::Debug.process_error("substring-upcase! received an invalid substring start index: #{si}", env) if si < 0 || si > str.length
 
       end_index = args.nth(3).evaluate(env)
-      raise "substring-upcase! requires an integer end index, but received #{end_index}" unless end_index.integer?
+      return Lisp::Debug.process_error("substring-upcase! requires an integer end index, but received #{end_index}", env) unless end_index.integer?
       ei = end_index.value
-      raise "substring-upcase! received an invalid substring end index: #{ei}" if ei < 0 || ei > str.length
+      return Lisp::Debug.process_error("substring-upcase! received an invalid substring end index: #{ei}", env) if ei < 0 || ei > str.length
 
       prefix = str[0...si]
       substr = str[si...ei]
@@ -617,7 +617,7 @@ end
     def self.string_append_impl(args, env)
       strings = args.to_a.map do |a|
         s = a.evaluate(env)
-        raise "string-append requires strings, but received #{s}" unless s.string?
+        return Lisp::Debug.process_error("string-append requires strings, but received #{s}", env) unless s.string?
         s.value
       end
 
@@ -632,49 +632,49 @@ end
 
 
     def self.string_head_impl(args, env)
-      raise "string-head requires 2 arguments, but received #{args.length}" unless args.length == 2
+      return Lisp::Debug.process_error("string-head requires 2 arguments, but received #{args.length}", env) unless args.length == 2
       s = args.nth(1).evaluate(env)
-      raise "string-head requires a string as it's first argument, but received #{s}" unless s.string?
+      return Lisp::Debug.process_error("string-head requires a string as it's first argument, but received #{s}", env) unless s.string?
       str = s.value
       
       end_index = args.nth(2).evaluate(env)
-      raise "string-head requires an integer end index, but received #{end_index}" unless end_index.integer?
+      return Lisp::Debug.process_error("string-head requires an integer end index, but received #{end_index}", env) unless end_index.integer?
       ei = end_index.value
-      raise "string-head received an invalid end index: #{ei}" if ei < 0 || ei > str.length
+      return Lisp::Debug.process_error("string-head received an invalid end index: #{ei}", env) if ei < 0 || ei > str.length
 
       self.with_value(str[0...ei])
     end
 
 
     def self.string_tail_impl(args, env)
-      raise "string-tail requires 2 arguments, but received #{args.length}" unless args.length == 2
+      return Lisp::Debug.process_error("string-tail requires 2 arguments, but received #{args.length}", env) unless args.length == 2
       s = args.nth(1).evaluate(env)
-      raise "string-tail requires a string as it's first argument, but received #{s}" unless s.string?
+      return Lisp::Debug.process_error("string-tail requires a string as it's first argument, but received #{s}", env) unless s.string?
       str = s.value
       
       start_index = args.nth(2).evaluate(env)
-      raise "string-tail requires an integer start index, but received #{start_index}" unless start_index.integer?
+      return Lisp::Debug.process_error("string-tail requires an integer start index, but received #{start_index}", env) unless start_index.integer?
       si = start_index.value
-      raise "string-tail received an invalid end index: #{si}" if si < 0 || si > str.length
+      return Lisp::Debug.process_error("string-tail received an invalid end index: #{si}", env) if si < 0 || si > str.length
 
       self.with_value(str[si..-1])
     end
 
 
     def self.string_pad_left_impl(args, env)
-      raise "string-pad-left requires 2 or 3 arguments, but received #{args.length}" unless args.length == 2 || args.length == 3
+      return Lisp::Debug.process_error("string-pad-left requires 2 or 3 arguments, but received #{args.length}", env) unless args.length == 2 || args.length == 3
       s = args.nth(1).evaluate(env)
-      raise "string-pad-left requires a string as it's first argument, but received #{s}" unless s.string?
+      return Lisp::Debug.process_error("string-pad-left requires a string as it's first argument, but received #{s}", env) unless s.string?
       str = s.value
       
       size_arg = args.nth(2).evaluate(env)
-      raise "string-pad-left requires an integer size, but received #{size_arg}" unless size_arg.integer?
+      return Lisp::Debug.process_error("string-pad-left requires an integer size, but received #{size_arg}", env) unless size_arg.integer?
       size = size_arg.value
-      raise "string-pad-left received an invalid size: #{size}" if size < 0
+      return Lisp::Debug.process_error("string-pad-left received an invalid size: #{size}", env) if size < 0
 
       padding_char = if args.length == 3
                        ch_arg = args.nth(3).evaluate(env)
-                       raise "string-pad-left requires a character pad, but received #{ch_arg}" unless ch_arg.character?
+                       return Lisp::Debug.process_error("string-pad-left requires a character pad, but received #{ch_arg}", env) unless ch_arg.character?
                        ch_arg.value
                      else
                        " "

data/lib/rubylisp/system.rb

@@ -4,13 +4,14 @@ module Lisp
 
     def self.register
       Primitive.register("sleep")         {|args, env| Lisp::System.sleep_impl(args, env) }
+      Primitive.register("quit")          {|args, env| exit() }
     end
 
 
     def self.sleep_impl(args, env)
-      raise "sleep needs 1 argument" if args.length != 1
+      return Lisp::Debug.process_error("sleep needs 1 argument", env) if args.length != 1
       arg = args.car.evaluate(env)
-      raise "sleep needs a numeric argument" unless arg.number?
+      return Lisp::Debug.process_error("sleep needs a numeric argument", env) unless arg.number?
       sleep(arg.value)
     end
 

data/lib/rubylisp/testing.rb

@@ -11,7 +11,7 @@ module Lisp
     end
 
     def self.describe_impl(args, env)
-      raise "First arg to describe must be a string or symbol" if !args.car.symbol? && !args.car.string?
+      return Lisp::Debug.process_error("First arg to describe must be a string or symbol", env) if !args.car.symbol? && !args.car.string?
       return if args.cdr.nil?
       puts
       puts "  #{args.car.to_s}"
@@ -68,7 +68,7 @@ module Lisp
                                when 2
                                    self.binary_check(name, args.car, args.cadr, env, inverted)
                                else
-                                   raise "check takes 1 or 2 arguments, received #{args.length}"
+                                   return Lisp::Debug.process_error("check takes 1 or 2 arguments, received #{args.length}", env)
                                end)
     end
 
@@ -79,7 +79,7 @@ module Lisp
     
     
     def self.check_star_impl(args, env)
-      raise "check* needs 2 arguments, received #{args.length}" if args.length != 2
+      return Lisp::Debug.process_error("check* needs 2 arguments, received #{args.length}", env) if args.length != 2
       @@number_of_tests += 1
       print "    (check* #{args.car.print_string} #{args.cadr.print_string}) - "
       

data/lib/rubylisp/type_checks.rb

@@ -7,50 +7,52 @@ module Lisp
       Primitive.register("pair?")     {|args, env| Lisp::TypeChecks::typep_impl("pair?", :pair, args, env) }
       Primitive.register("symbol?")   {|args, env| Lisp::TypeChecks::typep_impl("symbol?", :symbol, args, env) }
       Primitive.register("number?")   {|args, env| Lisp::TypeChecks::typep_impl("number?", :number, args, env) }
-      Primitive.register("integer?")   {|args, env| Lisp::TypeChecks::integerp_impl(args, env) }
-      Primitive.register("float?")   {|args, env| Lisp::TypeChecks::floatp_impl(args, env) }
+      Primitive.register("integer?")  {|args, env| Lisp::TypeChecks::integerp_impl(args, env) }
+      Primitive.register("float?")    {|args, env| Lisp::TypeChecks::floatp_impl(args, env) }
       Primitive.register("function?") {|args, env| Lisp::TypeChecks::functionp_impl(args, env) }
 
       Primitive.register("nil?")      {|args, env| Lisp::TypeChecks::nilp_impl(args, env) }
+      Primitive.register("null?")     {|args, env| Lisp::TypeChecks::nilp_impl(args, env) }
       Primitive.register("not-nil?")  {|args, env| Lisp::TypeChecks::not_nilp_impl(args, env) }
+      Primitive.register("not-null?") {|args, env| Lisp::TypeChecks::not_nilp_impl(args, env) }
     end
 
 
     def self.typep_impl(name, sym, args, env)
-      raise "#{name} needs 1 argument" unless args.length == 1
+      return Lisp::Debug.process_error("#{name} needs 1 argument", env) unless args.length == 1
       return Lisp::Boolean.with_value(args.car.evaluate(env).type == sym)
     end
 
 
     def self.integerp_impl(args, env)
-      raise "integer? needs 1 argument" unless args.length == 1
+      return Lisp::Debug.process_error("integer? needs 1 argument", env) unless args.length == 1
       val = args.car.evaluate(env)
       return Lisp::Boolean.with_value(val.type == :number && val.integer?)
     end
 
 
     def self.floatp_impl(args, env)
-      raise "float? needs 1 argument" unless args.length == 1
+      return Lisp::Debug.process_error("float? needs 1 argument", env) unless args.length == 1
       val = args.car.evaluate(env)
       return Lisp::Boolean.with_value(val.type == :number && val.float?)
     end
 
 
     def self.functionp_impl(args, env)
-      raise "function? needs 1 argument" unless args.length == 1
+      return Lisp::Debug.process_error("function? needs 1 argument", env) unless args.length == 1
       val = args.car.evaluate(env)
       return Lisp::Boolean.with_value(val.type == :function || val.type == :primitive)
     end
 
 
     def self.nilp_impl(args, env)
-      raise "nil? needs 1 argument" unless args.length == 1
+      return Lisp::Debug.process_error("nil? needs 1 argument", env) unless args.length == 1
       return Lisp::Boolean.with_value(args.car.evaluate(env).nil?)
     end
 
 
     def self.not_nilp_impl(args, env)
-      raise "not-nil? needs 1 argument" unless args.length == 1
+      return Lisp::Debug.process_error("not-nil? needs 1 argument", env) unless args.length == 1
       return Lisp::Boolean.with_value(!args.car.evaluate(env).nil?)
     end