shen-ruby 0.1.0

data/lib/kl/primitives/assignments.rb

@@ -0,0 +1,18 @@
+module Kl
+  module Primitives
+    module Assignments
+      def set(sym, value)
+        @variables[sym] = value
+        value
+      end
+
+      def value(sym)
+        if @variables.has_key?(sym)
+          @variables[sym]
+        else
+          raise Kl::Error, "variable #{sym} has no value"
+        end
+      end
+    end
+  end
+end

data/lib/kl/primitives/booleans.rb

@@ -0,0 +1,17 @@
+module Kl
+  module Primitives
+    # The boolean functions are all implemented as short-circuiting special
+    # forms in the compiler. The implementations below are for use as
+    # arguments to higher-order functions. They are used, e.g., in the
+    # Quantifier Machine test case in the Shen Test Suite.
+    module Booleans
+      def or(a, b)
+        a || b
+      end
+
+      def and(a, b)
+        a && b
+      end
+    end
+  end
+end

data/lib/kl/primitives/error_handling.rb

@@ -0,0 +1,13 @@
+module Kl
+  module Primitives
+    module ErrorHandling
+      define_method 'simple-error' do |err_msg|
+        raise Kl::Error, err_msg
+      end
+
+      define_method 'error-to-string' do |err|
+        err.message
+      end
+    end
+  end
+end

data/lib/kl/primitives/generic_functions.rb

@@ -0,0 +1,22 @@
+module Kl
+  module Primitives
+    # The following functions are implemented as special forms
+    # in Kl::Compiler:
+    #
+    #  - defun
+    #  - lambda
+    #  - let
+    #  - freeze
+    #  - type
+    module GenericFunctions
+      define_method '=' do |a, b|
+        a == b
+      end
+
+      # Curried after inclusion
+      define_method 'eval-kl' do |exp|
+        __eval(exp)
+      end
+    end
+  end
+end

data/lib/kl/primitives/lists.rb

@@ -0,0 +1,21 @@
+module Kl
+  module Primitives
+    module Lists
+      def cons(a, b)
+        Kl::Cons.new(a, b)
+      end
+
+      def hd(a)
+        a.hd
+      end
+
+      def tl(a)
+        a.tl
+      end
+
+      def cons?(a)
+        a.kind_of? Kl::Cons
+      end
+    end
+  end
+end

data/lib/kl/primitives/streams.rb

@@ -0,0 +1,38 @@
+module Kl
+  module Primitives
+    module Streams
+      def pr(s, stream)
+        if stream == STDIN
+          # shen-prbytes in toplevel.kl calls pr on *stinput* rather than
+          # *stoutput*. As a temporary solution, use the same approach
+          # that Bruno Deferrari uses in his Scheme port. See
+          # https://groups.google.com/d/topic/qilang/2ixosqX4Too/discussion
+          stream = STDOUT if stream == STDIN
+        end
+        stream.write(s)
+        s
+      end
+      
+      define_method 'read-byte' do |stream|
+        if stream.eof?
+          -1
+        else
+          stream.readbyte
+        end
+      end
+
+      def open(stream_type, name, direction)
+        unless stream_type == :file
+          raise Kl::Error, "unsupported stream type: #{stream_type}"
+        end
+        File.open(File.expand_path(name, value(:'*home-directory*')),
+                  direction == :out ? 'w' : 'r')
+      end
+      
+      def close(stream)
+        stream.close
+        :NIL
+      end
+    end
+  end
+end

data/lib/kl/primitives/strings.rb

@@ -0,0 +1,55 @@
+module Kl
+  module Primitives
+    # For the time being, Shen Ruby's string functions only support 8-bit 
+    # characters. Once the Shen environment is up and running and passing
+    # its test suite, strings will be extended to support UTF-8.
+    module Strings
+      def pos(s, n)
+        s.byteslice(n)
+      end
+      
+      def tlstr(s)
+        if s.empty?
+          :"shen-eos"
+        else
+          s.byteslice(1, s.bytesize - 1)
+        end
+      end
+      
+      def cn(s1, s2)
+        s1 + s2
+      end
+      
+      def str(x)
+        case x
+        when String
+          '"' + x + '"'
+        when Symbol
+          x.to_s
+        when Numeric
+          x.to_s
+        when TrueClass, FalseClass
+          x.to_s
+        when Proc
+          x.to_s
+        when IO
+          x.to_s
+        else
+          raise Kl::Error, "str applied to non-atomic type: #{x.class}"
+        end
+      end
+      
+      def string?(x)
+        x.kind_of? String
+      end
+
+      define_method 'n->string' do |n|
+        "" << n
+      end
+
+      define_method 'string->n' do |s|
+        s.bytes.to_a.first
+      end
+    end
+  end
+end

