rus3 0.1.2 → 0.2.0

data/lib/rus3/ast/error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Rus3
+  module AST
+    class Error < StandardError
+    end
+  end
+end

data/lib/rus3/ast/leaf_node.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Rus3
+  module AST
+
+    class LeafNode < Node
+      def leaf?
+        true
+      end
+    end
+
+    class BooleanNode < LeafNode
+      def type
+        :boolean
+      end
+    end
+
+    class IdentifierNode < LeafNode
+      def type
+        :identifier
+      end
+    end
+
+    class PeculiarIdentifierNode < IdentifierNode
+      def type
+        :peculiar_identifier
+      end
+    end
+
+    class CharacterNode < LeafNode
+      def type
+        :character
+      end
+    end
+
+    class StringNode < LeafNode
+      def type
+        :string
+      end
+    end
+
+    class NumberNode < LeafNode
+      def type
+        :number
+      end
+    end
+
+    class DotNode < LeafNode
+      def type
+        :dot
+      end
+    end
+
+  end
+end

data/lib/rus3/error.rb

@@ -46,6 +46,8 @@ module Rus3
     :unsupported_method => "specified method does not work now.",
     :unsupported_feature => "specified feature (`%s`) does not support for %s",
     :cannot_find_file => "cannot find %s",
+    :not_implemented_yet => "not implemented yet (%s)",
+    :unknown_operator => "unknown operator: got=%s",
   }
 
   # :startdoc:
@@ -125,7 +127,7 @@ module Rus3
 
   class SchemeSyntaxError < Error
     def initialize(obj)
-      super(EMSG[:scheme_syntax_error] % smart_error_value(obj))
+      super(EMSG[:scheme_syntax_error] % "#{obj[1]} as #{obj[0]}")
     end
   end
 
@@ -147,4 +149,16 @@ module Rus3
     end
   end
 
+  class NotImplementedYetError < Error
+    def initialize(feature)
+      super(EMSG[:not_implemented_yet] % feature)
+    end
+  end
+
+  class UknownOperatorError < Error
+    def initialize(operator)
+      super(EMSG[:unknown_operator] % operator)
+    end
+  end
+
 end

data/lib/rus3/evaluator.rb

@@ -2,76 +2,60 @@
 
 module Rus3
 
-  # An evaluator.
+  module Evaluator
+    require_relative "evaluator/environment"
 
-  class Evaluator
+    # Indicates the version of the evaluator module.
+    VERSION = "0.2.0"
 
-    # Indicates the version of the evaluator class.
-    VERSION = "0.1.0"
+    # An evaluator.
+    class Evaluator
 
-    include EmptyList
-
-    class Environment
-      include Rus3::Procedure::Control
-      include Rus3::Procedure::Write
-      include Rus3::Procedure::Vector
-      include Rus3::Procedure::List
-      include Rus3::Procedure::Char
-      include Rus3::Procedure::Predicate
-      include Rus3::EmptyList
-
-      attr_reader :binding
+      attr_reader :verbose
 
       def initialize
-        @binding = Kernel.binding
+        @verbose = false
       end
 
-    end
+      def verbose=(verbose)
+        @verbose = verbose
+      end
 
-    attr_accessor :verbose
+      def instance_eval(&proc)
+        super
+      end
 
-    attr_reader :environment
+      def eval(ast); nil; end
 
-    def initialize
-      @verbose = false
-      @env = Environment.new
-      define_procs_for_infix_ops
-    end
+      def version
+        "evaluator-module version: #{VERSION}"
+      end
 
-    def eval(exp)
-      pp exp if @verbose
-      @env.binding.eval(exp)
     end
 
-    def binding
-      @env.binding
-    end
+    class PassthroughEvaluator < Evaluator
+      EVALUATOR_VERSION = "0.1.0"
 
-    def version
-      "Evaluator version: #{VERSION}"
-    end
+      def version
+        super + " (pass-through-evaluator version: #{EVALUATOR_VERSION})"
+      end
+
+      def eval(ast)
+        if @verbose
+          ast.each { |node|
+            print "  evaluator(pass-through): "
+            pp node
+          }
+        end
+        ast.to_s
+      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
 
