rubylisp 1.0.9 → 1.0.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 19a21b82aeba5d0b46584080bf3625d60fb3b49d
-  data.tar.gz: 009daa5e7fef562898b0bbbe8c06816887c12fb6
+  metadata.gz: fb471b017a46d1820e5e61b82af7ffcbaed45a8e
+  data.tar.gz: ecdfb7e134106b6c9530fde8b03e581ddc8beca9
 SHA512:
-  metadata.gz: cd899d823e85dd7d9a812aca7e8b75b94550c4ee4abc193e881dc17d80a4a410e22cead3a62ec286c4ff4aee28e84ea5bf6633893b52fd8a3ca30f324e4d9cc9
-  data.tar.gz: 821ddee478d4b52f13435e29dbb40705401dfaeb7788ad62fc2fd463a29eb4ad9a2a7db8d9213a523f12175b3e530b0033da9bc622b161edae2cde1946ae928a
+  metadata.gz: d6800eb4f15865974d08a0d45144731fb71db8507a809c083b70fc3af2dae895f28aabe4e087f2d49659411da47da705edf69c86c87c7dcad0a18abb105fd6b6
+  data.tar.gz: b91cf1d11df1da585b78be7ae897afefbe94cad77c355f4535b8c3caf7c715dc5f2e13ba586f67e0e777f191719e5e1aff7b0124eef2b2be4d4e0957085cfbc4

data/bin/rubylisp

@@ -9,7 +9,7 @@ require 'readline/history/restore'
 Lisp::Initializer.register_builtins
 Lisp::Debug.interactive = true
 
-program :version, '0.0.1'
+program :version, '1.0.15'
 program :description, 'A large sub/super-set of MIT/GNU-Scheme implemented in pure Ruby.'
 
 # Smarter Readline to prevent empty and dups
@@ -42,7 +42,7 @@ command :repl do |c|
 
     options.default :file => ""
     puts 'RubyLisp REPL'
-    puts 'Copyright 2014-2015 David R. Astels'
+    puts 'Copyright 2014-2016 David R. Astels'
     puts
     parser = Lisp::Parser.new
     parser.process_file(options.file) if options.file != ""

data/lib/rubylisp/atom.rb

@@ -4,6 +4,10 @@ module Lisp
 
     attr_reader :value
 
+    def set_location(type, package, file, start, length)
+    end
+
+    
     def lisp_object?
       true
     end

data/lib/rubylisp/cons_cell.rb

@@ -4,6 +4,10 @@ module Lisp
     include Enumerable
     attr_reader :car, :cdr
 
+    def set_location(type, package, file, start, length)
+    end
+
+    
     def self.cons(a=nil, b=nil)
       b = nil if b.pair? && b.empty?
       ConsCell.new(a, b)
@@ -220,12 +224,16 @@ module Lisp
       return obj.value
     end
 
+
+    def push_current_code
+      env.push_code(self.print_string)
+    end
     
 
     def inner_eval(env)
       func = @car.evaluate(env)
       return Lisp::Debug.process_error("There is no function or macro named #{@car}", env) if func.nil?
-      env.current_code.unshift(self.print_string()) if !Lisp::Debug.eval_in_debug_repl && Lisp::Debug.interactive
+      push_current_code if !Lisp::Debug.eval_in_debug_repl && Lisp::Debug.interactive
 
       Lisp::Debug.log_eval(self, env)
       
@@ -239,7 +247,7 @@ module Lisp
       end
 
       result = func.apply_to(@cdr, env)
-      env.current_code.shift() if !Lisp::Debug.eval_in_debug_repl && Lisp::Debug.interactive
+      env.pop_code if !Lisp::Debug.eval_in_debug_repl && Lisp::Debug.interactive
       Lisp::Debug.log_result(result, env)
       result
     end

data/lib/rubylisp/environment_frame.rb

@@ -35,6 +35,30 @@ module Lisp
     def has_frame?
       !@frame.nil?
     end