data/lib/kl/primitives/symbols.rb

@@ -0,0 +1,17 @@
+module Kl
+  module Primitives
+    module Symbols
+      def intern(str)
+        # 'true' and 'false' are treated specially and return the
+        # corresponding booleans
+        if str == 'true'
+          true
+        elsif str == 'false'
+          false
+        else
+          str.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/kl/primitives/time.rb

@@ -0,0 +1,17 @@
+module Kl
+  module Primitives
+    module Time
+      define_method 'get-time' do |time_type|
+        case time_type
+        when :run, :real
+          ::Time.now.to_f
+        when :unix
+          ::Time.now.to_i
+        else
+          raise Kl::Error, "unsupported time type: #{time_type}"
+        end
+      end
+    end
+  end
+end
+  

data/lib/kl/primitives/vectors.rb

@@ -0,0 +1,30 @@
+module Kl
+  module Primitives
+    module Vectors
+      def absvector(n)
+        Kl::Absvector.new(n)
+      end
+
+      define_method 'address->' do |v, n, value|
+        if n < 0 || n >= v.upper_limit
+          raise Kl::Error, "out of bounds"
+        end
+
+        v[n] = value
+        v
+      end
+
+      define_method '<-address' do |v, n|
+        if n < 0 || n >= v.upper_limit
+          raise Kl::Error, "out of bounds"
+        end
+
+        v[n]
+      end
+
+      def absvector?(v)
+        v.kind_of? Kl::Absvector
+      end
+    end
+  end
+end

data/lib/kl/reader.rb

@@ -0,0 +1,40 @@
+require 'kl/lexer'
+
+module Kl
+  class Reader
+    def initialize(stream)
+      @lexer = Kl::Lexer.new(stream)
+    end
+
+    def next
+      token = @lexer.next
+      unless token.nil? 
+        if token.kind_of? Kl::Lexer::OpenParen
+          read_list
+        else
+          token
+        end
+      end
+    end
+
+  private
+
+    def read_list
+      items = []
+
+      loop do
+        token = @lexer.next
+        raise Kl::Error, 'Unterminated list' if token.nil?
+        case token
+        when Kl::Lexer::OpenParen
+          items << read_list
+        when Kl::Lexer::CloseParen
+          break
+        else
+          items << token
+        end
+      end
+      Kl::Cons.list(items)
+    end
+  end
+end

data/lib/kl/trampoline.rb

@@ -0,0 +1,14 @@
+module Kl
+  # Trampolines hold a function and a list of its already-evaluated
+  # arguments. They are used to keep the strack from growing on
+  # tail calls.
+  class Trampoline
+    attr_reader :fn, :args, :f
+    
+    def initialize(fn, args, f)
+      @fn = fn
+      @args = args
+      @f = f
+    end
+  end
+end

data/lib/shen_ruby.rb

@@ -0,0 +1,7 @@
+require 'kl'
+require 'shen_ruby/version'
+
+# The following file is a derivative of the Shen release packages with ShenRuby
+# and it located under the shen directory hierarchy to make the license
+# unambigous. It can be found at shen/lib/shen_ruby/shen.rb
+require 'shen_ruby/shen'

data/lib/shen_ruby/version.rb

@@ -0,0 +1,3 @@
+module ShenRuby
+  VERSION = "0.1.0"
+end

data/shen-ruby.gemspec

@@ -0,0 +1,26 @@
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require 'shen_ruby/version'
+
+Gem::Specification.new do |s|
+  s.name        = "shen-ruby"
+  s.version     = ShenRuby::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.license     = "Shen License and MIT License. See README.md for details."
+  s.authors     = ["Greg Spurrier", "Mark Tarver"]
+  s.email       = ["greg@sourcematters.org"]
+  s.homepage    = "https://github.com/gregspurrier/shen-ruby"
+  s.summary     = %q{ShenRuby is a Ruby port of the Shen programming language}
+  s.description = %q{ShenRuby is a port of the Shen programming language to Ruby. It currently supports Shen version 7.1.}
+
+  s.required_ruby_version     = ">= 1.9.3"
+
+  s.add_development_dependency "rspec", "~> 2.12"
+
+  git_files            = `git ls-files`.split("\n") rescue ''
+  s.files              = git_files
+  s.test_files         = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables        = %w(srrepl)
+  s.require_paths      = ["lib", "shen/lib"]
+end

data/shen/README.txt