+    require_relative "evaluator/scheme_evaluator"
+    require_relative "evaluator/translator"
+
+    DEFAULT_EVALUATOR = SchemeEvaluator # :nodoc:
+
   end
 end

data/lib/rus3/evaluator/environment.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Rus3
+
+  module Evaluator
+
+    class Environment
+      include Rus3::Procedure::Control
+      include Rus3::Procedure::Write
+      include Rus3::Procedure::Vector
+      include Rus3::Procedure::List
+      include Rus3::Procedure::Char
+      include Rus3::Procedure::Predicate
+      include Rus3::EmptyList
+
+      attr_reader :binding
+
+      def initialize
+        @binding = Kernel.binding
+      end
+
+    end
+
+  end
+end

data/lib/rus3/evaluator/scheme_evaluator.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Rus3
+
+  module Evaluator
+
+    class SchemeEvaluator < Evaluator
+      EVALUATOR_VERSION = "0.2.0"
+
+      def version
+        vmsg = "(scheme-evaluator :version #{EVALUATOR_VERSION})"
+        if @translator
+          vmsg += " #{@translator.version}"
+        end
+        super + " (#{vmsg})"
+      end
+
+      def initialize
+        super
+
+        @env = Environment.new
+        define_procs_for_infix_ops
+
+        @translator = Translator.new
+        @translator.add_procedure_map(INFIX_OPS_MAP)
+      end
+
+      def verbose=(verbose)
+        super
+        @translator and @translator.verbose = verbose
+      end
+
+      def instance_variable_set(var, value)
+        @env.binding.receiver.instance_variable_set(var, value)
+      end
+
+      def instance_eval(&proc)
+        @env.binding.receiver.instance_eval(&proc)
+      end
+
+      def eval(ast)
+        ruby_source = translate_ast(ast)
+        pp ruby_source if @verbose
+        @env.binding.eval(ruby_source)
+      end
+
+      def binding
+        @env.binding
+      end
+
+      INFIX_OPS_MAP = {
+        "+"  => "add",
+        "-"  => "subtract",
+        "*"  => "mul",
+        "/"  => "div",
+        "%"  => "mod",
+        "<"  => "lt?",
+        "<=" => "le?",
+        ">"  => "gt?",
+        ">=" => "ge?",
+        "==" => "eqv?",
+      }
+
+      private
+
+      def translate_ast(ast)
+        ast.map{|node| @translator.translate(node)}.join("\n")
+      end
+
+      def define_procs_for_infix_ops
+        r = @env.binding.receiver
+        INFIX_OPS_MAP.each { |op, proc_name|
+          r.instance_eval("def #{proc_name}(op1, op2); op1 #{op} op2; end")
+        }
+      end
+
+    end
+  end
+end

data/lib/rus3/evaluator/translator.rb

