rubasteme 0.1.0 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7318849fdcbcfd2daa359998f303bba5c27429bce2a36f06e9beddf05d26ba8a
-  data.tar.gz: 0037b93486d56d45c125ec47aa5417de6f61dbb6519679154974ac039206a738
+  metadata.gz: 55b3523ac9cea424c63244acb962f5a8c282515339cbf957ff34bd691ff3d5ef
+  data.tar.gz: 25f8653c598ac0cb61d3fd3c8277548f4b0ea033bc4d2fdb37fbab81efd8642f
 SHA512:
-  metadata.gz: 10e44958db29f64d4b17e0db107756e8952393941b7305f9b32adf79b5f71ca18faa234d99cf24ceb5d6da6023e4855260998d16c50d105d002645d80231aa15
-  data.tar.gz: 7abdcb827afb2cbbe428e1ac59167d98f21c07ab83046e212cd48af734cc4245f32de39f7b36741f46a740f8787e1b08c981f91dce62154070704140ff0f463c
+  metadata.gz: 0b35c5f9339f74b843a2d19977fb1a5e08e0e018b59b699bd4d58f88ee7d541f24be08054bd5d5e96e48c9bfcf5995e441df330cbbe33e7990ee61e7824c6e70
+  data.tar.gz: 531caab37c793ebcef980fe0f146158871c374a47e6eca90778d7bba05de3d6834d51f4d169f8f13b6b9c96ab7a9129b7ee60658116005080afb2fccd074176e

data/CHANGELOG.md

@@ -1,5 +1,43 @@
 ## [Unreleased]
 - (nothing to record here)
 
+## [0.1.5] - 2021-06-09
+### Added
+- Add a new node to represent `case` expression and its parsing.
+
+### Changed
+- Refactor parser to parse in 2 phases.
+
+### Fixed
+- Fix #5: incorrect parsing with internal definition at wrong
+  position.
+
+## [0.1.4] - 2021-05-31
+### Added
+- Add a new node to represent sequence. (#3)
+- Incorporate missing methods to ListNode from rbsiev project.
+
+### Fixed
+- Fix #2: typo in the version string.
+
+## [0.1.3] - 2021-05-20
+### Fixed
+- Change a method name of AST::CondNode.
+  - `#cond_clause` -> `#cond_clauses`
+- Modify the timing to pass lexer to parser in `exe/rubasteme`.
+- Fix #1: `:ast_vector` is missing in AST::AST_NODE_TYPE.
+
+## [0.1.2] - 2021-05-20
+### Added
+- Add a singleton method, `version` to Parser class.
+
+## [0.1.1] - 2021-05-20
+### Changed
+- Change the timing to pass a lexer instance to a Parser object:
+  - 0.1.0: initialize Parser object,
+    - `Parser.new(lexer)`
+  - 0.1.1: call parser method.
+    - `parser = Parser.new; parser.parse(lexer)`
+
 ## [0.1.0] - 2021-05-20
 - Initial release

data/examples/mini_rus3

@@ -47,9 +47,25 @@ class Evaluator
       @env.receiver.instance_eval("def #{proc_name}(op1, op2); op1 #{op} op2; end")
     }
     @env.receiver.instance_eval {
+      def list(*objs)
+        objs
+      end
+
+      def append(*lists)
+        if lists.empty?
+          []
+        else
+          lists[0] + append(*lists[1..-1])
+        end
+      end
+
       def display(obj)
         pp obj
       end
+
+      def zero?(obj)
+        obj == 0
+      end
     }
   end
 
@@ -74,7 +90,7 @@ class Evaluator
   def translate(ast_node)
     case ast_node.type
     when :ast_empty_list
-      ast_node.literal
+      "[]"
     when :ast_boolean
       (ast_node.literal[1] == "f") ? "false" : "true"
     when :ast_identifier
@@ -82,7 +98,13 @@ class Evaluator
     when :ast_string
       ast_node.literal
     when :ast_number
