rus3 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8b1f3c9f79ba7f452ff3a2f6d7ec904ac3a1e0ffd836bafd4b4892a8cb0b12ac
-  data.tar.gz: 8c65e739832e954d9ca16fac40e437ca73bb3cddf48c35fbd3eb2f86658d8fd6
+  metadata.gz: 5309fbc8e935c7fea460f7084c02e36d082c17ec4f61f6343e5c340aacfa8eec
+  data.tar.gz: 30ad12bdae593004cf1d23e7f82676ae5b5b4f7e7c92d51857de1bc916d61452
 SHA512:
-  metadata.gz: 9b87669992f65b1279ceb003d2767d7ae6173374c6d810c646ee2914643050514c483aadb81cebafbd505fbbea41b89e297e6026f20749e571e84b423bc3cc8c
-  data.tar.gz: fec0ac13faa9880b10f6245d660b3e95430bfcd6cf48a65787634a55fe32c32e4e5f2eeb8f9321467c6a8dede5c03d34d7ab23ef0a0045de698e8bdf821c5534
+  metadata.gz: fe695566d2706dc9121278a76589085b46de790c0b8b6bfae7f9befaabb53239ffe52f4aa77e8311eb5648388d35f51130c4056020b80cb1cc8a2318908192c2
+  data.tar.gz: e70a4aef0e3d336f9fde29aa4a6030c75d4c53bd04f2c0b901f2506aa629d3ea10eff29f6674574ad4bb7b587a9ce723965aab51a18b206b402dd2b36056e1ff

data/CHANGELOG.md

@@ -7,6 +7,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 ## [Unreleased]
 - (nothing to record here)
 