+
+
+    # --------------------------------------------------------------------------------
+    # Exaling code management
+
+    def push_code(code)
+      @current_code.push(code)
+    end
+
+
+    def pop_code
+      @current_code.pop
+    end
+
+
+    def top_code
+      @current_code[-1]
+    end
+
+
+    def has_code?
+      !@current_code.empty?
+    end
+    
     
     # Bindings following parent env frame pointer
 

data/lib/rubylisp/parser.rb

@@ -29,11 +29,13 @@ module Lisp
       Lisp::Character.with_value(ch)
     end
 
-    def parse_cons_cell(tokens)
-      tok, lit = tokens.next_token
+    def parse_cons_cell(start_pos, tokens)
+      pos, tok, lit = tokens.next_token
       if tok == :RPAREN
         tokens.consume_token
-        return Lisp::ConsCell.cons()
+        return Lisp::ConsCell.cons().tap do |obj|
+          obj.set_location(start_pos, pos - start_pos + 1) if @parse_for_debugging
+        end
       end
 
       car = nil
@@ -44,31 +46,39 @@ module Lisp
           tokens.consume_token
           cdr = self.parse_sexpr(tokens)
           return nil if tokens.next_token[0] == :EOF
-          tok, lit = tokens.next_token
+          pos, tok, lit = tokens.next_token
           return Lisp::Debug.process_error("Expected ')' to follow a dotted tail on line #{tokens.line_number}", Lisp::EnvironmentFrame.global) if tok != :RPAREN
           tokens.consume_token
-          return Lisp::ConsCell.array_to_list(cells, cdr)
+          return Lisp::ConsCell.array_to_list(cells, cdr).tap do |obj|
+            obj.set_location(start_pos, pos - start_pos + 1) if @parse_for_debugging
+          end
         else
           car = self.parse_sexpr(tokens)
           return Lisp::Debug.process_error("Unexpected EOF (expected ')') on line #{tokens.line_number}", Lisp::EnvironmentFrame.global) if tokens.next_token[0] == :EOF
           cells << car
         end
-        tok, lit = tokens.next_token
+        pos, tok, lit = tokens.next_token
       end
 
       tokens.consume_token
-      Lisp::ConsCell.array_to_list(cells)
+      Lisp::ConsCell.array_to_list(cells).tap do |obj|
+        obj.set_location(start_pos, pos - start_pos + 1) if @parse_for_debugging
+      end
     end
 
-    def parse_frame(tokens, literal)
+    def parse_frame(start_pos, tokens, literal)
       m = {}
-      tok, lit = tokens.next_token
+      pos, tok, lit = tokens.next_token
       if tok == :RBRACE
         tokens.consume_token
         if literal
-          Lisp::Frame.new
+          Lisp::Frame.new.tap do |obj|
+            obj.set_location(start_pos, pos - start_pos + 1) if @parse_for_debugging
+          end
         else
-          Lisp::ConsCell.cons(Lisp::Symbol.named("make-frame"), nil)
+          Lisp::ConsCell.cons(Lisp::Symbol.named("make-frame"), nil).tap do |obj|
+            obj.set_location(start_pos, pos - start_pos + 1) if @parse_for_debugging
+          end
         end
       else
         cells = []
@@ -76,29 +86,37 @@ module Lisp
           item = self.parse_sexpr(tokens)
           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
+          pos, tok, lit = tokens.next_token
         end
         
         tokens.consume_token
         keys_and_values = Lisp::ConsCell.array_to_list(cells)
         if literal
-          Lisp::PrimFrame.make_frame_impl(keys_and_values, Lisp::EnvironmentFrame.global)
+          Lisp::PrimFrame.make_frame_impl(keys_and_values, Lisp::EnvironmentFrame.global).tap do |obj|
+            obj.set_location(start_pos, pos - start_pos + 1) if @parse_for_debugging
+          end
         else