-      ast_node.literal
+      case ast_node.literal
+      when /([^\/]+)\/([^\/]+)/
+        md = Regexp.last_match
+        "Rational(#{md[1]}, #{md[2]})"
+      else
+        ast_node.literal
+      end
     when :ast_procedure_call
       translate_procedure_call(ast_node)
     when :ast_lambda_expression
@@ -133,7 +155,7 @@ class Evaluator
 
   def translate_lambda_expression(ast_node)
     formals = ast_node.formals.map{|e| translate(e)}.join(",")
-    body = ast_node.body.map{|e| translate(e)}.join("; ")
+    body = ast_node.body.sequence.map{|e| translate(e)}.join("; ")
     "lambda{|#{formals}|#{body}}"
   end
 
@@ -150,10 +172,15 @@ class Evaluator
   def translate_identifier_definition(ast_node)
     name = translate(ast_node.identifier)
     if ast_node.expression.type == :ast_lambda_expression
+      src = ""
       node = ast_node.expression
       formals = node.formals.map{|e| translate(e)}.join(", ")
-      body = node.body.map{|e| translate(e)}.join("; ")
-      "def #{name}(#{formals}); #{body}; end"
+      unless node.body.definitions.empty?
+        src += node.body.definitions.map{|e| translate(e)}.join("; ")
+        src += "; "
+      end
+      body = node.body.sequence.map{|e| translate(e)}.join("; ")
+      src + "def #{name}(#{formals}); #{body}; end"
     else
       value = translate(ast_node.expression)
       "#{name} = #{value}"
@@ -162,6 +189,7 @@ class Evaluator
 
 end
 
+parser = Rubasteme.parser
 evaluator = Evaluator.new
 
 require "readline"
