rus3 0.2.0 → 0.2.1

data/lib/rus3/procedure/comparison.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Rus3
+  module Procedure
+
+    # This module holds comparison operation procedures of Scheme.
+
+    module Comparison
+
+      def lt?(*args)
+        c_calc(:<, *args)
+      end
+
+      def le?(*args)
+        c_calc(:<=, *args)
+      end
+
+      def gt?(*args)
+        c_calc(:>, *args)
+      end
+
+      def ge?(*args)
+        c_calc(:>=, *args)
+      end
+
+      def same_value?(*args)
+        c_calc(:==, *args)
+      end
+
+      private
+
+      def c_calc(op, *args)
+        case args.size
+        when 0, 1
+          raise ArgumentError, args.to_s
+        when 2
+          args[0].send(op, args[1]) ? true : false
+        else
+          args[0].send(op, args[1]) and c_calc(op, *args[1..-1]) ? true : false
+        end
+      end
+
+    end
+  end
+end

data/lib/rus3/repl.rb

@@ -21,13 +21,13 @@ module Rus3
   class Repl
 
     # Indicates the version of the Repl class.
-    REPL_VERSION = "0.2.0"
+    REPL_VERSION = "0.2.1"
 
     class << self
 
       # Starts REPL.
-      def start(parser: nil, evaluator: nil, verbose: false)
-        repl = Repl.new(parser: parser, evaluator: evaluator, verbose: verbose)
+      def start(evaluator: nil, verbose: false)
+        repl = Repl.new(evaluator: evaluator, verbose: verbose)
         repl.loop
       end
 
@@ -35,9 +35,9 @@ module Rus3
 
     # Hods major component names of the REPL.
     COMPONENTS = {
-      :parser    => Parser::DEFAULT_PARSER,
+      :parser    => Rubasteme::Parser,
       :evaluator => Evaluator::DEFAULT_EVALUATOR,
-      :printer   => nil,
+      :printer   => Printer::ChainPrinter,
     }
 
     # Prompt for input.
@@ -51,18 +51,16 @@ module Rus3
     attr_accessor :verbose      # :nodoc:
     attr_accessor :prompt       # :nodoc:
 
-    def initialize(parser: nil, evaluator: nil, verbose: false)
+    def initialize(evaluator: nil, verbose: false)
       comps = COMPONENTS.dup
 
-      comps[:parser] = Parser.const_get("#{parser.capitalize}Parser") if parser
       comps[:evaluator] = Evaluator.const_get("#{evaluator.capitalize}Evaluator") if evaluator
 
       comps.each { |name, klass|
-        instance_variable_set("@#{name}", klass.nil? ? self : klass.new)
+        instance_variable_set("@#{name}", klass.new)
       }
 
       @prompt = PROMPT
-      @parser.prompt = PROMPT
 
       @verbose = verbose
       @evaluator.verbose = verbose
@@ -77,17 +75,18 @@ module Rus3
     end
 
     def loop