-          Lisp::ConsCell.cons(Lisp::Symbol.named("make-frame"), keys_and_values)
+          Lisp::ConsCell.cons(Lisp::Symbol.named("make-frame"), keys_and_values).tap do |obj|
+            obj.set_location(start_pos, pos - start_pos + 1) if @parse_for_debugging
+          end
         end
       end
     end
 
 
-    def parse_vector(tokens, literal)
+    def parse_vector(start_pos, tokens, literal)
       v = []
-      tok, lit = tokens.next_token
+      pos, tok, lit = tokens.next_token
       if tok == :RPAREN
         tokens.consume_token
         if literal
-          Lisp::Vector.new
+          Lisp::Vector.new.tap do |obj|
+            obj.set_location(start_pos, pos - start_pos + 1) if @parse_for_debugging
+          end
         else
-          Lisp::ConsCell.cons(Lis::Symbol.named("vector"), nil)
+          Lisp::ConsCell.cons(Lis::Symbol.named("vector"), nil).tap do |obj|
+            obj.set_location(start_pos, pos - start_pos + 1) if @parse_for_debugging
+          end
         end
       else
         cells = []
@@ -106,15 +124,19 @@ module Lisp
           item = self.parse_sexpr(tokens)
           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
+          pos, tok, lit = tokens.next_token
         end
         
         tokens.consume_token
         
         if literal
-          Lisp::Vector.with_array(cells)
+          Lisp::Vector.with_array(cells).tap do |obj|
+            obj.set_location(start_pos, pos - start_pos + 1) if @parse_for_debugging
+          end
         else
-          Lisp::ConsCell.cons(Lisp::Symbol.named("vector"), Lisp::ConsCell.array_to_list(cells))
+          Lisp::ConsCell.cons(Lisp::Symbol.named("vector"), Lisp::ConsCell.array_to_list(cells)).tap do |obj|
+            obj.set_location(start_pos, pos - start_pos + 1) if @parse_for_debugging
+          end
         end
       end
     end
@@ -122,7 +144,7 @@ module Lisp
     
     def parse_sexpr(tokens)
       while true
-        tok, lit = tokens.next_token
+        pos, tok, lit = tokens.next_token
         # puts "token: <#{tok}, #{lit}>"
         return nil if tok == :EOF
         tokens.consume_token
@@ -130,55 +152,95 @@ module Lisp
         when :COMMENT
           next
         when :NUMBER
-          return make_number(lit)
+          return make_number(lit).tap do |obj|
+            obj.set_location(pos, lit.length) if @parse_for_debugging
+          end
         when :FLOAT
-          return make_float(lit)
+          return make_float(lit).tap do |obj|
+            obj.set_location(pos, lit.length) if @parse_for_debugging
+          end
         when :HEXNUMBER
-          return make_hex_number(lit)
+          return make_hex_number(lit).tap do |obj|
+            obj.set_location(pos, lit.length) if @parse_for_debugging
+          end
         when :STRING
-          return make_string(lit)
+          return make_string(lit).tap do |obj|
+            obj.set_location(pos, lit.length) if @parse_for_debugging
+          end
         when :CHARACTER
-          return make_character(lit)
+          return make_character(lit).tap do |obj|
+            obj.set_location(pos, lit.length) if @parse_for_debugging
+          end
         when :LPAREN
-          return parse_cons_cell(tokens)
+          return parse_cons_cell(pos, tokens)
         when :LBRACE
-          return parse_frame(tokens, false)
+          return parse_frame(pos, tokens, false)
         when :QUOTE_LBRACE
-          return parse_frame(tokens, true)
+          return parse_frame(pos, tokens, true)
         when :HASH_LPAREN
-          return parse_vector(tokens, false)
+          return parse_vector(pos, tokens, false)
         when :QUOTE_HASH_LPAREN
-          return parse_vector(tokens, true)
+          return parse_vector(pos, tokens, true)
         when :SYMBOL
