rus3 0.1.0

data/lib/rus3/char.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Rus3
+  class Char
+  end
+end

data/lib/rus3/error.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Rus3
+  class Error < StandardError
+    include EmptyList
+
+    def smart_error_value(obj)  # :nodoc:
+      case obj
+      when Array
+        if obj.empty?           # an empty list
+          "()"
+        else                    # a normal proper list
+          list_notation = obj.to_s().gsub(/[\[\],]/, A2L_MAP)
+          "list( %s )" % obj
+        end
+      when Numeric
+        "number(%d)" % obj
+      when Rus3::Pair
+        "pair(%s)" % obj
+      else
+        "%s(%s)" % [obj.class, obj]
+      end
+    end
+
+    A2L_MAP = { "[" => "(", "," => "", "]" => ")"} # :nodoc:
+  end
+
+  # :stopdoc:
+
+  EMSG = {
+    :pair_required => "pair required: got=%s",
+    :list_required => "proper list required: got=%s",
+    :pair_or_list_required => "pair or proper list required: got=%s",
+    :out_of_range  => "argument out of range: got=%s",
+    :unsupported_method => "specified method does not work now.",
+    :wrong_type => "wrong type argument: got=%s, wants=%s",
+    :integer_required => "integer required: got=%s",
+    :real_number_required => "real number required: got=%s",
+    :number_required => "number required: got=%s",
+    :string_required => "string required: got=%s",
+    :scheme_syntax_error => "syntax error as Scheme: got=%s",
+    :cannot_find_file => "cannot find %s",
+    :unsupported_feature => "specified feature (`%s`) does not support for %s"
+  }
+
+  # :startdoc:
+
+  class PairRequiredError < Error
+    def initialize(obj)
+      super(EMSG[:pair_required] % smart_error_value(obj))
+    end
+  end
+
+  class ListRequiredError < Error
+    def initialize(obj)
+      super(EMSG[:list_required] % smart_error_value(obj))
+    end
+  end
+
+  class PairOrListRequiredError < Error
+    def initialize(obj)
+      super(EMSG[:pair_or_list_required] % smart_error_value(obj))
+    end
+  end
+
+  class OutOfRangeError < Error
+    def initialize(obj)
+      super(EMSG[:out_of_range] % smart_error_value(obj))
+    end
+  end
+
+  class UnsupportedMethodError < Error
+    def initialize
+      super(EMSG[:unsupported_method])
+    end
+  end
+
+  class WrongTypeError < Error
+    def initialize(obj, expected)
+      emsg = EMSG[:wrong_type] % [obj, expected]
+      super(emsg)
+    end
+  end
+
+  class IntegerRequiredError < Error
+    def initialize(obj)
+      super(EMSG[:integer_required] % smart_error_value(obj))
+    end
+  end
+
+  class RealNumberRequiredError < Error
+    def initialize(obj)
+      super(EMSG[:real_number_required] % smart_error_value(obj))
+    end
+  end
+
+  class NumberRequiredError < Error
+    def initialize(obj)
+      super(EMSG[:number_required] % smart_error_value(obj))
+    end
+  end
+
+  class StringRequiredError < Error
+    def initialize(obj)
+      super(EMSG[:string_required] % smart_error_value(obj))
+    end
+  end
+
+  class SchemeSyntaxError < Error
+    def initialize(obj)
+      super(EMSG[:scheme_syntax_error] % smart_error_value(obj))
+    end
+  end
+
+  class CannotFindFileError < Error
+    def initialize(obj)
+      super(EMSG[:cannot_find_file] % smart_error_value(obj))
+    end
+  end
+
+  class UnsupportedFeatureError < Error
+    def initialize(feature, obj)
+      super(EMSG[:unsupported_feature] % [feature, obj])
+    end
+  end
+
+end

