rus3 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e00bc6347634a3d6fd3ee9da17b18334e49373bab389c9c0126e5ee983504b56
-  data.tar.gz: 369f1e8627bdcb5c8ece22d0ba4971b417fa4924fa67ca31da3665bebb6a3aa8
+  metadata.gz: 8b1f3c9f79ba7f452ff3a2f6d7ec904ac3a1e0ffd836bafd4b4892a8cb0b12ac
+  data.tar.gz: 8c65e739832e954d9ca16fac40e437ca73bb3cddf48c35fbd3eb2f86658d8fd6
 SHA512:
-  metadata.gz: 4eac508d23d36f6f1f7f6b60879bfbb80921c16ed669ed2d60e5d4d8926a62189269c8cef2373e6489d3dae3b47af01ee888116ecd8a85070f84ce3c8493e57a
-  data.tar.gz: ac9f76be872b9a5d70822f4bf0d4fab3da83d931002fd2f7b749648f704e65b7063487f9e9d095630a8c5bb8e9dd2f3e3b24fef3f24338d83e49cc73404a603c
+  metadata.gz: 9b87669992f65b1279ceb003d2767d7ae6173374c6d810c646ee2914643050514c483aadb81cebafbd505fbbea41b89e297e6026f20749e571e84b423bc3cc8c
+  data.tar.gz: fec0ac13faa9880b10f6245d660b3e95430bfcd6cf48a65787634a55fe32c32e4e5f2eeb8f9321467c6a8dede5c03d34d7ab23ef0a0045de698e8bdf821c5534

data/CHANGELOG.md

@@ -5,7 +5,15 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
-- (nothing to record)
+- (nothing to record here)
+
+## [0.2.0] - 2021-05-03
+### Added
+- Re-write the parser and evaluator mechanism.
+- Add tests for SchemeParser and Translator.
+- Add a mechanism to replace comparison operator characters in
+  identifiers.
+  - e.g. `char<?` -> `char_lt?`
 
 ## [0.1.2] - 2021-04-23
 ### Added

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rus3 (0.1.2)
+    rus3 (0.2.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -17,12 +17,7 @@ You can start the Rus3 REPL with the command, `rus3`.
 
 ``` scheme
 > rus3
-A simple REPL for Rus3:
-- Rus3 version: 0.1.0
-  - REPL version: 0.1.0
-    - Parser version 0.1.0 ((scheme-parser-version . 0.1.0) (scheme-lexer-version . 0.1.0))
-    - Evaluator version: 0.1.0
-    - using built-in PRINTER
+A simple REPL to run Rus3:
 Rus3(scheme)>
 ```
 
@@ -32,6 +27,19 @@ In the REPL, you can enter Scheme expressions.  The REPL reads your
 Scheme expressions, translates it to Ruby expressions, and
 evaluated them.  Then, the REPL prints the result after `==> `.
 
+If you want to run verbosely, use "-d" (or "--debug") option, then it
+will become very verbose:
+
+``` scheme
+A simple REPL to run Rus3:
+(rus3 :version 0.2.0 :release 2021-05-02
+  (repl :version 0.2.0
+    (parser-module :version 0.2.0 ((scheme-parser :version 0.2.0) (scheme-lexer :version 0.2.0)))
+    (evaluator-module version: 0.2.0 ((scheme-evaluator :version 0.2.0) (scheme-ruby-translator :version 0.1.0)))
+    (:using :built-in :printer)))
+Rus3(scheme)>
+```
+
 ### Literal of Scheme values
 
 Boolean (`#f` and `#t`), an empty list (`()`), a string, and numbers

data/exe/rus3

@@ -2,17 +2,41 @@
 
 require "rus3"
 
+def usage
+  puts <<HELP
+usage:
+    rus3 [option]
+option:
+    -e, --evaluator NAME : specify evaluator
+    -d, --debug   : specify to run verbose mode
+    -v, --version : print version
+    -h, --help    : show this message
+
+    Following names are available as evaluator name:
+        scheme (use by default), passthrough
+HELP
+end
+
 opts = {}
 
 while ARGV.size > 0
   arg = ARGV.shift
   case arg
+  when "-p", "--parser"
+    parser_name = ARGV.shift
+    opts[:parser] = parser_name
+  when "-e", "--evaluator"
+    evaluator_name = ARGV.shift
+    opts[:evaluator] = evaluator_name
   when "-d", "--debug"
-    opts[:debug] = true
+    opts[:verbose] = true
   when "-v", "--version"
     puts "rus3 version #{Rus3::VERSION} (#{Rus3::RELEASE})"
     exit 0
+  when "-h", "--help"
+    usage
+    exit 0
   end
 end
 
-Rus3::Repl.start(verbose: opts[:debug])
+Rus3::Repl.start(**opts)

data/lib/rus3.rb

@@ -49,6 +49,9 @@ module Rus3
   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"

data/lib/rus3/ast.rb

@@ -0,0 +1,70 @@
+# 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

@@ -0,0 +1,412 @@
+# 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