risp 0.0.1

data/README

@@ -0,0 +1,65 @@
+= Risp
+
+Risp (Ruby lisp) is a quite tiny, toy interpreter of lisp.
+
+For almost people, it seems not to be appropriate Lisp --
+it lacks even a macro!!
+
+Features: variables are bound to Lisp-1 namespace, there's no
+special-form which is appropriate `defun'. It means a scheme's
+way is invalid. Please use lambda.
+
+ (define (hoge x) ;; raise type error for list
+   (+ x 1))
+
+There's no package system, macro and beautiful API.
+
+
++ Types
+ * integer
+ * string
+ * t
+ * nil
+ * symbol
+ * list
+ * function
+
++ Builtin functions and special-forms
+ * car
+ * cdr
+ * cons
+ * eq
+ * atom
+ * quote
+ * cond
+ * define
+ * lambda
+ * +
+
+
+= Install
+
+ $ gem install risp
+
+
+= Usage
+
+ $ risp somefile.l 
+
+ $ risp -i
+
+
+= Dependence 
+
+Risp is developed on:
+ ruby 1.9.1p429 (2010-07-02 revision 28523) [i386-mswin32]
+
+
+= Lisence 
+
+Under the modified BSD lisence.
+  
+
+---
+
+arikui <arikui.ruby@gmail.com>

data/Rakefile

@@ -0,0 +1,65 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/testtask'
+require_relative 'lib/risp'
+
+LIBS    = FileList["lib/*.rb"]
+TESTS   = FileList["test/test_*.rb"]
+
+task :default => :test
+
+gemspec = Gem::Specification.new do |s|
+  s.name = %q{risp}
+  s.version = Risp.version
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["arikui"]
+  s.date = %q{2010-11-19}
+  s.description = %q{A toy lisp interpreter.}
+  s.email = %q{arikui.ruby@gmail.com}
+  s.executable = 'risp'
+  s.extra_rdoc_files = ["README"]
+  s.files = ["README",
+             "Rakefile",
+             "bin/risp",
+             *TESTS, *LIBS]
+  s.homepage = %q{http://wiki.github.com/arikui1911/risp}
+  s.rdoc_options = ["--title", "risp documentation",
+                    "--charset", "utf-8",
+                    "--opname", "index.html",
+                    "--line-numbers",
+                    "--main", "README",
+                    "--inline-source",
+                    "--exclude", "^(examples|extras)/"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{risp}
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{A toy lisp interpreter; provides `pure-lisp' functions and Lisp-1 namespaces. Currently it lacks package system and macro(!!).}
+  s.test_files = TESTS.to_a
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+
+gem_task = Rake::GemPackageTask.new(gemspec)
+gem_task.define
+
+desc "Upload the gem file #{gem_task.gem_file}"
+task 'cutter' => 'gem' do |t|
+  gem "push #{gem_task.package_dir}/#{gem_task.gem_file}"
+end
+
+Rake::TestTask.new do |t|
+  t.warning = true
+end
+
+Rake::RDocTask.new do |t|
+  t.rdoc_dir = 'doc'
+  t.rdoc_files = LIBS.include("README")
+  t.options.push '-S', '-N'
+end

data/bin/risp

@@ -0,0 +1,79 @@
+#!/usr/bin/env ruby
+
+# Copyright (c) 2010, arikui
+# All rights reserved.
+
+# Redistribution and use in source and binary forms, with or
+# without modification, are permitted provided that the
+# following conditions are met:
+
+# * Redistributions of source code must retain the above
+#   copyright notice, this list of conditions and the
+#   following disclaimer.
+# * Redistributions in binary form must reproduce the above
+#   copyright notice, this list of conditions and the following
+#   disclaimer in the documentation and/or other materials
+#   provided with the distribution.
+# * Neither the name of the arikui-risp nor the names of its
+#   contributors may be used to endorse or promote products
+#   derived from this software without specific prior written
+#   permission.
+
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+# CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+# EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+require 'risp'
+require 'optparse'
+
+Version = Risp.version
+interactive_p = false
+
+ARGV.options do |o|
+  o.banner = "Usage: #{o.program_name} [-options] [source-file]"
+  o.on '-i', '--interactive', 'turn on interactive mode' do
+    interactive_p = true
+  end
+end
+
+def with_input(file, &block)
+  file ? File.open(file, &block) : yield($stdin)
+end
+
+ARGV.parse!
+
+source = interactive_p ? nil : ARGV.shift
+interpreter = Risp::Interpreter.new
+
+with_input(source) do |f|
+  reader = Risp::Reader.new(f)
+  loop do
+    begin
+      if interactive_p
+        print "Risp> "
+        sexp = reader.read
+        break if sexp.serialize == 'QUIT' || reader.eof?
+        r = sexp.evaluate(interpreter)
+        r.print($stdout)
+        puts
+      else
+        break if reader.eof?
+        sexp = reader.read
+        sexp.evaluate(interpreter)        
+      end
+    rescue Risp::RuntimeError, Risp::ReadError => ex
+      $stderr.puts ex.message
+      exit 1 unless interactive_p
+    end
+  end
+end