-          return make_symbol(lit)
+          return make_symbol(lit).tap do |obj|
+            obj.set_location(pos, lit.length) if @parse_for_debugging
+          end
         when :FFI_NEW_SYMBOL
-          return Lisp::FfiNew.new(lit)
+          return Lisp::FfiNew.new(lit).tap do |obj|
+            obj.set_location(pos, lit.length) if @parse_for_debugging
+          end
         when :FFI_SEND_SYMBOL
-          return Lisp::FfiSend.new(lit)
+          return Lisp::FfiSend.new(lit).tap do |obj|
+            obj.set_location(pos, lit.length) if @parse_for_debugging
+          end
         when :FFI_STATIC_SYMBOL
-          return Lisp::FfiStatic.new(lit)
+          return Lisp::FfiStatic.new(lit).tap do |obj|
+        obj.set_location(pos, lit.length) if @parse_for_debugging
+          end
         when :FALSE
-          return Lisp::FALSE
+          if @parse_for_debugging
+            return Lisp::Boolean.with_value(false).tap do |obj|
+              obj.set_location(pos, 2) if @parse_for_debugging
+            end
+          else
+            return Lisp::FALSE
+          end
         when :TRUE
-          return Lisp::TRUE
+          if @parse_for_debugging
+            return Lisp::Boolean.with_value(false).tap do |obj|
+              obj.set_location(pos, 2) if @parse_for_debugging
+            end
+          else
+            return Lisp::TRUE
+          end
         when :QUOTE
           expr = parse_sexpr(tokens)
-          return Lisp::ConsCell.array_to_list([Lisp::Symbol.named('quote'), expr])
+          return Lisp::ConsCell.array_to_list([Lisp::Symbol.named('quote'), expr]).tap do |obj|
+            obj.set_location(pos, expr.src_length + 1) if @parse_for_debugging
+          end
         when :BACKQUOTE
           expr = parse_sexpr(tokens)
-          return Lisp::ConsCell.array_to_list([Lisp::Symbol.named('quasiquote'), expr])
+          return Lisp::ConsCell.array_to_list([Lisp::Symbol.named('quasiquote'), expr]).tap do |obj|
+            obj.set_location(pos, expr.src_length + 1) if @parse_for_debugging
+          end
         when :COMMA
           expr = parse_sexpr(tokens)
-          return Lisp::ConsCell.array_to_list([Lisp::Symbol.named('unquote'), expr])
+          return Lisp::ConsCell.array_to_list([Lisp::Symbol.named('unquote'), expr]).tap do |obj|
+            obj.set_location(pos, expr.src_length + 1) if @parse_for_debugging
+          end
         when :COMMAAT
           expr = parse_sexpr(tokens)
-          return Lisp::ConsCell.array_to_list([Lisp::Symbol.named('unquote-splicing'), expr])
+          return Lisp::ConsCell.array_to_list([Lisp::Symbol.named('unquote-splicing'), expr]).tap do |obj|
+            obj.set_location(pos, expr.src_length + 2) if @parse_for_debugging
+          end
         when :WHITESPACE
           next
         when :ILLEGAL
           return Lisp::Debug.process_error("Illegal token: #{lit} on line #{tokens.line_number}", Lisp::EnvironmentFrame.global)
         else
-          return make_symbol(lit)
+          return make_symbol(lit).tap do |obj|
+            obj.set_location(pos, lit.length) if @parse_for_debugging
+          end
         end
       end
     end

data/lib/rubylisp/prim_io.rb

@@ -22,6 +22,11 @@ module Lisp
    end
 
 
+    def self.output_to_stdout(to_output)
+      $stdout.write(to_output)
+    end
+      
+
     def self.load_impl(args, env)
       fname = args.car
       return Lisp::Debug.process_error("'load' requires a string argument.", env) unless fname.string?
@@ -64,11 +69,11 @@ module Lisp
         p = args.cadr
         return Lisp::Debug.process_error("'write-string' requires a port as it's second argument.", env) unless p.port?
         port = p.value