@@ -0,0 +1,17 @@
+The files found in this directory and its subdirectories are part of
+Shen and are subject to the Shen License. A copy of the license may be
+found in license.txt in this directory. A detailed explanation of the
+license may be found at http://shenlanguage.org/license.html.
+
+Directory contents:
+
+README.txt  -- this file
+license.txt -- the Shen license
+release/    -- files extracted directly from the Shen 7.1 Source
+               release. The complete source for the most recent
+               release of Shen may be downloaded from
+               http://www.shenlanguage.org/Download/index.htm
+lib/        -- Ruby code that creates a full Shen environment running
+               under ShenRuby's implementation of K Lambda. This code
+               is considered a derivative work of the original Shen
+               Source release.

data/shen/lib/shen_ruby/shen.rb

@@ -0,0 +1,124 @@
+############################################################################
+# License
+# -------
+# The user is free to produce commercial applications with the
+# software, to distribute these applications in source or binary form,
+# and to charge monies for them as he sees fit and in concordance with
+# the laws of the land subject to the following license.
+# 
+# 1. The license applies to all the software and all derived software
+# and must appear on such.
+#
+# 2. It is illegal to distribute the software without this license
+# attached to it and use of the software implies agreement with the
+# license as such. It is illegal for anyone who is not the copyright
+# holder to tamper with or change the license.
+#
+# 3. Neither the names of Lambda Associates or the copyright holder
+# may be used to endorse or promote products built using the software
+# without specific prior written permission from the copyright holder.
+#
+# 4. That possession of this license does not confer on the copyright
+# holder any special contractual obligation towards the user. That in
+# no event shall the copyright holder 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) arising in any way
+# out of the use of the software, even if advised of the possibility
+# of such damage.
+#
+# 5. It is permitted for the user to change the software, for the
+# purpose of improving performance, correcting an error, or porting to
+# a new platform, and distribute the modified version of Shen
+# (hereafter the modified version) provided the resulting program
+# conforms in all respects to the Shen standard and is issued under
+# that title. The user must make it clear with his distribution that
+# he/she is the author of the changes and what these changes are and
+# why.
+#
+# 6. Derived versions of this software in whatever form are subject to
+# the same restrictions. In particular it is not permitted to make
+# derived copies of this software which do not conform to the Shen
+# standard or appear under a different title.
+#
+# 7. It is permitted to distribute versions of Shen which incorporate
+# libraries, graphics or other facilities which are not part of the
+# Shen standard.
+#
+# For an explication of this license see
+# http://www.lambdassociates.org/News/june11/license.htm which
+# explains this license in full.
+#
+############################################################################
+#
+# This file was written by Greg Spurrier as part of the ShenRuby
+# project. It is essentially a shell into which the K Lambda sources
+# of Shen are loaded at runtime as part of object initialization to
+# produce a working Shen environment. It is thefore a derivative work
+# of the Shen sources and is subject to the Shen License.
+#
+############################################################################
+
+module ShenRuby
+  # Instances of the ShenRuby::Shen class provide a Shen environment
+  # running within ShenRuby's K Lambda implementation.
+  class Shen < Kl::Environment
+    def initialize
+      super
+
+      # Set the global variables
+      set("*language*".to_sym, "Ruby")
+      set("*implementation*".to_sym, "#{RUBY_ENGINE} #{RUBY_VERSION}")
+      set("*release*".to_sym, RUBY_VERSION)
+      set("*port*".to_sym, ShenRuby::VERSION)
+      set("*porters*".to_sym, "Greg Spurrier")
+      set("*home-directory*".to_sym, Dir.pwd)
+      set("*stinput*".to_sym, STDIN)
+      set("*stoutput*".to_sym, STDOUT)
+
+
+      # Load the K Lambda files
+      kl_root = File.expand_path('../../../release/k_lambda', __FILE__)
+      %w(toplevel core sys).each do |kl_filename|
+        Kl::Environment.load_file(self, File.join(kl_root, kl_filename + ".kl"))
+      end
+
+      # Overrides
+      class << self
+        # Kl::Absvector.new already initializes every element, so we can
+        # use a simpler version of vector
+        def vector(n)
+          v = ::Kl::Absvector.new(n + 1) #, fail)
+          v[0] = n
+          v
+        end
+
+        # The version of shen-explode-string from sys.kl is not tail-recursive.
+        # Replace it with a version that does not blow up the stack.
+        define_method "shen-explode-string" do |str|
+          Kl::Cons.list(str.split(//))
+        end
+
+        # Give a way to bail out
+        define_method 'quit' do
+          ::Kernel.exit(0)
+        end
+
+        # For debugging the compiler
+        define_method 'set-dump-code' do |val|
+          @dump_code = val
+        end
+      end
+
+      # Load the rest of the K Lambda files
+      %w(sequent yacc
+         reader prolog track load writer
+         macros declarations t-star types
+        ).each do |kl_filename|
+        Kl::Environment.load_file(self, File.join(kl_root, kl_filename + ".kl"))
+      end
+    end
+  end
+end