rubymotionlisp 1.0.13 → 1.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 39e0ad7494d397d7b81efa7a7944b2f5a9e67af9
-  data.tar.gz: fa4a9db073a2a8980aa656214053471f70fa3237
+  metadata.gz: 5de6ce4210bcf029285a399dcdcbfcbfb9e694b0
+  data.tar.gz: aa4cf373497533635555b76d401d197dad8ab060
 SHA512:
-  metadata.gz: b1e5b6777151826297e368fc1e0d0f86017f96f9d1b9d422883eb20994d3f3e8eab46cd05f0efbe48da7bea8de81795a7f9720a4081b70789fe955b1520d566c
-  data.tar.gz: f7af412d0764290c28eb36e3b74c717db63cf148b7c203ed7a6caf27f196b11b36585e7c9773098eaaa81d528ffbd7d9a6585b46738398cb929a0f77d7d3f296
+  metadata.gz: ad066de387e6c61c70e5b27e3022f4690a6673aba8bc42f8323618d2d6b6f7f423fdc8b244973bc06d8528a29e6670ee8544c2b3f6a72f924f39213f081272c8
+  data.tar.gz: d7b568d0fdbc79539e9dbc91c380a4defd3e5bef226a2433728519c4f1702d77f5d7ead5b6c12d78796717b1f5fae95067cd1d51259c0ac6ebcc00950e552d3d

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)
@@ -17,6 +21,197 @@ module Lisp
     def value
       self
     end
+    
+    def set_car!(d)
+      @car = d
+    end
+
+    def lisp_object?
+      true
+    end
+    
+    def set_cdr!(d)
+      @cdr = d
+    end
+
+
+    def set_nth!(n, d)
+      return nil if empty?
+      c = self
+      n.times {|i| c = c.cdr}
+      c.set_car!(d)
+    end
+
+    
+    def empty?
+      @car.nil? && @cdr.nil?
+    end
+
+    def string?
+      false
+    end
+
+    def character?
+      false
+    end
+
+    def number?
+      false
+    end
+
+    def positive?
+      false
+    end
+
+    def zero?
+      false
+    end
+
+    def negative?
+      false
+    end
+
+    def symbol?
+      false
+    end
+
+    def primitive?
+      false
+    end
+
+    def special?
+      false
+    end
+
+    def function?
+      false
+    end
+
+    def macro?
+      false
+    end
+
+    def pair?
+      true
+    end
+
+    def list?
+      true
+    end
+
+    def frame?
+      false
+    end
+
+    def vector?
+      false
+    end
+
+    def eq?(other)
+      return true if empty? && (other.nil? || (other.pair? && other.empty?))
+      other.pair? && self == other
+    end
+
+    def eqv?(other)
+      return true if empty? && (other.nil? || (other.pair? && other.empty?))
+      other.pair? && self == other
+    end
+    
+    def equal?(other)
+      return true if empty? && (other.nil? || (other.pair? && other.empty?))
+      return false unless other.pair?
+      @car.equal?(other.car) && @cdr.equal?(other.cdr)
+    end
+    
+    def type
+      :pair
+    end
+
+    def to_s_helper
+      return "#{@car.to_s}" if @cdr.nil?
+      return "#{@car.to_s} . #{@cdr.to_s}" unless @cdr.pair?
+      "#{@car.to_s} #{@cdr.to_s_helper}"
+    end
+
+    def to_s
+      return "()" if self.empty?
+      return "'#{@cdr.car.to_s}" if @car.symbol? && @car.name == "quote"
+      return "{#{@cdr.to_s_helper}}" if @car.symbol? && @car.name == "make-frame"
+      return "#(#{@cdr.to_s_helper})" if @car.symbol? && @car.name == "make-vector"
+      return "(#{@car.to_s} . #{@cdr.to_s})" if !@cdr.nil? && !@cdr.pair?
+      return "(#{self.to_s_helper})"
+    end
+
+    def print_string_helper
+      @cdr.nil? ? "#{@car.print_string}" : "#{@car.print_string} #{@cdr.print_string_helper}"
+    end
+
+    def print_string
+      return "()" if self.empty?
+      return "'#{@cdr.car.print_string}" if @car.symbol? && @car.name == "quote"
+      return "{#{@cdr.print_string_helper}}" if @car.symbol? && @car.name == "make-frame"
+      return "#(#{@cdr.print_string_helper})" if @car.symbol? && @car.name == "make-vector"
+      return "(#{@car.print_string} . #{@cdr.print_string})" if !@cdr.nil? && !@cdr.pair?
+      return "(#{self.print_string_helper})"
+    end
+
+    def to_a
+      a = []
+      return a if empty?
+      c = self
+      until c.nil?
+        a << c.car
+        c = c.cdr
+      end
+      a
+    end
+
+    def each &block
+      return if empty?
+      c = self
+      if self.length > 0
+        until c.nil?
+          yield c.car 
+          c = c.cdr
+        end
+      end
+    end
+
+    def self.array_to_list(cells, tail=nil)
+      return cons() if cells.empty? && tail.nil?
+      head = ConsCell.new
+      last_cell = head
+      (0...cells.length).each do |i|
+        new_cell = self.cons(cells[i], nil)
+        last_cell.set_cdr!(new_cell)
+        last_cell = new_cell
+      end
+      last_cell.set_cdr!(tail)
+      head.cdr
+    end
+
+    def traverse(path)
+      next_cell = self
+      path.chars.each do |p|
+        return nil if next_cell.nil?  || !next_cell.pair?
+        next_cell = ((p == ?a) ? next_cell.car : next_cell.cdr)
+      end
+      next_cell
+    end
+
+    def method_missing(name, *args, &block)
+      if name[0] == ?c && name[-1] == ?r && (name[1..-2].chars.all? {|e| "ad".include?(e)})
+        self.traverse(name[1..-2].reverse)
+      else
+        super
+      end
+    end
+
+    def nth(n)
+      c = self
+      n.times {|i| c = c.cdr}
+      c.car
+    end
 
     def nth_tail(n)
       c = self