@@ -0,0 +1,337 @@
+# frozen_string_literal: true
+
+module Rus3
+
+  module Evaluator
+
+    # A class to translate an i-exp to r-exp.
+
+    class Translator
+      TRANSLATOR_VERSION = "0.1.0"
+
+      def version
+        "(scheme-ruby-translator :version #{TRANSLATOR_VERSION})"
+      end
+
+      def initialize
+        @verbose = false
+        @procedure_map = {}
+      end
+
+      def verbose=(verbose)
+        @verbose = verbose
+      end
+
+      def add_procedure_map(map)
+        @procedure_map.merge!(map)
+      end
+
+      # Translates an AST node into Ruby code.
+
+      def translate(ast_node)
+        return nil if ast_node.nil?
+
+        if @verbose
+          print "- translater ==> "
+          pp ast_node
+        end
+
+        method_name = "translate_#{ast_node.type}".intern
+        begin
+          m = method(method_name)
+        rescue
+          raise SchemeSyntaxError.new([ast_node.type, ast_node.to_s])
+        end
+        m.call(ast_node)
+      end
+
+      # :stopdoc:
+
+      private
+
+      def translate_boolean(ast_node)
+        case ast_node.literal[0..1]
+        when "#f"
+          "false"
+        when "#t"
+          "true"
+        else
+          raise SchemeSyntaxError.new([:boolean, ast_node.to_s])
+        end
+      end
+
+      def translate_identifier(ast_node)
+        replace_extended_char(ast_node.literal)
+      end
+
+      def translate_character(ast_node)
+        character = ast_node.literal[2..-1]
+        case character
+        when "space"
+          character = " "
+        when "newline"
+          character = "\n"
+        end
+        "Char.new(\"#{character}\")"
+      end
+
+      def translate_string(ast_node)
+        "#{ast_node.literal}"
+      end
+
+      def translate_number(ast_node)
+        converter = nil
+        case ast_node.literal
+        when /\A0\Z/
+          converter = "Integer"
+        when /\A[+-]?[1-9][0-9]*\Z/ # 123
+          converter = "Integer"
+        when /\A[+-]?([0-9]?|[1-9][0-9]*)\.[0-9]+\Z/ # 0.123 or 123.456
+          converter = "Float"
+        when /\A[+-]?[0-9]+\/[1-9][0-9]*\Z/ # 1/2
+          converter = "Rational"
+        else
+          converter = "Complex"
+        end
+        "#{converter}(\"#{ast_node.literal}\")"
+      end
+
+      def translate_peculiar_identifier(ast_node)
+        op_literal = ast_node.literal == "=" ? "==" : ast_node.literal
+        sym = @procedure_map[op_literal]
+        raise Rus3::UnknownOperatorError, op_literal if sym.nil?
+        sym.to_s
+      end
+
+      def translate_list(ast_node)
+        elements = ast_node.map{|e| translate(e)}.join(", ")
+        "[#{elements}]"
+      end
+
+      def translate_vector(ast_node)
+        obj_src = ast_node.map{|e| translate(e)}.join(", ")
+        "vector(#{obj_src})"
+      end
+
+      def translate_procedure_call(ast_node)
+        operands = ast_node.operands.map{|e| translate(e)}.join(", ")
+        operator = translate(ast_node.operator)
+        if ast_node.operator.type == :lambda_expression
+          "#{operator}.call(#{operands})"
+        else
+          "#{operator}(#{operands})"
+        end
+      end
+
+      def translate_lambda_expression(ast_node)
+        formals = translate_formals(ast_node)
+        body = translate_body(ast_node)
+        "lambda{|#{formals}| #{body}}"
+      end
+
+      def translate_formals(ast_node)
+        ast_node.formals.map{|node| translate_identifier(node)}.join(", ")
+      end
+
+      def translate_body(ast_node)
+        ast_node.body.map{|node| translate(node)}.join("; ")
+      end
+
+      def translate_conditional(ast_node)
+        test = translate(ast_node.test)
+        consequent = translate(ast_node.consequent)
+        alternate = translate(ast_node.alternate)
+        rb_src = "if #{test}; #{consequent}"
+        if alternate
+          rb_src += "; else; #{alternate}"
+        end
+        rb_src += "; end"
+        rb_src
+      end
+
+      def translate_assignment(ast_node)
+        identifier = translate_identifier(ast_node.identifier)
+        expression = translate(ast_node.expression)
+        "#{identifier} = #{expression}"
+      end
+
+      def translate_quotation(ast_node)
+        propagate_quotation(ast_node[1])
+      end
+
+      def propagate_quotation(ast_node)
+        case ast_node.type
+        when :list, :procedure_call, :lambda_expression, :conditional, :assignment
+          elements = ast_node.map{|child| propagate_quotation(child)}
+          "[" + elements.join(", ") + "]"
+        when :vector
+          elements = ast_node.map{|child| propagate_quotation(child)}
+          "vector(" + elements.join(", ")  + ")"
+        when :boolean, :character, :string
+          translate(ast_node)
+        when :number
+          ast_node.to_s
+        when :identifier, :peculiar_identifier
+          ":#{ast_node.to_s}"
+        else
+          raise SchemeSyntaxError.new([ast_node.type, ast_node.to_s])
+        end
+      end
+
+      def translate_identifier_definition(ast_node)
+        name = translate_identifier(ast_node.identifier)
+        if ast_node.expression.type == :lambda_expression
+          def_formals = translate_formals(ast_node.expression)
+          body = translate_body(ast_node.expression)
+          "def #{name}(#{def_formals}); #{body}; end"
+        else
+          rb_value = translate(ast_node.expression)
+          "#{name} = #{rb_value}"
+        end
+      end
+
+      def translate_cond(ast_node)
+        test_and_exps = ast_node.cond_clauses.map{|e| translate(e)}
+
+        first = intermediate = last = nil
+
+        first = test_and_exps[0]
+
+        if test_and_exps.size > 1
+          last = test_and_exps[-1]
+        end
+
+        if test_and_exps.size > 2
+          intermediate = test_and_exps[1..-2]
+        end
+
+        rb_src = []
+        rb_src << "if #{first}"
+
+        if intermediate
+          rb_src.concat(intermediate.map{|e| " elsif #{e}"})
+        end
+
+        if last
+          if /\Aelse/ === last
+            rb_src << " #{last}"
+          else
+            rb_src << " elsif #{last}"
+          end
+        end
+
+        rb_src.join(";") + "; end"
+      end
+
+      def translate_cond_clause(ast_node)
+        test_src = translate(ast_node.test)
+        exps_src = ast_node.sequence.map{|e| translate(e)}.join(";")
+        "#{test_src}; #{exps_src}"
+      end
+
+      def translate_let(ast_node)
+        formals = []
+        args = []
+
+        ast_node.bind_specs.each { |spec|
+          formals << translate_identifier(spec.identifier)
+          args << translate(spec.expression)
+        }
+
+        body = translate_body(ast_node)
+
+        "lambda{|#{formals.join(', ')}| #{body}}.call(#{args.join(', ')})"
+      end
+
+      RB_KEYWORDS_MAP = {
+        "BEGIN"    => nil,
+        "END"      => nil,
+        "alias"    => nil,
+        "and"      => nil,
+        "begin"    => nil,
+        "break"    => nil,
+        "case"     => nil,
+        "class"    => nil,
+        "def"      => nil,
+        "defined?" => nil,
+        "do"       => nil,
+        "else"     => nil,
+        "elsif"    => nil,
+        "end"      => nil,
+        "ensure"   => nil,
+        "false"    => nil,
+        "for"      => nil,
+        "if"       => nil,
+        "in"       => nil,
+        "module"   => nil,
+        "next"     => nil,
+        "nil"      => nil,
+        "not"      => nil,
+        "or"       => nil,
+        "redo"     => nil,
+        "rescue"   => nil,
+        "retry"    => nil,
+        "return"   => nil,
+        "self"     => nil,
+        "super"    => nil,
+        "then"     => nil,
+        "true"     => nil,
+        "undef"    => nil,
+        "unless"   => nil,
+        "until"    => nil,
+        "when"     => nil,
+        "while"    => nil,
+        "yield"    => nil,
+        "__LINE__" => nil,
+        "__FILE__" => nil,
+        "__ENCODING__" => nil,
+      }
+
+      COMPARISON_OPS_MAP = {
+        "="  => "eq",
+        "<"  => "lt",
+        ">"  => "gt",
+        "<=" => "le",
+        ">=" => "ge",
+      }
+
+      EXTENDED_REGEXP = Regexp.new("[#{Rus3::Lexer::EXTENDED_CHARS}]")
+
+      EXTENDED_CHARS_MAP = {
+        "!" => "!",             # no conversion
+        "$" => "$",             # no conversion
+        "%" => "%",             # no conversion
+        "&" => "&",             # no conversion
+        "*" => "*",             # no conversion
+        "+" => "+",             # no conversion
+        "-" => "_",
+        "." => ".",             # no conversion
+        "/" => "/",             # no conversion
+        ":" => ":",             # no conversion
+        "<" => "<",             # no conversion
+        "=" => "=",             # no conversion
+        ">" => "to_",
+        "?" => "?",             # no conversion
+        "@" => "@",             # no conversion
+        "^" => "^",             # no conversion
+        "_" => "_",             # no conversion
+        "~" => "~",             # no conversion
+      }
+
+      def replace_extended_char(literal)
+        result = literal
+
+        COMPARISON_OPS_MAP.each { |op, word|
+          comparison_regexp = Regexp.new("#{op}\\?\\Z")
+          if comparison_regexp === literal
+            result = literal.sub(comparison_regexp, "_#{word}?")
+          end
+        }
+
+        result.gsub(EXTENDED_REGEXP, EXTENDED_CHARS_MAP)
+      end
+
+      # :startdoc:
+    end
+  end
+end