data/lib/risp.rb

@@ -0,0 +1,522 @@
+# Copyright (c) 2010, arikui
+# All rights reserved.
+
+# Redistribution and use in source and binary forms, with or
+# without modification, are permitted provided that the
+# following conditions are met:
+
+# * Redistributions of source code must retain the above
+#   copyright notice, this list of conditions and the
+#   following disclaimer.
+# * Redistributions in binary form must reproduce the above
+#   copyright notice, this list of conditions and the following
+#   disclaimer in the documentation and/or other materials
+#   provided with the distribution.
+# * Neither the name of the arikui-risp nor the names of its
+#   contributors may be used to endorse or promote products
+#   derived from this software without specific prior written
+#   permission.
+
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+# CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+# EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+require 'singleton'
+
+module Risp
+  VERSION = '0.0.1'
+
+  def self.version
+    VERSION
+  end
+
+  class ReadError < RuntimeError ; end
+
+  class Reader
+    def initialize(f, filename = '-', lineno = 1)
+      @f = f
+      @filename = filename
+      @lineno = lineno
+      @read_table = {}
+      DEFAULT_READ_TABLE.each do |char, m|
+        @read_table[char] = method(m)
+      end
+      @read_table.default = method(DEFAULT_READ_TABLE.default)
+    end
+
+    def read
+      get_sexp()
+    end
+    
+    def eof?
+      @f.eof?
+    end
+
+    private
+
+    def getc
+      c = @f.getc
+      @lineno += 1 if c == "\n"
+      c
+    end
+
+    def error(msg)
+      raise ReadError, "#{@filename}:#{@lineno}: #{msg}"
+    end
+
+    DEFAULT_READ_TABLE = {
+      '(' => :get_list,
+      "'" => :get_quote,
+      '"' => :get_string,
+    }
+    DEFAULT_READ_TABLE.default = :get_number_or_symbol
+
+    def get_sexp
+      while ch = getc()
+        func = @read_table.fetch(ch, nil) and return func.call(ch)
+        /\A[\s\n]/ =~ ch or return @read_table.default.call(ch)
+      end
+      Nil.instance
+    end
+
+    def skip_spaces
+      while ch = getc()
+        break unless /\A[\s\n]/ =~ ch
+      end
+      ch
+    end
+
+    def get_list(lparen)
+      ch = skip_spaces()
+      error "Un-closed list, missing right paren before EOF" unless ch
+      return Nil.instance if ')' == ch
+      @f.ungetc ch
+      top = list = List.new
+      loop do
+        list.car = get_sexp()
+        ch = skip_spaces()
+        error"Un-closed list, missing right paren before EOF" unless ch
+        case ch
+        when ')' then break
+        when '.'
+          list.cdr = get_sexp()
+          ch = skip_spaces()
+          error "Un-closed list, missing right paren before EOF" unless ch
+          error "Not-right paren token follows after dot-pair." unless ch == ')'
+          return top
+        else
+          @f.ungetc ch
+          list.cdr = List.new
+          list = list.cdr
+        end
+      end
+      top
+    end
+
+    def get_quote(q)
+      list = List.new
+      list.car = Symbol.new('quote')
+      list.cdr = List.new
+      list.cdr.car = get_sexp()
+      list
+    end
+
+    ESC_SEQ_TABLE = {
+      '"' => '"',
+      'n' => "\n",
+      't' => "\t",
+    }
+
+    def get_string(dq)
+      buf = ''
+      quoted = false
+      while ch = getc()
+        if quoted
+          seq = ESC_SEQ_TABLE[ch] and buf << seq
+          quoted = false
+        else
+          case ch
+          when '"' then break
+          when '\\' then quoted = true
+          else buf << ch
+          end
+        end
+      end
+      error "Un-closed string, missing later double quote." unless ch
+      String.new(buf)
+    end
+
+    def get_number_or_symbol(char)
+      token = char.dup
+      while ch = getc()
+        case ch
+        when /\A[\s\n]/ then break
+        when '(', ')'
+          @f.ungetc ch
+          break
+        end
+        token << ch
+      end
+      case token
+      when /\A\d+\Z/ then Integer.new(Kernel.Integer(token))
+      when 't' then T.instance
+      when 'nil' then Nil.instance
+      else Symbol.new(token)
+      end
+    end
+  end
+
+  module Sexp
+    def function?
+      false
+    end
+
+    def symbol?
+      false
+    end
+    
+    def atom?
+      false
+    end
+  end
+  
+  class Cell
+    include Sexp
+
+    def initialize
+      self.car = Nil.instance
+      self.cdr = Nil.instance
+    end
+
+    attr_accessor :car
+    attr_accessor :cdr
+  end
+
+  class List < Cell
+    def print(f)
+      f.print '('
+      print_inner(f, [self])
+      f.print ')'
+    end
+
+    def print_inner(f, appreaed_list)
+      car.print(f)
+      case cdr
+      when Nil
+        ;
+      when List
+        f.print ' '
+        if appreaed_list.any?{|x| x.equal?(cdr) }
+          f.print '...'
+        else
+          appreaed_list << cdr
+          cdr.print_inner(f, appreaed_list)
+        end
+      else
+        f.print ' . '
+        cdr.print(f)
+      end
+    end
+
+    def serialize
+      inspect
+    end
+
+    def evaluate(intp)
+      operator = car.evaluate(intp)
+      intp.apply(operator, cdr)
+    end
+
+    def to_a
+      ret = []
+      to_a_main ret, self
+      ret
+    end
+
+    def to_a_main(buf, lst)
+      unless lst == Nil.instance
+        buf << lst.car
+        to_a_main(buf, lst.cdr)
+      end
+    end
+
+    def length
+      length_main self
+    end
+
+    private
+
+    def length_main(lst)
+      lst == Nil.instance ? 0 : 1 + length_main(lst.cdr)
+    end
+  end
+
+  class Nil
+    include Sexp
+    include Singleton
+
+    def print(f)
+      f.print "NIL"
+    end
+
+    def serialize
+      "NIL"
+    end
+
+    def evaluate(intp)
+      self
+    end
+
+    def to_a
+      []
+    end
+    
+    def atom?
+      true
+    end
+  end
+
+  class Atom
+    include Sexp
+    
+    def atom?
+      true
+    end
+  end
+
+  class T < Atom
+    include Singleton
+
+    def print(f)
+      f.print "T"
+    end
+
+    def serialize
+      "T"
+    end
+
+    def evaluate(intp)
+      self
+    end
+  end
+
+  class Symbol < Atom
+    CACHE = {}
+
+    def self.new(name)
+      CACHE[name] ||= super(name)
+    end
+
+    def initialize(name)
+      @name = name
+    end
+
+    attr_reader :name
+
+    def print(f)
+      f.print serialize()
+    end
+
+    def serialize
+      name.upcase
+    end
+
+    def evaluate(intp)
+      intp.symbol_value(self)
+    end
+
+    def symbol?
+      true
+    end
+  end
+
+  class Number < Atom
+  end
+
+  class Integer < Number
+    def initialize(n)
+      @value = n
+    end
+
+    attr_reader :value
+
+    def print(f)
+      f.print serialize()
+    end
+
+    def serialize
+      value.to_s
+    end
+
+    def evaluate(intp)
+      self
+    end
+
+    def +(other)
+      Integer.new(self.value + other.value)
+    end
+  end
+
+  class String < Atom
+    def initialize(value)
+      @value = value
+    end
+
+    attr_reader :value
+
+    def print(f)
+      f.print serialize()
+    end
+
+    def serialize
+      value
+    end
+
+    def evaluate(intp)
+      self
+    end
+  end
+
+  class NativeFunction < Atom
+    def function?
+      true
+    end
+
+    def initialize(arity = nil, &body)
+      @arity = arity
+      @body  = body
+    end
+
+    def print(f)
+      f.print serialize
+    end
+
+    def serialize
+      "#{inspect.split(/\s+/)[0]}>"
+    end
+
+    def call(intp, args)
+      args = args.to_a
+      if @arity && @arity != args.size
+        raise RuntimeError, "wrong number of arguments (#{args.size} for #{@arity})"
+      end
+      @body.call(*args)
+    end
+  end
+
+  class Function < Atom
+    def function?
+      true
+    end
+
+    def initialize(params, body)
+      @params = params.to_a
+      @body = body
+    end
+
+    def print(f)
+      f.print serialize
+    end
+
+    def serialize
+      "#{inspect.split(/\s+/)[0]}>"
+    end
+
+    def call(intp, args)
+      args = args.to_a
+      unless @params.size == args.size
+        raise RuntimeError, "wrong number of arguments (#{args.size} for #{@params.size})"
+      end
+      ret = nil
+      intp.local_environment(@params.zip(args)) do
+        @body.each{|s| ret = s.evaluate(intp) }
+      end
+      ret
+    end
+  end
+
+  class RuntimeError < ::RuntimeError ; end
+
+  class Interpreter
+    def initialize
+      @specials = {}
+      @frames = []
+      @specials[Symbol.new('car')] = NativeFunction.new(1){|list|
+        list.evaluate(self).car
+      }
+      @specials[Symbol.new('cdr')] = NativeFunction.new(1){|list|
+        list.evaluate(self).cdr
+      }
+      @specials[Symbol.new('cons')] = NativeFunction.new(2){|car, cdr|
+        list = List.new
+        list.car = car.evaluate(self)
+        list.cdr = cdr.evaluate(self)
+        list
+      }
+      @specials[Symbol.new('eq')] = NativeFunction.new(2){|x, y|
+        x.evaluate(self).equal?(y.evaluate(self)) ? T.instance : Nil.instance
+      }
+      @specials[Symbol.new('atom')] = NativeFunction.new(1){|sexp|
+        sexp.evaluate(self).atom? ? T.instance : Nil.instance
+      }
+      @specials[Symbol.new('quote')] = NativeFunction.new(1){|sexp|
+        sexp
+      }
+      @specials[Symbol.new('cond')] = NativeFunction.new{|*forms|
+        result = forms.each{|form|
+          test, *body = form.to_a
+          if test.evaluate(self) == T.instance
+            ret = nil
+            body.each{|s| ret = s.evaluate(self) }
+            break ret
+          end
+        }
+        result.equal?(forms) ? Nil.instance : result
+      }
+      @specials[Symbol.new('define')] = NativeFunction.new(2){|bindee, value|
+        case
+        when bindee.symbol?
+          (@frames.last || @specials)[bindee] = value.evaluate(self)
+        else
+          raise RuntimeError, "#{bindee.serialize} is not a symbol."
+        end
+      }
+      @specials[Symbol.new('lambda')] = NativeFunction.new{|params, *body|
+        Function.new(params, body)
+      }
+      @specials[Symbol.new('+')] = NativeFunction.new{|*args|
+        args.map{|arg| arg.evaluate(self) }.inject(Integer.new(0), :+)
+      }
+    end
+
+    def local_environment(alist)
+      f = alist.each_with_object({}){|(sym, val), h| h[sym] = val }
+      @frames.push f
+      ret = yield
+      @frames.pop
+      ret
+    end
+
+    def symbol_value(sym)
+      @frames.reverse_each do |frame|
+        v = frame[sym] and return v
+      end
+      @specials[sym] or raise RuntimeError, "unbound variable - `#{sym.name}'"
+    end
+
+    def apply(function, args)
+      raise RuntimeError, "not a function - #{function}" unless function.function?
+      function.call(self, args)
+    end
+  end
+end