data/lib/rubylisp/parser.rb

@@ -5,47 +5,37 @@ module Lisp
     def initialize
     end
 
-    def make_number(str, pos)
-      Lisp::Number.with_value(str.to_i).tap do |obj|
-        obj.set_location(pos, str.length)
-      end
+    def make_number(str)
+      Lisp::Number.with_value(str.to_i)
     end
 
     def make_hex_number(str)
-      Lisp::Number.with_value(["0x", str].join.to_i(0)).tap do |obj|
-        obj.set_location(pos, str.length)
-      end
+      Lisp::Number.with_value(["0x", str].join.to_i(0))
     end
 
     def make_float(str)
-      Lisp::Number.with_value(str.to_f).tap do |obj|
-        obj.set_location(pos, str.length)
-      end
+      Lisp::Number.with_value(str.to_f)
     end
 
     def make_string(str)
-      Lisp::String.with_value(str).tap do |obj|
-        obj.set_location(pos, str.length)
-      end
+      Lisp::String.with_value(str)
     end
 
     def make_symbol(str)
-      Lisp::Symbol.named(str).tap do |obj|
-        obj.set_location(pos, str.length)
-      end
+      Lisp::Symbol.named(str)
     end
 
     def make_character(ch)
-      Lisp::Character.with_value(ch).tap do |obj|
-        obj.set_location(pos, str.length)
-      end
+      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
@@ -56,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 = []
@@ -88,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 = []
@@ -118,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
@@ -134,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
@@ -162,15 +172,15 @@ module Lisp
             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).tap do |obj|
             obj.set_location(pos, lit.length) if @parse_for_debugging

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
@@ -112,7 +113,7 @@ module Lisp
       end
 
       tok ||= :SYMBOL
-      return @position, tok, case tok
+      return tok, case tok
                   when :SYMBOL, :FFI_STATIC_SYMBOL
                     lit
                   when :FFI_SEND_SYMBOL
@@ -143,7 +144,7 @@ module Lisp
               :NUMBER
             end
 
-      return @position, tok, lit
+      return tok, lit
     end
 
 
@@ -183,9 +184,9 @@ module Lisp
         advance
       end
 
-      return @position, :EOF, '' if eof?
+      return :EOF, '' if eof?
       advance
-      return @position, :STRING, process_escapes(lit)
+      return :STRING, process_escapes(lit)
     end
 
 
@@ -203,27 +204,26 @@ module Lisp
         advance
       end
 
