rubymotionlisp 0.2.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d85596233d6ab54b78b99d7f4342ffd4715b0232
-  data.tar.gz: 2d932f67ed7198a177d3e861f7e28e8bf44ed17b
+  metadata.gz: 4a5e0c6cc93b15753596a1b9aa0c822b0b68c6a3
+  data.tar.gz: 00eee04b22a3f97fed1247ccfd648344e52be820
 SHA512:
-  metadata.gz: b7a037bf9a0259db400540ffed44e03435c9f5b99000b1109b2cd80904c35a2a15c5b1e56db1986246daf758cba332cf6aefe149f48bbdd32485c5cb9c9e9381
-  data.tar.gz: 3b44862aef4a032f91ef8049eda3b3c8d513643cc3c6c500ffbbd1ab90b6d93a825da01245d7428fd70e595b179b38832ddbd2c636762cc84d933db572d27982
+  metadata.gz: 9c4ff7a0acfd6600aaf14a59d7a4ed1f3d44bf159f5058e0314637e475acfff5cef39dd2749d3f1f4ea33109d6bab6232762f5b8e7b29a81883b4afef893892e
+  data.tar.gz: 4bcdc3a7c9b7af440ffe8c563c8e422b5e63724189b873eb0e39d12b4647332550349c67494e0892ace064bb67fd1856280713fb6612eceb0e0570af53d62850

data/README.md

@@ -43,13 +43,75 @@ Or install it yourself as:
 4. Push to the branch (git push origin my-new-feature)
 5. Create new Pull Request
 
-## REPL
+## The rubylisp command ##
+
+Installing the rubylisp gem installs the `rubylisp` command
+
+    >:rubylisp help
+      NAME:
+    
+        rubylisp
+    
+      DESCRIPTION:
+    
+        A large sub/super-set of MIT/GNU-Scheme implemented in pure Ruby.
+    
+      COMMANDS:
+            
+        help Display global or [command] help documentation         
+        repl Rubylisp REPL          
+        test Runs tests     
+    
+      GLOBAL OPTIONS:
+            
+        -h, --help 
+            Display help documentation
+            
+        -v, --version 
+            Display version information
+            
+        -t, --trace 
+            Display backtrace when an error occurs
+            
+    >:
+
+        
+### REPL ###
 
 RubyLisp includes a very basic REPL that, as expected, lets you type
 in snippets (it does not support multiline snippets) of Lisp code,
 evaluates them, and prints the result.
 
-    >: rubylisp
+    >:rubylisp help repl
+
+    NAME:
+    
+        repl
+    
+      SYNOPSIS:
+    
+        rubylisp repl [options]
+    
+      DESCRIPTION:
+    
+        Rubylisp REPL
+    
+      EXAMPLES:
+            
+        # Simply run the REPL
+        rubylisp repl
+            
+        # Run the REPL, loading a file first
+        rubylisp repl --file code.lsp
+            
+      OPTIONS:
+            
+        -f, --file LISPFILE 
+            The name of the lisp file to load
+            
+
+
+    >: rubylisp repl
 
     RubyLisp REPL
     > 4
@@ -61,6 +123,71 @@ evaluates them, and prints the result.
     > (fib 4)
     24
 
+The repl uses readline for editing and history. History is saved in ~/.rubylisp_history. Evaling `(quit)` will exit the repl.
+
+### Test runner ###
+
+The `rubylisp` command also contains a test runner.
+
+    >:ruby -Ilib bin/rubylisp help test
+    
+      NAME:
+    
+        test
+    
+      SYNOPSIS:
+    
+        rubylisp test [options]
+    
+      DESCRIPTION:
+    
+        Runs tests
+    
+      EXAMPLES:
+            
+        # Run the tests in tests/list_tests.lsp with verbose output
+        rubylisp test -v -f tests/list_tests.lsp
+            
+        # Quietly run all tests in the directory tests
+        rubylisp test -q -d tests
+            
+      OPTIONS:
+            
+        -f, --file TESTFILE 
+            The name of the test file to run
+            
+        -d, --dir TESTDIR 
+            The name of a directory of test files, all of which will be run
+            
+        --verbose 
+            Verbose test output: all context & it labels, and each assertion and it's result.
+            
+        --terse 
+            terse test output (the default): + for passes, - for failures, and ! for errors
+            
+        --quiet 
+            Only output a summary
+
+    >:rubylisp test -d lisptest --terse
+    
+    
+    Running lisp tests
+    +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+    +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+    +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+    +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+    +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+    +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+    +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+    +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+    +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+    +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+    +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+    +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+    ++++++++++++++++++++++++++++
+    Ran 928 lisp tests in 7.0789 seconds
+    928 passes, 0 failures, 0 errors
+
 ## Integrating
 
 