data/lib/rus3/evaluator.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Rus3
+
+  # An evaluator.
+
+  class Evaluator
+
+    # Indicates the version of the evaluator class.
+    VERSION = "0.1.0"
+
+    include EmptyList
+
+    class Environment
+      include Rus3::Procedure::Control
+      include Rus3::Procedure::Write
+      include Rus3::Procedure::List
+      include Rus3::Procedure::Predicate
+      include Rus3::EmptyList
+
+      attr_reader :binding
+
+      def initialize
+        @binding = Kernel.binding
+      end
+
+    end
+
+    attr_accessor :verbose
+
+    attr_reader :environment
+
+    def initialize
+      @verbose = false
+      @env = Environment.new
+      define_procs_for_infix_ops
+    end
+
+    def eval(exp)
+      pp exp if @verbose
+      @env.binding.eval(exp)
+    end
+
+    def binding
+      @env.binding
+    end
+
+    def version
+      "Evaluator version: #{VERSION}"
+    end
+
+    private
+
+    INFIX_OPS = {
+      :+  => :add,
+      :-  => :subtract,
+      :*  => :mul,
+      :/  => :div,
+      :%  => :mod,
+      :<  => :lt?,
+      :<= => :le?,
+      :>  => :gt?,
+      :>= => :ge?,
+      :== => :eqv?,
+    }
+
+    def define_procs_for_infix_ops
+      r = @env.binding.receiver
+      INFIX_OPS.each { |op, proc_name|
+        r.instance_eval("def #{proc_name}(op1, op2); op1 #{op} op2; end")
+      }
+    end
+
+  end
+end

data/lib/rus3/pair.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Rus3
+
+  # A building block to construct a dotted pair.
+
+  class Pair
+    include EmptyList
+
+    # CAR part of the pair.
+    attr_reader :car
+
+    # CDR part of the pair.
+    attr_reader :cdr
+
+    # :call-seq:
+    #   new(car, cdr) -> a new Pair object
+
+    def initialize(car = EMPTY_LIST, cdr = EMPTY_LIST)
+      @car = car
+      @cdr = cdr
+    end
+
+    # Replaces the CAR part with the argument.
+
+    def set_car!(obj)
+      @car = obj
+    end
+
+    # Replaces the CDR part with the argument.
+
+    def set_cdr!(obj)
+      @cdr = obj
+    end
+
+    # Compares to an other pair.
+
+    def ==(other)
+      other.instance_of?(Pair) and @car == other.car and @cdr == other.cdr
+    end
+
+    # Converts to an Array, which looks like as follows:
+    #
+    #   [CAR, CDR]
+    #
+    # When CAR or CDR part is also a Pair object, converts
+    # recursively.
+
+    def to_a
+      [@car, @cdr].map { |e| Pair === e ? e.to_a : e}
+    end
+
+    # Converts to a String.  Normally, uses the dot-pair notaion which
+    # looks like "(CAR . CDR)".  If the CDR part is an empty string,
+    # looks like a normal list which has a single element, like
+    # "(CAR)".
+
+    def to_s
+      car_part = null?(@car) ? "()" : @car
+      if null?(@cdr)
+        "(#{car_part})"
+      else
+        "(#{car_part} . #{@cdr})"
+      end
+    end
+  end
+end

data/lib/rus3/parser.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Rus3
+
+  module Parser
+    require "readline"
+    require_relative "parser/lexer"
+
+    # Indicates the version of the parser module.
+    VERSION = "0.1.0"
+
+    # A base class to derived a parser.
+    class Parser
+
+      # Holds a prompt string.  It is intended to be set in the REPL
+      # loop.
+      attr_accessor :prompt
+
+      def initialize
+        @prompt = ""
+      end
+
+      # Constructs the version string.
+
+      def version
+        "Parser version #{VERSION}"
+      end
+
+      # Reads an expression from the passed IO instance.  Returns nil
+      # when reaches to EOF.
+
+      def read(io = STDIN)
+        exp = Readline::readline(@prompt, true)
+        exp.nil? ? nil : parse(exp)
+      end
+
+      protected
+
+      # Parses the passed expression, then returns the processed
+      # expression to be evaluated by an evaluator.  How to process
+      # depends on each derived parser class.
+
+      def parse(exp)
+        nil
+      end
+
+    end
+
+    require_relative "parser/scheme_parser"
+
+    DEFAULT_PARSER = SchemeParser # :nodoc:
+
+    # :stopdoc:
+
+    class PassthroughParser < Parser
+      PARSER_VERSION = "0.1.0"
+
+      def version
+        super + " (Pass Through Parser version: #{PARSER_VERSION})"
+      end
+    end
+
+    def parse(exp)
+      exp
+    end
+
+    # :startdoc:
+
+  end
+
+end