@@ -183,8 +211,7 @@ msg = loop {
   end
 
   lexer = Rbscmlex::Lexer.new(source, form: :token)
-  parser = Rubasteme.parser(lexer)
-  ast_program = parser.parse
+  ast_program = parser.parse(lexer)
 
   result = evaluator.eval(ast_program)
 

data/examples/mini_sicp_scheme

@@ -25,6 +25,7 @@ module SicpScheme
 
   def self.repl(prompt)
     env = TOPLEVEL_ENV
+    parser = Rubasteme.parser
     evaluator = Evaluator.new
     printer = Printer.new
 
@@ -44,8 +45,7 @@ module SicpScheme
       end
 
       lexer = Rbscmlex::Lexer.new(source, form: :token)
-      parser = Rubasteme.parser(lexer)
-      exp = parser.parse.to_a
+      exp = parser.parse(lexer).to_a
 
       result = evaluator.eval(exp, env)
 

data/examples/sicp_scheme/evaluator.rb

@@ -43,6 +43,9 @@ module SicpScheme
       when *EV_IF
         eval_if(exp, env)
       when *EV_LAMBDA
+        internal_definitions(exp).each { |d|
+          eval_definition(d, env)
+        }
         make_procedure(lambda_parameters(exp),
                        lambda_body(exp),
                        env)
@@ -199,8 +202,9 @@ module SicpScheme
     end
 
     def begin_actions(exp)
-      # exp = [:ast_begin, [:ast_*_1], [:ast_*_2], ... ]
-      exp[1..-1]
+      # exp = [:ast_begin, [:ast_sequence]]
+      # sequence = [:ast_sequence, [:ast_*_1], [:ast_*_2], ...]
+      exp[1][1..-1]
     end
 
     def eval_sequence(exps, env)
@@ -241,15 +245,24 @@ module SicpScheme
       exp[2]
     end
 
+    def internal_definitions(exp)
+      # exp = [:ast_lambda_expression, [:ast_formals], [:ast_body]]
+      # body = [:ast_body, [:ast_internal_definitions], [:ast_sequence]]
+      # internal_definitions = [:ast_intern_definitions, [:ast_definition], ...]
+      exp[2][1][1..-1]
+    end
+
     def lambda_parameters(exp)
-      # exp = [:ast_lambda_expression, [:ast_formals], [:ast_*_1] ...]
+      # exp = [:ast_lambda_expression, [:ast_formals], [:ast_body]]
       formals = exp[1][1..-1]
       formals.map{|node| identifier(node)}
     end
 
     def lambda_body(exp)
-      # exp = [:ast_lambda_expression, [:ast_formals], [:ast_*_1] ...]
-      exp[2..-1]
+      # exp = [:ast_lambda_expression, [:ast_formals], [:ast_body]]
+      # body = [:ast_body, [:ast_internal_definitions], [:ast_sequence]]
+      # sequence = [:ast_sequence, [:ast_*_1], [:ast_*_2], ...]
+      exp[2][2][1..-1]
     end
 
     def make_procedure(parameters, body, env)

data/exe/rubasteme

@@ -73,8 +73,8 @@ end
 
 tokens = lines.map{|e| Kernel.eval(e)}
 lexer = Rubasteme.lexer(tokens)
-parser = Rubasteme.parser(lexer)
-ast = parser.parse
+parser = Rubasteme.parser
+ast = parser.parse(lexer)
 
 output = ""
 PP.pp(ast.to_a, output)

data/lib/rbscmlex/missing.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Rbscmlex
+
+  # :stopdoc:
+  EMSG = {
+    unexpected_token_type: "unexpected token type: got=%s, expected=%s",
+    missing_right_parenthesis: "missing right parenthesis",
+  }
+  # :startdoc:
+
+  # Indicates a token is not expected one.
+  class UnexpectedTokenTypeError < Error
+    def initialize(got, expected = nil)
+      super(EMSG[:unexpected_token_type] % [got, expected])
+    end
+  end
+
+  # Indicates a mismatch of parenthesizes.
+  class MissingRightParenthesisError < Error
+    def initialize
+      super(EMSG[:missing_right_parenthesis])
+    end
+  end
+
+  class Lexer
+
+    def skip_lparen(offset = 0)
+      if peek_token(offset).type == :lparen
+        skip_token(offset)
+      else
+        raise UnexpectedTokenTypeError.new(peek_token(offset).type, :lparen)
+      end
+    end
+
+    def skip_rparen(offset = 0)
+      if peek_token(offset).type == :rparen
+        skip_token(offset)
+      else
+        raise MissingRightParenthesisError
+      end
+    end
+
+  end
+
+end

data/lib/rubasteme.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "rbscmlex"
+require_relative "rbscmlex/missing"
 
 module Rubasteme
 
@@ -8,6 +9,10 @@ module Rubasteme
     Rbscmlex::Lexer.new(obj)
   end
 
+  def self.parse(source)
+    parser.parse(lexer(source))
+  end
+
   require_relative "rubasteme/error"
   require_relative "rubasteme/utils"
   require_relative "rubasteme/ast"

data/lib/rubasteme/ast.rb

@@ -19,17 +19,27 @@ module Rubasteme
       :ast_dot,
       # branch
       :ast_program,
+      :ast_vector,
       :ast_list,
       :ast_quotation,
       :ast_procedure_call,
       :ast_lambda_expression,
       :ast_formals,
+      :ast_body,
+      :ast_internal_definitions,
+      :ast_sequence,
       :ast_conditional,
       :ast_assignment,
       :ast_identifier_definition,
       :ast_cond,
       :ast_cond_clause,
+      :ast_cond_recipient_clause,
+      :ast_else_clause,
       :ast_case,
+      :ast_case_clause,
+      :ast_data,
+      :ast_case_recipient_clause,
+      :ast_else_recipient_clause,
       :ast_and,
       :ast_or,
       :ast_when,
@@ -49,7 +59,7 @@ module Rubasteme
       :ast_illegal,
     ]
 
-    def self.instantiate(ast_node_type, literal)
+    def self.instantiate(ast_node_type, literal = nil)
       type_name = Utils.camel_case(ast_node_type.to_s.delete_prefix("ast_"))
       klass = AST.const_get("#{type_name}Node")
 

data/lib/rubasteme/ast/branch_node.rb