+## [0.2.1] - 20201-05-20
+### Changed
+- Use Rbscmlex instead of built-in lexer. (#6)
+- Use Rubasteme instead of built-in AST and parser. (#6)
+
+### Fixed
+- Fix #5: too old `required_ruby_version`.
+
 ## [0.2.0] - 2021-05-03
 ### Added
 - Re-write the parser and evaluator mechanism.

data/Gemfile.lock

@@ -1,13 +1,18 @@
 PATH
   remote: .
   specs:
-    rus3 (0.2.0)
+    rus3 (0.2.1)
+      rbscmlex (>= 0.1.3)
+      rubasteme (>= 0.1.3)
 
 GEM
   remote: https://rubygems.org/
   specs:
     minitest (5.14.4)
     rake (13.0.3)
+    rbscmlex (0.1.3)
+    rubasteme (0.1.3)
+      rbscmlex (>= 0.1.3)
 
 PLATFORMS
   x86_64-darwin-20

data/lib/rus3.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "rbscmlex"
+require "rubasteme"
+
 module Rus3
 
   # An empty list is a special object in Scheme language.  The role
@@ -43,16 +46,14 @@ module Rus3
 
   require_relative "rus3/procedure/utils"
   require_relative "rus3/procedure/predicate"
+  require_relative "rus3/procedure/arithmetic"
+  require_relative "rus3/procedure/comparison"
   require_relative "rus3/procedure/char"
   require_relative "rus3/procedure/list"
   require_relative "rus3/procedure/vector"
   require_relative "rus3/procedure/control"
   require_relative "rus3/procedure/write"
 
-  require_relative "rus3/ast"
-  require_relative "rus3/token"
-  require_relative "rus3/lexer"
-  require_relative "rus3/parser"
   require_relative "rus3/evaluator"
   require_relative "rus3/printer"
   require_relative "rus3/repl"

data/lib/rus3/evaluator/environment.rb

@@ -11,6 +11,8 @@ module Rus3
       include Rus3::Procedure::List
       include Rus3::Procedure::Char
       include Rus3::Procedure::Predicate
+      include Rus3::Procedure::Comparison
+      include Rus3::Procedure::Arithmetic
       include Rus3::EmptyList
 
       attr_reader :binding

data/lib/rus3/evaluator/scheme_evaluator.rb

@@ -19,10 +19,9 @@ module Rus3
         super
 
         @env = Environment.new
-        define_procs_for_infix_ops
-
         @translator = Translator.new
-        @translator.add_procedure_map(INFIX_OPS_MAP)
+        @translator.add_procedure_map(ARITHMETIC_OPS_MAP)
+        @translator.add_procedure_map(COMPARISON_OPS_MAP)
       end
 
       def verbose=(verbose)
@@ -48,17 +47,20 @@ module Rus3
         @env.binding
       end
 
-      INFIX_OPS_MAP = {
+      ARITHMETIC_OPS_MAP = {
         "+"  => "add",
         "-"  => "subtract",
         "*"  => "mul",
         "/"  => "div",
         "%"  => "mod",
+      }
+
+      COMPARISON_OPS_MAP = {
         "<"  => "lt?",
         "<=" => "le?",
         ">"  => "gt?",
         ">=" => "ge?",
-        "==" => "eqv?",
+        "=" => "same_value?",
       }
 
       private
@@ -67,13 +69,6 @@ module Rus3
         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

@@ -36,7 +36,8 @@ module Rus3
           pp ast_node
         end
 
-        method_name = "translate_#{ast_node.type}".intern
+        type = ast_node.type.to_s.delete_prefix("ast_")
+        method_name = "translate_#{type}".intern
         begin
           m = method(method_name)
         rescue
@@ -49,6 +50,10 @@ module Rus3
 
       private
 
+      def translate_empty_list(_)
+        EmptyList::EMPTY_LIST.to_s
+      end
+
       def translate_boolean(ast_node)
         case ast_node.literal[0..1]
         when "#f"
@@ -56,7 +61,7 @@ module Rus3
         when "#t"
           "true"
         else
-          raise SchemeSyntaxError.new([:boolean, ast_node.to_s])
+          raise SchemeSyntaxError.new([:ast_boolean, ast_node.to_s])
         end
       end
 
@@ -96,13 +101,6 @@ module Rus3
         "#{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}]"
@@ -113,10 +111,33 @@ module Rus3
         "vector(#{obj_src})"
       end
 
+      def translate_quotation(ast_node)
+        propagate_quotation(ast_node[0])
+      end
+
+      def propagate_quotation(ast_node)
+        case ast_node.type
+        when :ast_list, :ast_procedure_call, :ast_lambda_expression, :ast_conditional, :ast_assignment
+          elements = ast_node.map{|child| propagate_quotation(child)}
+          "[" + elements.join(", ") + "]"
+        when :ast_vector
+          elements = ast_node.map{|child| propagate_quotation(child)}
+          "vector(" + elements.join(", ")  + ")"
+        when :ast_boolean, :ast_character, :ast_string
+          translate(ast_node)
+        when :ast_number
+          translate_number(ast_node)
+        when :ast_identifier
+          ":#{ast_node.to_s}"
+        else
+          raise SchemeSyntaxError.new([ast_node.type, ast_node.to_s])
+        end
+      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
+        if ast_node.operator.type == :ast_lambda_expression
           "#{operator}.call(#{operands})"
         else
           "#{operator}(#{operands})"
@@ -155,32 +176,9 @@ module Rus3
         "#{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
+        if ast_node.expression.type == :ast_lambda_expression
           def_formals = translate_formals(ast_node.expression)
           body = translate_body(ast_node.expression)
           "def #{name}(#{def_formals}); #{body}; end"
@@ -229,11 +227,31 @@ module Rus3
         "#{test_src}; #{exps_src}"
       end
 
+      def translate_case(ast_node)
+        "not implemented yet"
+      end
+
+      def translate_and(ast_node)
+        "not implemented yet"
+      end
+
+      def translate_or(ast_node)
+        "not implemented yet"
+      end
+
+      def translate_when(ast_node)
+        "not implemented yet"
+      end
+
+      def translate_unless(ast_node)
+        "not implemented yet"
+      end
+
       def translate_let(ast_node)
         formals = []
         args = []
 
-        ast_node.bind_specs.each { |spec|
+        ast_node.bindings.each { |spec|
           formals << translate_identifier(spec.identifier)
           args << translate(spec.expression)
         }
@@ -243,6 +261,26 @@ module Rus3
         "lambda{|#{formals.join(', ')}| #{body}}.call(#{args.join(', ')})"
       end
 
+      def translate_let_star(ast_node)
+        "not implemented yet"
+      end
+
+      def translate_letrec(ast_node)
+        "not implemented yet"
+      end
+
+      def translate_letrec_star(ast_node)
+        "not implemented yet"
+      end
+
+      def translate_begin(ast_node)
+        "not implemented yet"
+      end
+
+      def translate_do(ast_node)
+        "not implemented yet"
+      end
+
       RB_KEYWORDS_MAP = {
         "BEGIN"    => nil,
         "END"      => nil,
@@ -295,7 +333,7 @@ module Rus3
         ">=" => "ge",
       }
 
-      EXTENDED_REGEXP = Regexp.new("[#{Rus3::Lexer::EXTENDED_CHARS}]")
+      EXTENDED_REGEXP = Regexp.new("[!\\$%&\\*\\+\\-\\./:<=>\\?@\\^_~]")
 
       EXTENDED_CHARS_MAP = {
         "!" => "!",             # no conversion
@@ -319,16 +357,21 @@ module Rus3
       }
 
       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)
+        case literal
+        when /\A[+\-*\/%=]\Z/, /\A[<>]=?\Z/
+          md = Regexp.last_match
+          @procedure_map[md.to_s]
+        else
+          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
       end
 
       # :startdoc:

data/lib/rus3/printer.rb

@@ -4,23 +4,59 @@ module Rus3
   module Printer
 
     # Indicates the version of the printer module.
-    VERSION = "0.1.0"
+    VERSION = "0.2.1"
 
     class Printer
-      include Rus3::Procedure::Write
-
       attr_accessor :verbose
 
       def initialize
         @verbose = false
       end
 
+      def self.version
+        ""
+      end
+    end
+
+    class RubyPrinter < Printer
+      def print(obj)
+        prefix = "==> "
+        prefix += "[#{obj.class}]: " if @verbose
+        Kernel.print prefix
+        pp obj
+      end
+
+      def self.version
+        "ruby-object-printer :version #{VERSION}"
+      end
+    end
+
+    class SchemePrinter < Printer
+      include Rus3::Procedure::Write
+
       def print(obj)
         display(obj)
       end
 
-      def version
-        "Printer version #{VERSION}"
+      def self.version
+        "scheme-printer :version #{VERSION}"
+      end
+    end
+
+    class ChainPrinter < Printer
+      CHAIN = [RubyPrinter.new, SchemePrinter.new]
+
+      def self.version
+        chain_printers = CHAIN.map{|e| e.class}
+        "chain-printer :version #{VERSION} :chain (#{chain_printers})"
+      end
+
+      def verbose=(flag)
+        CHAIN.each{|printer| printer.verbose = flag}
+      end
+
+      def print(obj)
+        CHAIN.each{|printer| printer.print(obj)}
       end
     end
 

data/lib/rus3/procedure/arithmetic.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Rus3
+  module Procedure
+
+    # This module holds arithmetic operation procedures of Scheme.
+
+    module Arithmetic
+
+      def add(*args)
+        a_calc(:+, *args)
+      end
+
+      def subtract(*args)
+        a_calc(:-, *args)
+      end
+
+      def mul(*args)
+        a_calc(:*, *args)
+      end
+
+      def div(*args)
+        a_calc(:/, *args)
+      end
+
+      def mod(*args)
+        a_calc(:%, *args)
+      end
+
+      private
+
+      def a_calc(op, *args)
+        case args.size
+        when 0
+          0
+        when 1
+          args[0]
+        else
+          a_calc(op, args[0].send(op, args[1]), *args[2..-1])
+        end
+      end
+
+    end
+  end
+end