data/lib/rubylisp/atom.rb

@@ -68,15 +68,23 @@ module Lisp
       false
     end
 
-    def alist?
+    def frame?
       false
     end
 
-    def frame?
+    def vector?
       false
     end
 
-    def vector?
+    def port?
+      false
+    end
+
+    def eof_object?
+      false
+    end
+
+    def environment?
       false
     end
 
@@ -88,10 +96,16 @@ module Lisp
       self.class.new(self.value)
     end
     
+    def eqv?(sexpr)
+      self == sexpr
+    end
+
     def eq?(sexpr)
-      return false if sexpr.nil?
-      return false if self.type != sexpr.type
-      self.value == sexpr.value
+      eqv?(sexpr)
+    end
+    
+    def equal?(sexpr)
+      eq?(sexpr)
     end
     
     def type
@@ -133,6 +147,11 @@ module Lisp
     def set!(v)
     end
 
+    def to_s
+      @value.to_s
+    end
+
+    
     def print_string
       self.to_s
     end

data/lib/rubylisp/boolean.rb

@@ -2,11 +2,11 @@ module Lisp
 
   class Boolean < Atom
     def self.TRUE
-      @true_constant ||= Boolean.new(true)
+      @true_constant ||= Lisp::Boolean.new(true)
     end
 
     def self.FALSE
-      @false_constant ||= Boolean.new(false)
+      @false_constant ||= Lisp::Boolean.new(false)
     end
 
     def self.with_value(b)
@@ -26,8 +26,11 @@ module Lisp
     end
 
     def to_s
-      return "#t" if @value
-      "#f"
+      if @value
+        "#t"
+      else
+        "#f"
+      end
     end
 
     def true?
@@ -44,6 +47,6 @@ module Lisp
     
   end
 
-  TRUE = Boolean.TRUE
-  FALSE = Boolean.FALSE
+  TRUE = Lisp::Boolean.TRUE
+  FALSE = Lisp::Boolean.FALSE
 end

data/lib/rubylisp/builtins.rb

@@ -0,0 +1,33 @@
+module Lisp
+
+  class Initializer
+
+    def self.initialize_global_environment
+      Lisp::EnvironmentFrame.global.bind(Symbol.named("nil"), nil)
+    end
+
+    def self.register_builtins
+      Lisp::PrimEquivalence.register
+      Lisp::PrimMath.register
+      Lisp::PrimLogical.register
+      Lisp::PrimSpecialForms.register
+      Lisp::PrimListSupport.register
+      Lisp::PrimRelational.register
+      Lisp::PrimTypeChecks.register
+      Lisp::PrimAssignment.register
+      Lisp::PrimIo.register
+      Lisp::PrimAlist.register
+      Lisp::PrimFrame.register
+      Lisp::PrimCharacter.register
+      Lisp::PrimString.register
+      Lisp::PrimNativeObject.register
+      Lisp::PrimClassObject.register
+      Lisp::PrimSystem.register
+      Lisp::PrimVector.register
+      Lisp::Debug.register
+      Lisp::PrimEnvironment.register
+    end
+
+  end
+
+end

data/lib/rubylisp/character.rb

@@ -3,278 +3,6 @@ module Lisp
 
   class Character < Atom
 