@@ -55,21 +55,37 @@ module Rubasteme
     end
 
     class ListNode < BranchNode
-      def initialize(_ = nil)
-        super(nil)
+      def initialize(initial_size = 0, _ = nil)
+        super(initial_size)
+      end
+
+      def empty?
+        @nodes.empty?
+      end
+
+      def first
+        @nodes[0]
+      end
+
+      def rest
+        @nodes[1..-1]
+      end
+
+      def elements
+        @nodes
       end
     end
 
     class QuotationNode < ListNode
       def initialize(_ = nil)
-        super(nil)
+        super(0, nil)
       end
     end
 
     class ProcedureCallNode < ListNode
       def initialize(_ = nil)
         # @nodes = [<operator>, <operand>*]
-        super(1)
+        super(1, _)
       end
 
       def operator
@@ -91,8 +107,8 @@ module Rubasteme
 
     class LambdaExpressionNode < ListNode
       def initialize(_ = nil)
-        # @nodes = [<formals>, <body>, ...]
-        super(1)
+        # @nodes = [<formals>, <body>]
+        super(2, _)
       end
 
       def formals
@@ -104,20 +120,18 @@ module Rubasteme
       end
 
       def body
-        @nodes[1..-1]
+        @nodes[1]
       end
 
-      def body=(nodes)
-        nodes.each_with_index { |node, i|
-          @nodes[i + 1] = node
-        }
+      def body=(node)
+        @nodes[1] = node
       end
     end
 
     class FormalsNode < ListNode
       def initialize(_ = nil)
         # @nodes = [<identifier 1>, <identifier 2>, ... ]
-        super(nil)
+        super(0, nil)
       end
 
       def add_identifier(node)
@@ -125,11 +139,64 @@ module Rubasteme
       end
     end
 
+    class HoldingSequenceBaseNode < ListNode
+      def initialize(initial_size = 0, sequence_pos = 0, _ = nil)
+        # @nodes = [..., <sequence>, ...]
+        super(initial_size, _)
+        @sequence_pos = sequence_pos
+      end
+
+      def sequence
+        @nodes[@sequence_pos]
+      end
+
+      def sequence=(node)
+        @nodes[@sequence_pos] = node
+      end
+    end
+
+    class BodyNode < HoldingSequenceBaseNode
+      def initialize(_ = nil)
+        # @nodes = [<definitions>, <sequence>]
+        super(2, 1, _)
+      end
+
+      def definitions
+        @nodes[0]
+      end
+
+      def definitions=(node)
+        @nodes[0] = node
+      end
+    end
+
+    class InternalDefinitionsNode < ListNode
+      def initialize(_ = nil)
+        # @nodes = [<definition 1>, <definition 2>, ... ]
+        super(0, nil)
+      end
+
+      def add_definition(node)
+        @nodes << node
+      end
+    end
+
+    class SequenceNode < ListNode
+      def initialize(_ = nil)
+        # @nodes = [<expression 1>, <expression 2>, ... ]
+        super(0, _)
+      end
+
+      def add_expression(node)
+        @nodes << node
+      end
+    end
+
     class ConditionalNode < ListNode
       def initialize(_ = nil)
         # @nodes = [<test>, <consequent>] or
         #          [<test>, <consequent>, <alternate>]
-        super(1)
+        super(2, _)
       end
 
       def test
@@ -164,7 +231,7 @@ module Rubasteme
     class AssignmentNode < ListNode
       def initialize(_ = nil)
         # @nodes = [<identifier>, <expression>]
-        super(2)
+        super(2, _)
       end
 
       def identifier
@@ -188,7 +255,7 @@ module Rubasteme
       def initialize(_ = nil)
         # @nodes = [<identifier>, <expression>]
         #   <expression> might be a lambda expression.
-        super(2)
+        super(2, _)
       end
 
       def identifier
@@ -224,10 +291,10 @@ module Rubasteme
 
     class CondNode < ListNode
       def initialize(_ = nil)
-        super(nil)
+        super(0, _)
       end
 