-      return @position, :CHARACTER, lit
+      return :CHARACTER, lit
     end
 
 
     def read_next_token
-      @position = @source.pos
-      
-      return @position, :EOF, '' if eof?
+      return :EOF, '' if eof?
 
       if @absorb_whitespace
         while space?(@current_ch)
           @line_number += 1 if @current_ch == "\n"
           advance
-          return @position, :EOF, '' if eof?
+          @position = @source.pos
+          return :EOF, '' if eof?
         end
       end
       
       if !@absorb_whitespace && space?(@current_ch)
         @line_number += 1 if @current_ch == "\n"
         advance
-        return @position, :WHITESPACE, " "
+        return :WHITESPACE, " "
       elsif number?(@current_ch)
         return read_number(false)
       elsif @current_ch == '-' && number?(@next_ch)
@@ -242,50 +242,50 @@ module Lisp
       elsif @current_ch == '\'' && @next_ch == '{'
         advance
         advance
-        return @position, :QUOTE_LBRACE, "'{"
+        return :QUOTE_LBRACE, "'{"
       elsif @current_ch == '\'' && @next_ch == '#' && @next_next_ch == '('
         advance
         advance
         advance
-        return @position, :QUOTE_HASH_LPAREN, "'#("
+        return :QUOTE_HASH_LPAREN, "'#("
       elsif @current_ch == '\''
         advance
-        return @position, :QUOTE, "'"
+        return :QUOTE, "'"
       elsif @current_ch == '`'
         advance
-        return @position, :BACKQUOTE, "`"
+        return :BACKQUOTE, "`"
       elsif @current_ch == ',' && @next_ch == '@'
         advance
         advance
-        return @position, :COMMAAT, ",@"
+        return :COMMAAT, ",@"
       elsif @current_ch == ','
         advance
-        return @position, :COMMA, ","
+        return :COMMA, ","
       elsif @current_ch == '('
         advance
-        return @position, :LPAREN, "("
+        return :LPAREN, "("
       elsif @current_ch == '#' && @next_ch == '('
         advance
         advance
-        return @position, :HASH_LPAREN, "#("
+        return :HASH_LPAREN, "#("
       elsif @current_ch == ')'
         advance
-        return @position, :@position, RPAREN, ")"
+        return :RPAREN, ")"
       elsif @current_ch == '{'
         advance
-        regturn @position, :LBRACE, "{"
+        return :LBRACE, "{"
       elsif @current_ch == '}'
         advance
-        return @position, :RBRACE, "}"
+        return :RBRACE, "}"
       elsif @current_ch == '['
         advance
-        return @position, :LBRACKET, "["
+        return :LBRACKET, "["
       elsif @current_ch == ']'
         advance
-        return @position, :RBRACKET, "]"
+        return :RBRACKET, "]"
       elsif @current_ch == '.' && space?(@next_ch)
         advance
-        return @position, :PERIOD, "."
+        return :PERIOD, "."
       elsif @current_ch == '.' && symbol_character?(@next_ch)
         return read_symbol
         elsif symbol_character?(@current_ch)
@@ -293,24 +293,25 @@ module Lisp
         elsif @current_ch == '#' && @next_ch == 't'
         advance
         advance
-        return @position, :TRUE, "#t"
+        return :TRUE, "#t"
       elsif @current_ch == '#' && @next_ch == 'f'
         advance
         advance
-        return @position, :FALSE, "#f"
+        return :FALSE, "#f"
       elsif @current_ch == ';'
         lit = ""
         while true
-          return @position, :COMMENT, lit if eof? || @current_ch == "\n"
+          return :COMMENT, lit if eof? || @current_ch == "\n"
           lit << @current_ch
           advance
         end
       else
-        return @position, :ILLEGAL, @current_ch
+        return :ILLEGAL, @current_ch
       end
     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: rubymotionlisp
 version: !ruby/object:Gem::Version
-  version: 1.0.13
+  version: 1.0.14
 platform: ruby
 authors:
 - Dave Astels
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-12 00:00:00.000000000 Z
+date: 2016-03-13 00:00:00.000000000 Z
 dependencies: []
 description: An embeddable Lisp as an extension language for RubyMotion
 email: dastels@icloud.com