-    def self.register
-      Primitive.register("char->name", "(char->name char)\n\nReturns a string corresponding to the printed representation of char. This is the character or character-name component of the external representation.") do |args, env|
-        Lisp::Character::char_name_impl(args, env)
-      end
-      
-      Primitive.register("name->char", "(name->char string)\n\nConverts a string that names a character into the character specified. If string does not name any character, name->char signals an error.") do |args, env|
-        Lisp::Character::name_char_impl(args, env)
-      end
-      
-      Primitive.register("char=?", "(char=? char1 char2)\n\nReturn whether char1 and char2 are the same") do |args, env|
-        Lisp::Character::char_eq_impl(args, env)
-      end
-      
-      Primitive.register("char<?", "(char<? char1 char2)\n\nReturn whether char1 is less than char2") do |args, env|
-        Lisp::Character::char_lt_impl(args, env)
-      end
-      
-      Primitive.register("char>?", "(char>? char1 char2)\n\nReturn whether char1 is greater than char2") do |args, env|
-        Lisp::Character::char_gt_impl(args, env)
-      end
-      
-      Primitive.register("char<=?", "(char<=? char1 char2)\n\nReturn whether char1 is less than or equal to char2") do |args, env|
-        Lisp::Character::char_lteq_impl(args, env)
-      end
-      
-      Primitive.register("char>=?", "(char>=? char1 char2)\n\nReturn whether char1 is greater than or equal to char2") do |args, env|
-        Lisp::Character::char_gteq_impl(args, env)
-      end
-      
-      Primitive.register("char-ci=?", "(char=? char1 char2)\n\nReturn whether char1 is equal to char2, ignoring case") do |args, env|
-        Lisp::Character::char_ci_eq_impl(args, env)
-      end
-      
-      Primitive.register("char-ci<?", "(char=? char1 char2)\n\nReturn whether char1 is less than char2, ignoring case") do |args, env|
-        Lisp::Character::char_ci_lt_impl(args, env)
-      end
-      
-      Primitive.register("char-ci>?", "(char=? char1 char2)\n\nReturn whether char1 is greater than char2, ignoring case") do |args, env|
-        Lisp::Character::char_ci_gt_impl(args, env)
-      end
-      
-      Primitive.register("char-ci<=?", "(char=? char1 char2)\n\nReturn whether char1 is less than or equal to char2, ignoring case") do |args, env|
-        Lisp::Character::char_ci_lteq_impl(args, env)
-      end
-      
-      Primitive.register("char-ci>=?", "(char=? char1 char2)\n\nReturn whether char1 is greater than orequal to char2, ignoring case") do |args, env|
-        Lisp::Character::char_ci_gteq_impl(args, env)
-      end
-      
-      Primitive.register("char?", "(char? sexpr)\n\nReturns #t if object is a character; otherwise returns #f.") do |args, env|
-        Lisp::Character::charp_impl(args, env)
-      end
-      
-      Primitive.register("char-upcase", "(char-upcase char)\n\nReturns the uppercase equivalent of char if char is a letter; otherwise returns char. These procedures return a character char2 such that (char-ci=? char char2).") do |args, env|
-        Lisp::Character::char_upcase_impl(args, env)
-      end
-      
-      Primitive.register("char-downcase", "(char-downcase char)\n\nReturns the lowercase equivalent of char if char is a letter; otherwise returns char. These procedures return a character char2 such that (char-ci=? char char2).") do |args, env|
-        Lisp::Character::char_downcase_impl(args, env)
-      end
-      
-      Primitive.register("char->digit", "(char->digit char [radix])\n\nIf char is a character representing a digit in the given radix, returns the corresponding integer value. If you specify radix (which must be an integer between 2 and 36 inclusive), the conversion is done in that base, otherwise it is done in base 10. If char doesn’t represent a digit in base radix, char->digit returns #f.\n\nNote that this procedure is insensitive to the alphabetic case of char.") do |args, env|
-        Lisp::Character::char_digit_impl(args, env)
-      end
-      
-      Primitive.register("digit->char", "(digit->char digit [radix])\n\nReturns a character that represents digit in the radix given by radix. Radix must be an exact integer between 2 and 36 (inclusive), and defaults to 10. Digit, which must be a non-negative integer, should be less than radix; if digit is greater than or equal to radix, digit->char returns #f.") do |args, env|
-        Lisp::Character::digit_char_impl(args, env)
-      end
-      
-      Primitive.register("char->integer", "(char->integer char)\n\nchar->integer returns the character code representation for char.") do |args, env|
-        Lisp::Character::char_int_impl(args, env)
-      end
-      
-      Primitive.register("integer->char", "(integer->char k)\n\ninteger->char returns the character whose character code representation is k.") do |args, env|
-        Lisp::Character::int_char_impl(args, env)
-      end
-    end
-
-
-    def self.find_character_for_chr(ch)
-      @@character_constants.each_value {|v| return v if v.value == ch}
-      return @@character_constants[ch] = Lisp::Character.new(ch)
-    end
-
-
-    def self.find_character_for_name(n)
-      return @@character_constants[n] if @@character_constants.has_key?(n)
-      if n.length == 1
-        ch = self.new(n[0])
-       return @@character_constants[n] = ch
-      end
-      nil
-    end
-
-
-    def self.char_name_impl(args, env)
-      return Lisp::Debug.process_error("char->name requires a single argument, found #{args.length}", env) unless args.length == 1
-      char = args.car.evaluate(env)
-      return Lisp::Debug.process_error("char->name requires a character argument", env) unless char.character?
-      kv = @@character_constants.rassoc(char)
-      return Lisp::String.with_value(kv[0]) unless kv.nil?
-      return Lisp::Debug.process_error("char->name was passed an invalid character", env)
-    end
-
-
-    def self.name_char_impl(args, env)
-      return Lisp::Debug.process_error("name->char requires a single argument, found #{args.length}", env) unless args.length == 1
-      name = args.car.evaluate(env)
-      return Lisp::Debug.process_error("name->char requires a string argument", env) unless name.string?
-      ch = find_character_for_name(name.value)
-      return ch unless ch.nil?
-      return Lisp::Debug.process_error("There is no character with the name #{name}", env)
-    end
-
-
-    def self.get_one_character_arg(func, args, env)
-      return Lisp::Debug.process_error("#{func} requires a character argument, found no args", env) unless args.length >= 1
-      char1 = args.car.evaluate(env)
-      return Lisp::Debug.process_error("#{func} requires a character argument, found #{char1}", env) unless char1.character?
-      return char1
-    end
-
-
-    def self.get_two_character_args(func, args, env)
-      return Lisp::Debug.process_error("#{func} requires two arguments, found
-                                ##{args.length}", env) unless args.length == 2
-      char1 = args.car.evaluate(env)
-      return Lisp::Debug.process_error("#{func} requires character arguments, found #{char1}", env) unless char1.character?
-      char2 = args.cadr.evaluate(env)
-      return Lisp::Debug.process_error("#{func} requires character arguments, found #{char2}", env) unless char2.character?
-      return [char1, char2]
-    end
-
-
-    def self.char_eq_impl(args, env)
-      char1, char2 = get_two_character_args("char=?", args, env)
-      Lisp::Boolean.with_value(char1.value == char2.value)
-    end
-
-
-    def self.char_lt_impl(args, env)
-      char1, char2 = get_two_character_args("char<?", args, env)
-      Lisp::Boolean.with_value(char1.value < char2.value)
-    end
-
-
-    def self.char_gt_impl(args, env)
-      char1, char2 = get_two_character_args("char>?", args, env)
-      Lisp::Boolean.with_value(char1.value > char2.value)
-    end
-
-
-    def self.char_lteq_impl(args, env)
-      char1, char2 = get_two_character_args("char<=?", args, env)
-      Lisp::Boolean.with_value(char1.value <= char2.value)
-    end
-
-
-    def self.char_gteq_impl(args, env)
-      char1, char2 = get_two_character_args("char>=?", args, env)
-      Lisp::Boolean.with_value(char1.value >= char2.value)
-    end
-
-
-    def self.char_ci_eq_impl(args, env)
-      char1, char2 = get_two_character_args("char-ci=?", args, env)
-      Lisp::Boolean.with_value(char1.value.downcase == char2.value.downcase)
-    end
-
-
-    def self.char_ci_lt_impl(args, env)
-      char1, char2 = get_two_character_args("char-ci<?", args, env)
-      Lisp::Boolean.with_value(char1.value.downcase < char2.value.downcase)
-    end
-
-
-    def self.char_ci_gt_impl(args, env)
-      char1, char2 = get_two_character_args("char-ci>?", args, env)
-      Lisp::Boolean.with_value(char1.value.downcase > char2.value.downcase)
-    end
-
-
-    def self.char_ci_lteq_impl(args, env)
-      char1, char2 = get_two_character_args("char-ci<=?", args, env)
-      Lisp::Boolean.with_value(char1.value.downcase <= char2.value.downcase)
-    end
-
-
-    def self.char_ci_gteq_impl(args, env)
-      char1, char2 = get_two_character_args("char-ci>=?", args, env)
-      Lisp::Boolean.with_value(char1.value.downcase >= char2.value.downcase)
-    end
-
-
-    def self.charp_impl(args, env)
-      return Lisp::Debug.process_error("char->name requires a single argument, found #{args.length}", env) unless args.length == 1
-      char = args.car.evaluate(env)
-      Lisp::Boolean.with_value(char.character?)
-    end
-
-
-    def self.char_upcase_impl(args, env)
-      char = get_one_character_arg("char->digit", args, env)
-      find_character_for_chr(char.value.upcase)
-    end
-
-
-    def self.char_downcase_impl(args, env)
-      char = get_one_character_arg("char->digit", args, env)
-      find_character_for_chr(char.value.downcase)
-    end
-
-
-    def self.char_digit_impl(args, env)
-      char = get_one_character_arg("char->digit", args, env)
-      base = if args.length == 1
-               10
-             else
-               b = args.cadr.evaluate(env)
-               return Lisp::Debug.process_error("Base for char->digit has to be an integer", env) unless b.integer?
-               return Lisp::Debug.process_error("Base for char->digit has to be between 2 and 36", env) unless b.value >=2 && b.value <= 36
-               b.value
-             end
-      ch = char.value.upcase
-      value = case ch
-              when /[0-9]/
-                ch[0].ord - 48
-              when /[A-Z]/
-                10 + ch[0].ord - 65
-              else
-                -1
-              end
-      if value == -1
-        Lisp::FALSE
-      elsif value >= base
-        Lisp::FALSE
-      else
-        Lisp::Number.with_value(value)
-      end
-    end
-
-
-    def self.digit_char_impl(args, env)
-      d = args.car.evaluate(env)
-      return Lisp::Debug.process_error("Digit value for digit->char has to be an integer", env) unless d.integer?
-      base = if args.length == 1
-               10
-             else
-               b = args.cadr.evaluate(env)
-               return Lisp::Debug.process_error("Base for char->digit has to be an integer", env) unless b.integer?
-               return Lisp::Debug.process_error("Base for char->digit has to be between 2 and 36", env) unless b.value >=2 && b.value <= 36
-               b.value
-             end
-      val = d.value
-      return Lisp::FALSE if val < 0 || val >= base 
-      find_character_for_chr((((val < 10) ? 48 : 55) + val).chr)
-    end
-
-
-    def self.char_int_impl(args, env)
-      char = get_one_character_arg("char->int", args, env)
-      Lisp::Number.with_value(char.value.ord)
-    end
-
-
-    def self.int_char_impl(args, env)
-      i = args.car.evaluate(env)
-      return Lisp::Debug.process_error("Integer value for int->char has to be an integer", env) unless i.integer?
-      find_character_for_chr(i.value.chr)
-    end
-
-
     def initialize(n)
       @value = n
     end
@@ -289,6 +17,12 @@ module Lisp
       true
     end
 
+    
+    def eqv?(other)
+      return false unless other.character?
+      @value == other.value
+    end
+
 
     def type
       :character
@@ -363,9 +97,14 @@ module Lisp
     @@character_constants["DEL"]       = Lisp::Character.new("\x7F")
 
 
+    def self.character_constants()
+      @@character_constants
+    end
+
+    
     def self.with_value(n)
       if n.length == 1
-        ch = find_character_for_chr(n[0])
+        ch = Lisp::PrimCharacter.find_character_for_chr(n[0])
         return ch unless ch.nil?
         ch = self.new(n[0])
         @@character_constants[n] = ch
@@ -373,9 +112,9 @@ module Lisp
       elsif @@character_constants.has_key?(n)
         @@character_constants[n]
       elsif n[0..1] == "U+"
-        find_character_for_chr(n[2..-1].to_i(16).chr)
+        Lisp::PrimCharacter.find_character_for_chr(n[2..-1].to_i(16).chr)
       else
-        return Lisp::Debug.process_error("Invalid character name: #{n}", env)
+        return Lisp::Debug.process_error("Invalid character name: #{n}", Lisp::EnvironmentFrame.global)
       end
     end
 

data/lib/rubylisp/class_object.rb

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+module Lisp
+
+  class ClassObject < Atom
+
+    def self.new_instance
+      self.new(@value.alloc.init)
+    end
+
+
+    def self.with_class(c)
+      self.new(c)
+    end
+
+    
+    def initialize(c)
+      @value = c
+    end
+
+    
+    def with_value(&block)
+      block.call(@value)
+    end
+
+    
+    def class?
+      true
+    end
+
+    
+    def type
+      :class
+    end
+
+    
+    def native_type
+      @value.class
+    end
+
+    
+    def to_s
+      "<a class: #{@value.name}>"
+    end
+
+    
+    def true?
+      @value != nil
+    end
+
+    
+    def false?
+      @value == nil
+    end
+
+  end
+end