rubasteme 0.1.1 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f983bac291b02cde63445a66509273604d6f64fabb7c833d24e7430f5605962d
-  data.tar.gz: 9a08587175a838efb7572f17185e22891d58dc68cf9dacfd497d2ef1dd06bca2
+  metadata.gz: 64c7c931d6ce0f30b29ef9333c9e7152abce225dce5a97d735341b6d62e6b331
+  data.tar.gz: 761c91ab6bf8b418a9bf2f6949fd48e0155b7014ea0d38c0587b2afb014c5614
 SHA512:
-  metadata.gz: 18df612e9ba4413f7e256e07e0227ac09a81db6926ff432d04d8e3c8742141479daa897e6f67e571b6e9c5d2e4ab93ab80eac30db0811a8dcd653c4b46d949c4
-  data.tar.gz: 5b89ff08b4e4567b441aa50d0000e8237ea631d8987e4f4fb8dbe09109ed25d6f168751d72088867da2f441c65febc787951426a6276165d688a85742b157572
+  metadata.gz: 317a934288b9dc1df0001b15b923ba385801bcee0359178a050c64380192d8bb212a2328138db9c92ab75f2b41d427956a9f2777d3835677de0ed37c08da0c10
+  data.tar.gz: 972222e1ea19919cf532c909ffef26639da2b5534ff73d296a046c8eac222328a3d11d71af5c2f2d7453c7ea3e477c54fd3d9ac17e8261d838cab05e93f44df9

data/CHANGELOG.md

@@ -1,6 +1,41 @@
 ## [Unreleased]
 - (nothing to record here)
 
+## [0.1.6] - 2021-06-09
+### Fixed:
+- Fix #8: cannot generate a procedure call node if operator is a
+  lambda expression.
+
+## [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:

data/examples/mini_rus3

@@ -155,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
 
@@ -172,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}"
@@ -184,7 +189,7 @@ class Evaluator
 
 end
 
-parser = Rubasteme::Parser.new
+parser = Rubasteme.parser
 evaluator = Evaluator.new
 
 require "readline"

data/examples/mini_sicp_scheme

@@ -25,7 +25,7 @@ module SicpScheme
 
   def self.repl(prompt)
     env = TOPLEVEL_ENV
-    parser = Rubasteme::Parser.new
+    parser = Rubasteme.parser
     evaluator = Evaluator.new
     printer = Printer.new
 

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