-      msg = Kernel.loop {               # LOOP
+      msg = Kernel.loop {       # LOOP
         begin
-          ast = @parser.read(STDIN)     # READ
+          source = read(STDIN)  # READ
+          break FAREWELL_MESSAGE if source.nil?
+          ast = @parser.parse(Rbscmlex::Lexer.new(source))
         rescue SchemeSyntaxError => e
           puts "ERROR" + (@verbose ? "(READ)" : "")  + ": %s" % e
           next
         end
-        break FAREWELL_MESSAGE if ast.nil?
 
         begin
-          value = @evaluator.eval(ast)  # EVAL
+          value = @evaluator.eval(ast) # EVAL
         rescue SyntaxError, StandardError => e
           puts "ERROR" + (@verbose ? "(EVAL)" : "")  + ": %s" % e
           next
@@ -95,7 +94,7 @@ module Rus3
 
         history_push(value)
 
-        @printer.print(value)              # PRINT
+        @printer.print(value)   # PRINT
       }
       puts "#{msg}" unless msg.nil?
     end
@@ -125,28 +124,23 @@ module Rus3
     require "readline"
 
     def read(io = STDIN)
-      Readline::readline(@prompt, true)
-    end
-
-    def eval(ast)
-      ast
-    end
-
-    def print(obj)
-      prefix = "==> "
-      prefix += "[#{obj.class}]: " if @verbose
-      Kernel.print prefix
-      pp obj
+      program_source = nil
+      if io == STDIN
+        program_source = Readline::readline(@prompt, true)
+      else
+        program_source = io.readlines(chomp: true).join(" ")
+      end
+      program_source
     end
 
     private
 
     def version_message(comp_name)
-      vmsg = nil
+      vmsg = ""
       component = instance_variable_get("@#{comp_name}")
-      if component.nil? or component == self
-        vmsg = ":using :built-in :#{comp_name}"
-      else
+      if component.class.respond_to?(:version)
+        vmsg = "#{component.class.version}"
+      elsif component.respond_to?(:version)
         vmsg = "#{component.version}"
       end
       vmsg
@@ -225,7 +219,8 @@ HELP
           scheme_source = File.readlines(path, chomp: true).join(" ")
           result = ast = nil
           if @scm_parser.respond_to?(:parse)
-            ast = @scm_parser.parse(scheme_source)
+            lexer = Rbscmlex::Lexer.new(scheme_source)
+            ast = @scm_parser.parse(lexer)
           end
           if @scm_evaluator.respond_to?(:eval)
             result = @scm_evaluator.eval(ast)

data/lib/rus3/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Rus3
-  VERSION = "0.2.0"
-  RELEASE = "2021-05-03"
+  VERSION = "0.2.1"
+  RELEASE = "2021-05-20"
 end

data/rus3.gemspec

@@ -9,10 +9,10 @@ Gem::Specification.new do |spec|
   spec.email         = ["mnbi@users.noreply.github.com"]
 
   spec.summary       = "Ruby with Syntax Sugar of Scheme"
-  spec.description   = "Ruby with Syntax Sugar of Scheme"
+  spec.description   = "Ruby with Syntax Sugar of Scheme, or Scheme to Ruby translator."
   spec.homepage      = "https://github.com/mnbi/rus3"
   spec.license       = "MIT"
-  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.7.0")
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = "https://github.com/mnbi/rus3"
@@ -27,9 +27,6 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  # Uncomment to register a new dependency of your gem
-  # spec.add_dependency "example-gem", "~> 1.0"
-
-  # For more information and examples about making a new gem, checkout our
-  # guide at: https://bundler.io/guides/creating_gem.html
+  spec.add_dependency "rbscmlex", ">= 0.1.3"
+  spec.add_dependency "rubasteme", ">= 0.1.3"
 end

metadata

@@ -1,16 +1,44 @@
 --- !ruby/object:Gem::Specification
 name: rus3
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - mnbi
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-05-03 00:00:00.000000000 Z
-dependencies: []
-description: Ruby with Syntax Sugar of Scheme
+date: 2021-05-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rbscmlex
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.3
+- !ruby/object:Gem::Dependency
+  name: rubasteme
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.3
+description: Ruby with Syntax Sugar of Scheme, or Scheme to Ruby translator.
 email:
 - mnbi@users.noreply.github.com
 executables:
@@ -33,23 +61,18 @@ files:
 - examples/iota.scm
 - exe/rus3
 - lib/rus3.rb
-- lib/rus3/ast.rb
-- lib/rus3/ast/branch_node.rb
-- lib/rus3/ast/error.rb
-- lib/rus3/ast/leaf_node.rb
 - lib/rus3/char.rb
 - lib/rus3/error.rb
 - lib/rus3/evaluator.rb
 - lib/rus3/evaluator/environment.rb
 - lib/rus3/evaluator/scheme_evaluator.rb
 - lib/rus3/evaluator/translator.rb
-- lib/rus3/lexer.rb
 - lib/rus3/pair.rb
-- lib/rus3/parser.rb
-- lib/rus3/parser/scheme_parser.rb
 - lib/rus3/port.rb
 - lib/rus3/printer.rb
+- lib/rus3/procedure/arithmetic.rb
 - lib/rus3/procedure/char.rb
+- lib/rus3/procedure/comparison.rb
 - lib/rus3/procedure/control.rb
 - lib/rus3/procedure/list.rb
 - lib/rus3/procedure/predicate.rb
@@ -57,7 +80,6 @@ files:
 - lib/rus3/procedure/vector.rb
 - lib/rus3/procedure/write.rb
 - lib/rus3/repl.rb
-- lib/rus3/token.rb
 - lib/rus3/vector.rb
 - lib/rus3/version.rb
 - rus3.gemspec
@@ -76,7 +98,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/rus3/ast.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-module Rus3
-
-  module AST
-
-    require_relative "ast/error"
-
-    module Utils
-      class << self
-        def camel_case(snake_case)
-          snake_case.to_s.split("_").map(&:capitalize).join("")
-        end
-      end
-    end
-
-    class Node
-      attr_reader :literal
-
-      def initialize(literal = nil)
-        @literal = literal
-      end
-
-      def leaf?;    false; end
-      def branch?;  false; end
-      def illegal?; false; end
-
-      def type; nil; end
-
-      def to_s
-        @literal
-      end
-    end
-
-    class IllegalNode < Node
-      def initialize(ast_type, literal)
-        super(literal)
-        @given_type = ast_type
-      end
-
-      def illegal?
-        true
-      end
-
-      def type
-        @given_type
-      end
-
-      def to_s
-        "type: #{@given_type}, literal: #{@literal}"
-      end
-    end
-
-    require_relative "ast/leaf_node"
-    require_relative "ast/branch_node"
-
-    class << self
-      def instantiate(ast_type, literal = nil)
-        klass_name = Utils.camel_case(ast_type) + "Node"
-        klass = AST.const_get(klass_name)
-        if klass.nil? or klass == IllegalNode
-          IllegalNode.new(ast_type, literal)
-        else
-          klass.new(literal)
-        end
-      end
-
-    end
-  end
-end

data/lib/rus3/ast/branch_node.rb

@@ -1,412 +0,0 @@
-# frozen_string_literal: true
-
-module Rus3
-  module AST
-
-    class BranchNode < Node
-      include Enumerable
-
-      def initialize(size = nil)
-        super(nil)
-        @nodes = size.nil? ? [] : Array.new(size)
-      end
-
-      def branch?
-        true
-      end
-
-      def <<(node)
-        @nodes << node
-      end
-
-      def [](index)
-        raise OutOfRangeError, index if index >= @nodes.size
-        @nodes[index]
-      end
-
-      def each(&block)
-        if block.nil?
-          @nodes.each
-        else
-          @nodes.each(&block)
-          self
-        end
-      end
-
-      def to_s
-        @nodes.map(&:to_s).join(" ")
-      end
-
-    end
-
-    class ProgramNode < BranchNode
-      def initialize(_ = nil)
-        super(nil)
-      end
-
-      def type
-        :program
-      end
-    end
-
-    class VectorNode < BranchNode
-      def initialize(_ = nil)
-        super(nil)
-      end
-
-      def type
-        :vector
-      end
-
-      def to_s
-        "#(" + super + ")"
-      end
-    end
-
-    class ListNode < BranchNode
-      def initialize(first_literal = nil, initial_size = nil)
-        super(initial_size)
-        @nodes[0] = IdentifierNode.new(first_literal) if first_literal
-      end
-
-      def type
-        :list
-      end
-
-      def car
-        @nodes[0]
-      end
-
-      def cdr
-        @nodes[1..-1]
-      end
-
-      def to_s
-        "(" + super + ")"
-      end
-    end
-
-    class QuotationNode < ListNode
-      def initialize(_ = nil)
-        super("quote")
-      end
-
-      def type
-        :quotation
-      end
-    end
-
-    class ProcedureCallNode < ListNode
-      def initialize(_ = nil)
-        # @nodes = [<operator>, <operand>*]
-        super(nil, 1)
-      end
-
-      def type
-        :procedure_call
-      end
-
-      def operator
-        @nodes[0]
-      end
-
-      def operator=(node)
-        @nodes[0] = node
-      end
-
-      def operands
-        @nodes[1..-1]
-      end
-
-      def add_operand(node)
-        @nodes << node
-      end
-    end
-
-    class LambdaExpressionNode < ListNode
-      def initialize(_ = nil)
-        # @nodes = [<lambda>, <formals>, <body> ...]
-        super("lambda", 2)
-      end
-
-      def type
-        :lambda_expression
-      end
-
-      def formals
-        @nodes[1]
-      end
-
-      def formals=(list_node)
-        @nodes[1] = list_node
-      end
-
-      def body
-        @nodes[2..-1]
-      end
-
-      def body=(nodes)
-        nodes.each_with_index { |node, i|
-          @nodes[i + 2] = node
-        }
-      end
-    end
-
-    class ConditionalNode < ListNode
-      def initialize(_ = nil)
-        # @nodes = [<if>, <test>, <consequent>] or
-        #          [<if>, <test>, <consequent>, <alternate>]
-        super("if", 3)
-      end
-
-      def type
-        :conditional
-      end
-
-      def test
-        @nodes[1]
-      end
-
-      def consequent
-        @nodes[2]
-      end
-
-      def alternate
-        if @nodes.size > 3
-          @nodes[3]
-        else
-          nil
-        end
-      end
-
-      def test=(node)
-        @nodes[1] = node
-      end
-
-      def consequent=(node)
-        @nodes[2] = node
-      end
-
-      def alternate=(node)
-        @nodes[3] = node
-      end
-    end
-
-    class AssignmentNode < ListNode
-      def initialize(_ = nil)
-        super("set!", 3)
-      end
-
-      def type
-        :assignment
-      end
-
-      def identifier
-        @nodes[1]
-      end
-
-      def identifier=(node)
-        @nodes[1] = node
-      end
-
-      def expression
-        @nodes[2]
-      end
-
-      def expression=(node)
-        @nodes[2] = node
-      end
-    end
-
-    class IdentifierDefinitionNode < ListNode
-      def initialize(_ = nil)
-        super("define", 3)
-      end
-
-      def type
-        :identifier_definition
-      end
-
-      def identifier
-        @nodes[1]
-      end
-
-      def identifier=(node)
-        @nodes[1] = node
-      end
-
-      def expression
-        @nodes[2]
-      end
-
-      def expression=(node)
-        @nodes[2] = node
-      end
-
-      def def_formals
-        if lambda?
-          expression.formals
-        else
-          nil
-        end
-      end
-
-      def body
-        if lambda?
-          expression.body
-        else
-          nil
-        end
-      end
-
-      private
-
-      def lambda?
-        expression.type == :lambda_expression
-      end
-
-    end
-
-    class SyntaxDefinitionNode < ListNode
-      def type
-        :syntax_definition
-      end
-
-    end
-
-    class ValuesDefinitionNode < ListNode
-      def type
-        :values_definition
-      end
-
-    end
-
-    class RecordTypeDefinitionNode < ListNode
-      def type
-        :record_type_definition
-      end
-
-    end
-
-    class MacroBlockNode < ListNode
-      def initialize(literal)
-        super(literal)
-      end
-
-      def type
-        :macro_block
-      end
-
-    end
-
-    class CondNode < ListNode
-      def initialize(_ = nil)
-        super("cond")
-      end
-
-      def type
-        :cond
-      end
-
-      def cond_clauses
-        @nodes[1..-1]
-      end
-
-      def add_clause(node)
-        @nodes << node
-      end
-    end
-
-    class CondClauseNode < ListNode
-      def initialize(_ = nil)
-        super(nil, 1)
-      end
-
-      def type
-        :cond_clause
-      end
-
-      def test
-        @nodes[0]
-      end
-
-      def test=(node)
-        @nodes[0] = node
-      end
-
-      def sequence
-        @nodes[1..-1]
-      end
-
-      def add_expression(node)
-        @nodes << node
-      end
-    end
-
-    class LetNode < ListNode
-      def initialize(_ = nil)
-        super("let", 2)
-      end
-
-      def type
-        :let
-      end
-
-      def bind_specs
-        @nodes[1]
-      end
-
-      def bind_specs=(node)
-        @nodes[1] = node
-      end
-
-      def body
-        @nodes[2..-1]
-      end
-
-      def body=(nodes)
-        nodes.each_with_index { |node, i|
-          @nodes[i + 2] = node
-        }
-      end
-    end
-
-    class BindSpecNode < ListNode
-      def initialize(_ = nil)
-        super(nil, 2)
-      end
-
-      def type
-        :bind_spec
-      end
-
-      def identifier
-        @nodes[1]
-      end
-
-      def identifier=(node)
-        @nodes[1] = node
-      end
-
-      def expression
-        @nodes[2]
-      end
-
-      def expression=(node)
-        @nodes[2] = node
-      end
-    end
-
-    class AndNode < ListNode
-      def initialize(_ = nil)
-        super("and")
-      end
-
-      def type
-        :and
-      end
-
-    end
-
-  end
-end