-      def cond_clause
+      def cond_clauses
         @nodes[0..-1]
       end
 
@@ -236,10 +303,12 @@ module Rubasteme
       end
     end
 
-    class CondClauseNode < ListNode
-      # @nodes = [<test>, <sequence>]
+    class CondClauseNode < HoldingSequenceBaseNode
       def initialize(_ = nil)
-        super(nil)
+        # type 1: @nodes = [<test>, <sequence>]
+        # type 2: @nodes = [<test>]
+        #   - <sequence> is empty
+        super(2, 1, _)
       end
 
       def test
@@ -249,33 +318,135 @@ module Rubasteme
       def test=(node)
         @nodes[0] = node
       end
+    end
 
-      def sequence
+    class RecipientClauseBaseNode < ListNode
+      def initialize(initial_size = 0, recipient_pos = 0, _ = nil)
+        # @nodes = [<recipient>]
+        # <recipient> -> <expression>
+        super(initial_size, _)
+        @recipient_pos = recipient_pos
+      end
+
+      def recipient
+        @nodes[@recipient_pos]
+      end
+
+      def recipient=(node)
+        @nodes[@recipient_pos] = node
+      end
+    end
+
+    class CondRecipientClauseNode < RecipientClauseBaseNode
+      def initialize(_ = nil)
+        # <cond clause> -> ( <test> => <recipient> )
+        # @nodes = [<test>, <recipient>]
+        super(2, 1, _)
+      end
+
+      def test
+        @nodes[0]
+      end
+
+      def test=(node)
+        @nodes[0] = node
+      end
+    end
+
+    class ElseClauseNode < HoldingSequenceBaseNode
+      def initialize(_ = nil)
+        # @nodes = [<sequence>]
+        super(1, 0, _)
+      end
+    end
+
+    class CaseNode < ListNode
+      def initialize(_ = nil)
+        # @nodes = [<expression>, <case caluse>, ... <else clause>]
+        super(1, _)
+      end
+
+      def expression
+        @nodes[0]
+      end
+
+      def expression=(node)
+        @nodes[0] = node
+      end
+
+      def case_clauses
         @nodes[1..-1]
       end
 
-      def add_expression(node)
+      def add_clause(node)
         @nodes << node
       end
     end
 
+    class CaseClauseNode < HoldingSequenceBaseNode
+      def initialize(_ = nil)
+        # @nodes = [<data>, <sequence>]
+        super(2, 1, _)
+      end
+
+      def data
+        @nodes[0]
+      end
+
+      def data=(node)
+        @nodes[0] = node
+      end
+    end
+
+    class DataNode < ListNode
+      def initialize(_ = nil)
+        # @nodes = [<datum>, ...]
+        super(0, _)
+      end
+    end
+
+    class CaseRecipientClauseNode < RecipientClauseBaseNode
+      def initialize(_ = nil)
+        # ( ( <datum>* ) => <recipient> )
+        # @nodes = [<data>, <recipient>]
+        super(2, 1, _)
+      end
+
+      def data
+        @nodes[0]
+      end
+
+      def data=(node)
+        @nodes[0] = node
+      end
+    end
+
+    class ElseRecipientClauseNode < RecipientClauseBaseNode
+      def initialize(_ = nil)
+        # ( else => <recipient> )
+        # @nodes = [<recipient>]
+        super(1, 0, _)
+      end
+    end
+
     class AndNode < ListNode
       def initialize(_ = nil)
         # @nodes = [<test>, ...]
-        super(nil)
+        super(0, _)
       end
     end
 
     class OrNode < ListNode
       def initialize(_ = nil)
         # @nodes = [<test>, ...]
-        super(nil)
+        super(0, _)
       end
     end
 
-    class TestAndSequenceNode < ListNode
+    class TestAndSequenceBaseNode < HoldingSequenceBaseNode
       def initialize(_ = nil)
-        super(1)
+        # @nodes = [<test>, <sequence>]
+        super(2, 1, _)
       end
 
       def test
@@ -285,27 +456,19 @@ module Rubasteme
       def test=(node)
         @nodes[0] = node
       end