data/test/test_risp_reader.rb

@@ -0,0 +1,25 @@
+require 'expectations'
+require 'stringio'
+require 'risp'
+
+Expectations do
+  expect Risp::Integer do
+    Risp::Reader.new(StringIO.new("123")).read
+  end
+
+  expect 123 do
+    Risp::Reader.new(StringIO.new("123")).read.value
+  end
+end
+
+
+__END__
+require 'test/unit'
+require 'stringio'
+
+class TestRispReader < Test::Unit::TestCase
+  def test_integer
+    sexp = Risp::Reader.new(StringIO.new("123")).read
+    assert_kind_of Risp::Integer, sexp
+  end
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: risp
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- arikui
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-19 00:00:00 +09:00
+default_executable: 
+dependencies: []
+
+description: A toy lisp interpreter.
+email: arikui.ruby@gmail.com
+executables: 
+- risp
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- README
+- Rakefile
+- bin/risp
+- test/test_risp_reader.rb
+- lib/risp.rb
+has_rdoc: true
+homepage: http://wiki.github.com/arikui1911/risp
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --title
+- risp documentation
+- --charset
+- utf-8
+- --opname
+- index.html
+- --line-numbers
+- --main
+- README
+- --inline-source
+- --exclude
+- ^(examples|extras)/
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: risp
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A toy lisp interpreter; provides `pure-lisp' functions and Lisp-1 namespaces. Currently it lacks package system and macro(!!).
+test_files: 
+- test/test_risp_reader.rb