shen-ruby 0.10.0 → 0.11.0

data/lib/kl/error.rb

@@ -1,4 +0,0 @@
-module Kl
-  class Error < StandardError
-  end
-end

data/lib/kl/internal_error.rb

@@ -1,7 +0,0 @@
-module Kl
-  # Internal errors represent inconsistent state within the compiler
-  # or runtime environment. They are not catchable by application-level
-  # code.
-  class InternalError < StandardError
-  end
-end

data/lib/kl/lexer.rb

@@ -1,186 +0,0 @@
-require 'singleton'
-require 'kl/error'
-
-module Kl
-  class Lexer
-    SYMBOL_CHARS = /[-=*\/+_?$!\@~><&%'#`;:{}a-zA-Z0-9.]/
-
-    # Syntax tokens
-    class OpenParen
-      include Singleton
-    end
-    class CloseParen
-      include Singleton
-    end
-
-    def initialize(stream)
-      @stream = stream
-      @buffer = []
-    end
-
-    def eof?
-      @buffer.empty? && @stream.eof?
-    end
-
-    def getc
-      if @buffer.empty?
-        @stream.getc
-      else
-        @buffer.pop
-      end
-    end
-    
-    def ungetc(c)
-      @buffer.push(c)
-    end
-    
-    def next
-      drain_whitespace
-      unless eof?
-        c = getc
-        case c
-        when '('
-          OpenParen.instance
-        when ')'
-          CloseParen.instance
-        when '"'
-          consume_string
-        when SYMBOL_CHARS
-          ungetc(c)
-          consume_number_or_symbol
-        else
-          raise Error, "illegal character: #{c}"
-        end
-      end
-    end
-
-  private
-    def drain_whitespace
-      until eof?
-        c = getc
-        if c =~ /\S/
-          ungetc(c)
-          break
-        end
-      end
-    end
-
-    def consume_string
-      chars = []
-      loop do
-        raise Error, "unterminated string" if eof?
-        c = getc
-        break if c == '"'
-        chars << c
-      end
-      chars.join
-    end
-
-    def consume_number
-      # Shen allows multiple leading plusses and minuses. The plusses
-      # are ignored and an even number of minuses cancel each other.
-      # Thus '------+-7' is read as 7. 
-      #
-      # The Shen reader parses "7." as the integer 7 and the symbol '.'
-      decimal_seen = false
-      negative = false
-      past_sign = false
-      chars = []
-      loop do
-        break if eof?
-        c = getc
-        if c =~ /\d/
-          past_sign = true
-          chars << c
-        elsif c == '.' && !decimal_seen
-          past_sign = true
-          decimal_seen = true
-          chars << c
-        elsif c == '+' && !past_sign
-          # ignore
-        elsif c == '-' && !past_sign
-          negative = !negative
-        else
-          ungetc c
-          break
-        end
-      end
-      chars.unshift('-') if negative
-      if chars.last == '.'
-        # A trailing decimal point is treated as part of the next
-        # token. Forget we saw it.
-        ungetc(chars.pop)
-        decimal_seen = false
-      end
-      str = chars.join
-      decimal_seen ? str.to_f : str.to_i
-    end
-
-    def consume_symbol
-      chars = []
-      loop do
-        break if eof?
-        c = getc
-        unless c =~ SYMBOL_CHARS
-          ungetc c
-          break
-        end
-        chars << c
-      end
-      str = chars.join
-
-      case str
-      when 'true'
-        true
-      when 'false'
-        false
-      else
-        str.to_sym
-      end
-    end
-
-    def consume_number_or_symbol
-      # First drain optional leading signs
-      # Then drain optional decimal point
-      # If there is another character and it is a digit, then it
-      # is a number. Otherwise it is a symbol.
-      chars = []
-      loop do
-        break if eof?
-        c = getc
-        unless c =~ /[-+]/
-          ungetc c
-          break
-        end
-        chars << c
-      end
-      if eof?
-        chars.reverse.each {|x| ungetc x}
-        return consume_symbol
-      end
-
-      c = getc
-      chars << c
-      if c == '.'
-        if eof?
-          chars.reverse.each {|x| ungetc x}
-          return consume_symbol
-        end
-        c = getc
-        chars << c
-        chars.reverse.each {|x| ungetc x}
-        if c =~ /\d/
-          return consume_number
-        else
-          return consume_symbol
-        end          
-      elsif c =~ /\d/
-        chars.reverse.each {|x| ungetc x}
-        return consume_number
-      else
-        chars.reverse.each {|x| ungetc x}
-        return consume_symbol
-      end
-    end
-  end
-end

data/lib/kl/primitives/arithmetic.rb

@@ -1,60 +0,0 @@
-module Kl
-  module Primitives
-    module Arithmetic
-      def +(a, b)
-        raise ::Kl::Error, "#{a} is not a number" unless a.kind_of? Numeric
-        raise ::Kl::Error, "#{b} is not a number" unless b.kind_of? Numeric
-        a + b
-      end
-      
-      def -(a, b)
-        raise ::Kl::Error, "#{a} is not a number" unless a.kind_of? Numeric
-        raise ::Kl::Error, "#{b} is not a number" unless b.kind_of? Numeric
-        a - b
-      end
-      
-      def *(a, b)
-        raise ::Kl::Error, "#{a} is not a number" unless a.kind_of? Numeric
-        raise ::Kl::Error, "#{b} is not a number" unless b.kind_of? Numeric
-        a * b
-      end
-      
-      def /(a, b)
-        raise ::Kl::Error, "#{a} is not a number" unless a.kind_of? Numeric
-        raise ::Kl::Error, "#{b} is not a number" unless b.kind_of? Numeric
-        if a.kind_of?(Fixnum) && b.kind_of?(Fixnum) && a % b != 0
-          a = a.to_f
-        end
-        a / b
-      end
-      
-      def >(a, b)
-        raise ::Kl::Error, "#{a} is not a number" unless a.kind_of? Numeric
-        raise ::Kl::Error, "#{b} is not a number" unless b.kind_of? Numeric
-        a > b
-      end
-
-      def <(a, b)
-        raise ::Kl::Error, "#{a} is not a number" unless a.kind_of? Numeric
-        raise ::Kl::Error, "#{b} is not a number" unless b.kind_of? Numeric
-        a < b
-      end
-      
-      def >=(a, b)
-        raise ::Kl::Error, "#{a} is not a number" unless a.kind_of? Numeric
-        raise ::Kl::Error, "#{b} is not a number" unless b.kind_of? Numeric
-        a >= b
-      end
-      
-      def <=(a, b)
-        raise ::Kl::Error, "#{a} is not a number" unless a.kind_of? Numeric
-        raise ::Kl::Error, "#{b} is not a number" unless b.kind_of? Numeric
-        a <= b
-      end
-      
-      def number?(a)
-        a.kind_of?(Numeric)
-      end
-    end
-  end
-end

data/lib/kl/primitives/assignments.rb

@@ -1,15 +0,0 @@
-module Kl
-  module Primitives
-    module Assignments
-      def set(sym, value)
-        raise Kl::Error, "#{sym} is not a symbol" unless sym.kind_of? Symbol
-        @variables[sym] = value
-        value
-      end
-
-      def value(sym)
-        @variables[sym]
-      end
-    end
-  end
-end

data/lib/kl/primitives/booleans.rb

@@ -1,21 +0,0 @@
-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
-      define_method 'if' do |a, b, c|
-        a ? b : c
-      end
-
-      def or(a, b)
-        a || b
-      end
-
-      def and(a, b)
-        a && b
-      end
-    end
-  end
-end

data/lib/kl/primitives/error_handling.rb

@@ -1,13 +0,0 @@
-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/extensions.rb

@@ -1,12 +0,0 @@
-module Kl
-  module Primitives
-    # Extensions to the official set of K Lambda primitives.
-    # Unlike the official primitives, these are allowed to be overridden
-    # by the Shen sources later.
-    module Extensions
-      define_method 'do' do |a, b|
-        b
-      end
-    end
-  end
-end

data/lib/kl/primitives/generic_functions.rb

@@ -1,29 +0,0 @@
-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
-
-      # Freeze is also provided as a normal function to support
-      # the partial application of zero arguments case. In this
-      # case it becomes a non-special-form.
-      def freeze(exp)
-        Kernel.lambda { exp }
-      end
-    end
-  end
-end

data/lib/kl/primitives/lists.rb

@@ -1,23 +0,0 @@
-module Kl
-  module Primitives
-    module Lists
-      def cons(a, b)
-        Kl::Cons.new(a, b)
-      end
-
-      def hd(a)
-        raise Kl::Error, "#{a} is not a list" unless a.kind_of? Kl::Cons
-        a.hd
-      end
-
-      def tl(a)
-        raise Kl::Error, "#{a} is not a list" unless a.kind_of? Kl::Cons
-        a.tl
-      end
-
-      def cons?(a)
-        a.kind_of? Kl::Cons
-      end
-    end
-  end
-end

data/lib/kl/primitives/streams.rb

@@ -1,28 +0,0 @@
-module Kl
-  module Primitives
-    module Streams
-      define_method 'read-byte' do |stream|
-        if stream.eof?
-          -1
-        else
-          stream.readbyte
-        end
-      end
-
-      define_method 'write-byte' do |byte, stream|
-        stream.putc byte
-        byte
-      end
-
-      def open(name, direction)
-        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

@@ -1,63 +0,0 @@
-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)
-        raise Kl::Error, "#{s} is not a string" unless s.kind_of? String
-        raise Kl::Error, "#{n} is not an integer" unless n.kind_of? Fixnum
-        if n < 0 || n >= s.length
-          raise Kl::Error, "out of bounds"
-        end
-        s.byteslice(n)
-      end
-      
-      def tlstr(s)
-        raise Kl::Error, "#{s} is not a string" unless s.kind_of? String
-        raise Kl::Error, "attempted to take tail of an empty string" if s.empty?
-        s.byteslice(1, s.bytesize - 1)
-      end
-      
-      def cn(s1, s2)
-        raise Kl::Error, "#{s1} is not a string" unless s1.kind_of? String
-        raise Kl::Error, "#{s2} is not a string" unless s2.kind_of? String
-        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|
-        raise Kl::Error, "#{n} is not an integer" unless n.kind_of? Fixnum
-        "" << n
-      end
-
-      define_method 'string->n' do |s|
-        raise Kl::Error, "#{s} is not a string" unless s.kind_of? String
-        raise Kl::Error, 'attempted to get code point of empty string' if s.empty?
-        s.bytes.to_a.first
-      end
-    end
-  end
-end