-
-      def sequence
-        @nodes[1..-1]
-      end
-
-      def add_sequence(node)
-        @nodes << node
-      end
     end
 
-    class WhenNode < TestAndSequenceNode
+    class WhenNode < TestAndSequenceBaseNode
     end
 
-    class UnlessNode < TestAndSequenceNode
+    class UnlessNode < TestAndSequenceBaseNode
     end
 
     class LetNode < ListNode
       def initialize(_ = nil)
-        # @nodes = [<bindings>, <body>, ...] or
-        #          [<identifier>, <bindings>, <body>, ...]
-        super(1)
+        # @nodes = [<bindings>, <body>] or
+        #          [<identifier>, <bindings>, <body>]
+        super(1, _)
       end
 
       def identifier
@@ -329,14 +492,12 @@ module Rubasteme
       end
 
       def body
-        named_let? ? @nodes[2..-1] : @nodes[1..-1]
+        named_let? ? @nodes[2] : @nodes[1]
       end
 
-      def body=(nodes)
+      def body=(node)
         start_pos = named_let? ? 2 : 1
-        nodes.each_with_index { |node, i|
-          @nodes[start_pos + i] = node
-        }
+        @nodes[start_pos] = node
       end
 
       private
@@ -348,8 +509,8 @@ module Rubasteme
 
     class LetBaseNode < ListNode
       def initialize(_ = nil)
-        # @nodes = [<bindings>, <body>, ...]
-        super(1)
+        # @nodes = [<bindings>, <body>]
+        super(2, _)
       end
 
       def bindings
@@ -361,13 +522,11 @@ module Rubasteme
       end
 
       def body
-        @nodes[1..-1]
+        @nodes[1]
       end
 
-      def body=(nodes)
-        nodes.each_with_index { |node, i|
-          @nodes[1 + i] = node
-        }
+      def body=(node)
+        @nodes[1] = node
       end
     end
 
@@ -383,7 +542,7 @@ module Rubasteme
     class BindingsNode < ListNode
       def initialize(_ = nil)
         # @nodes = [<bind spec 1>, <bind spec 2> , ...]
-        super(nil)
+        super(0, _)
       end
 
       def add_bind_spec(node)
@@ -393,7 +552,7 @@ module Rubasteme
 
     class BindSpecNode < ListNode
       def initialize(_ = nil)
-        super(2)
+        super(2, _)
       end
 
       def identifier
@@ -413,16 +572,17 @@ module Rubasteme
       end
     end
 
-    class BeginNode < ListNode
+    class BeginNode < HoldingSequenceBaseNode
       def initialize(_ = nil)
-        super(nil)
+        # @nodes = [<sequnece>]
+        super(1, 0, _)
       end
     end
 
     class DoNode < ListNode
       def initialize(_ = nil)
         # @nodes = [<iteration bindings>, <test and do result>, <command>, ...]
-        super(2)
+        super(2, _)
       end
 
       def iteration_bindings
@@ -452,7 +612,7 @@ module Rubasteme
 
     class IterationBindingsNode < ListNode
       def initialize(_ = nil)
-        super(nil)
+        super(0, _)
       end
 
       def add_iteration_spec(node)
@@ -460,28 +620,14 @@ module Rubasteme
       end
     end
 
-    class TestAndDoResultNode < ListNode
-      def initialize(_ = nil)
-        super(1)
-      end
-
-      def test
-        @nodes[0]
-      end
-
-      def test=(node)
-        @nodes[0] = node
-      end
-
-      def add_expression(node)
-        @nodes << node
-      end
+    class TestAndDoResultNode < TestAndSequenceBaseNode
     end
 
     class IterationSpecNode < ListNode
       def initialize(_ = nil)
-        # @nodes = [<identifier>, <init>, <step>]
-        super(3)
+        # 1. @nodes = [<identifier>, <init>, <step>]
+        # 2. @nodes = [<identifier>, <init>]
+        super(2, _)
       end
 
       def identifier