+        port.write(s.value)
       else
-        port = $stdout
+        self.output_to_stdout(s.value)
       end
-
-      port.write(s.value)
+      Lisp::String.with_value("OK")
     end
 
     
@@ -77,11 +82,11 @@ module Lisp
         p = args.car
         return Lisp::Debug.process_error("'newline' requires a port as it's argument.", env) unless p.port?
         port = p.value
+        port.write("\n")
       else
-        port = $stdout
+        self.output_to_stdout("\n")
       end
-
-      port.write("\n")
+      Lisp::String.with_value("OK")
     end
 
     
@@ -90,11 +95,11 @@ module Lisp
         p = args.cadr
         return Lisp::Debug.process_error("'write' requires a port as it's second argument.", env) unless p.port?
         port = p.value
+        port.write(args.car.print_string)
       else
-        port = $stdout
+        self.output_to_stdout(args.car.print_string)
       end
-
-      port.write(args.car.print_string)
+      Lisp::String.with_value("OK")
     end
 
     
@@ -209,8 +214,10 @@ module Lisp
 
       if destination.port?
         destination.value.write(combined_string)
+        Lisp::String.with_value("OK")
       elsif destination.value
-        $stdout.write(combined_string)
+        self.output_to_stdout(combined_string)
+        Lisp::String.with_value("OK")
       else
         return Lisp::String.with_value(combined_string)
       end

data/lib/rubylisp/prim_system.rb

@@ -3,6 +3,7 @@ module Lisp
   class PrimSystem
 
     def self.register
+      Primitive.register("load-ruby", "1") {|args, env| Lisp::PrimSystem.load_ruby_impl(args, env) }
       Primitive.register("sleep", "1") {|args, env| Lisp::PrimSystem.sleep_impl(args, env) }
       Primitive.register("time", "1", "", true)  {|args, env| Lisp::PrimSystem.time_impl(args, env) }
       Primitive.register("quit", "0")  {|args, env| exit() }
@@ -11,6 +12,14 @@ module Lisp
     end
 
     
+    def self.load_ruby_impl(args, env)
+      arg = args.car
+      return Lisp::Debug.process_error("load-ruby needs a string argument", env) unless arg.string?
+      load(arg.value)
+      Lisp::TRUE
+    end
+
+    
     def self.sleep_impl(args, env)
       arg = args.car
       return Lisp::Debug.process_error("sleep needs a numeric argument", env) unless arg.number?

data/lib/rubylisp/symbol.rb

@@ -38,6 +38,7 @@ module Lisp
     end
 
     def evaluate(env)
+      super
       return self if @naked
       env.value_of(self)
     end

data/lib/rubylisp/tokenizer.rb

@@ -15,6 +15,7 @@ module Lisp
     def initialize(src, absorb_space=true)
       @absorb_whitespace = absorb_space
       @source = src
+      @position = 0
       @lookahead_token = nil
       @lookahead_literal = ''
       @eof = false
@@ -51,7 +52,7 @@ module Lisp
     end
     
     def next_token
-      return @lookahead_token, @lookahead_literal
+      return @position, @lookahead_token, @lookahead_literal
     end
 
     def eof?
@@ -214,6 +215,7 @@ module Lisp
         while space?(@current_ch)
           @line_number += 1 if @current_ch == "\n"
           advance
+          @position = @source.pos
           return :EOF, '' if eof?
         end
       end
@@ -309,6 +311,7 @@ module Lisp
     end
 
     def consume_token
+      @position = @source.pos
       @lookahead_token, @lookahead_literal = self.read_next_token
       consume_token if @lookahead_token == :COMMENT
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubylisp
 version: !ruby/object:Gem::Version
-  version: 1.0.9
+  version: 1.0.15
 platform: ruby
 authors:
 - Dave Astels
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-14 00:00:00.000000000 Z
+date: 2016-04-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: commander