data/lib/rus3/parser/lexer.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Rus3::Parser
+
+  class Lexer < Enumerator
+
+    # Indicates the version of the lexer class
+    LEXER_VERSION = "0.1.0"
+
+    # :stopdoc:
+
+    TYPES = [
+      # delimiters
+      :lparen,
+      :rparen,
+      # value types
+      :boolean,
+      :ident,
+      :string,
+      :number,
+      # operators
+      :op_proc,
+      # keywords
+      :if,
+      :define,
+      # control
+      :illegal,
+    ]
+
+    BOOLEAN    = /\A#(f|t)\Z/
+    STRING     = /\A\"[^\"]*\"\Z/
+
+    # idents
+    EXTENDED   = "\\-"
+    IDENT_PAT  = "[a-zA-Z_][\\w?!#{EXTENDED}]*"
+    IDENTIFIER = Regexp.new("\\A#{IDENT_PAT}\\Z")
+
+    EXTENDED_REGEXP = Regexp.new("[#{EXTENDED}]")
+    EXTENDED_MAP = { "-" => "_", }
+
+    # operators
+    ARITHMETIC_OPS = /\A[+\-*\/%]\Z/
+    COMPARISON_OPS = /\A[<>]=?\Z/
+
+    # numbers
+    REAL_PAT   = "(([1-9][0-9]*)|0)(\.[0-9]+)?"
+    RAT_PAT    = "#{REAL_PAT}\\/#{REAL_PAT}"
+    C_REAL_PAT = "(#{REAL_PAT}|#{RAT_PAT})"
+    C_IMAG_PAT = "#{C_REAL_PAT}"
+    COMP_PAT   = "#{C_REAL_PAT}(\\+|\\-)#{C_IMAG_PAT}i"
+
+    REAL_NUM   = Regexp.new("\\A[+-]?#{REAL_PAT}\\Z")
+    RATIONAL   = Regexp.new("\\A[+-]?#{RAT_PAT}\\Z")
+    COMPLEX    = Regexp.new("\\A[+-]?#{COMP_PAT}\\Z")
+    PURE_IMAG  = Regexp.new("\\A[+-](#{C_IMAG_PAT})?i\\Z")
+
+    KEYWORDS = {
+      "LAMBDA" => :lambda,
+      "IF"     => :if,
+      "SET!"   => :set!,
+      "DEFINE" => :define,
+      "COND"   => :cond,
+      "LET"    => :let,
+      "ELSE"   => :else,        # may use with :cond
+    }
+
+    # :startdoc:
+
+    Token = Struct.new(:type, :literal) # :nodoc:
+
+    class << self
+
+      def new(exp, _ = nil)
+        tokens = tokenize(exp)
+        super(tokens.size) { |y|
+          tokens.each { |tk|
+            y.yield(tk)
+          }
+        }
+      end
+
+      S2R_MAP = { "(" => "[ ", ")" => " ]" } # :nodoc:
+
+      def tokenize(exp)
+        source = exp.gsub(/[()]/, S2R_MAP)
+
+        source.split(" ").map { |literal|
+          case literal
+          when "["
+            Token.new(:lparen, literal)
+          when "]"
+            Token.new(:rparen, literal)
+          when BOOLEAN
+            Token.new(:boolean, literal)
+          when IDENTIFIER
+            key = literal.upcase
+            if KEYWORDS.keys.include?(key)
+              Token.new(KEYWORDS[key], literal)
+            else
+              Token.new(:ident, literal.gsub(EXTENDED_REGEXP, EXTENDED_MAP))
+            end
+          when STRING
+            Token.new(:string, literal)
+          when "="
+            Token.new(:op_proc, "==")
+          when ARITHMETIC_OPS, COMPARISON_OPS
+            Token.new(:op_proc, literal)
+          when REAL_NUM, RATIONAL, COMPLEX, PURE_IMAG
+            Token.new(:number, literal)
+          else
+            Token.new(:illegal, literal)
+          end
+        }
+      end
+
+    end
+
+  end
+end