rubasteme 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ae403f48775a21a957a932a5a4ca6c8ba57a2a599e67a7dc1b3073c90979fda0
-  data.tar.gz: 7f8b072b65a9011b3ba0bc010b58608d5c21bff9996279494f8e562ef4e6aa2d
+  metadata.gz: db8dd40c792c40ff4b5a60cfdf1e1ca6ec79384fc4b2fc773f4ed6b0882d1bc0
+  data.tar.gz: 2fec3b113e8fb7ed3da8199102b8df2999dafd116666586fc4405b8a21dd539b
 SHA512:
-  metadata.gz: d99c7be0fab343b682c27bf8eae4ae6b57c7378cc83b106471902ae0c7fc320f69183d9c81f03541c52984792b87c0a88d57ce6ba0cd3b65436505717b25ed8a
-  data.tar.gz: 70a04f9e03e44b7e4fb6c057fde7355acd27efc7b21522f408264791cf60786b22858e0d04d4a49a96af438dde4090be9d2fdf241ebdcd9fd421f3607aa8c51a
+  metadata.gz: ca78d9e9ae1c06e7e0cb19bf313f7e2fe6aa8e407d0927b77d8a86c7a1414dea44937924058fbb66c812804a66753891c508d155c3826cced645b813ba376845
+  data.tar.gz: 005c8b48680a091d3a8867341a5cc4e845ec7b0b299b0d862cea9830cd9c9b20951cf49ef7da2c917e5a1df0c3666cdc34bf5a4598c92ec4de4d8c8eff97d5a0

data/CHANGELOG.md

@@ -1,6 +1,14 @@
 ## [Unreleased]
 - (nothing to record here)
 
+## [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.

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}"

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/lib/rubasteme/ast.rb

@@ -25,12 +25,18 @@ module Rubasteme
       :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_else_clause,
+      :ast_cond_recipient_clause,
       :ast_case,
+      :ast_else_recipient_clause,
       :ast_and,
       :ast_or,
       :ast_when,

data/lib/rubasteme/ast/branch_node.rb

@@ -58,6 +58,22 @@ module Rubasteme
       def initialize(_ = nil)
         super(nil)
       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
@@ -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,13 +120,11 @@ 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
 
@@ -125,6 +139,59 @@ 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(nil)
+      end
+
+      def add_definition(node)
+        @nodes << node
+      end
+    end
+
+    class SequenceNode < ListNode
+      def initialize(_ = nil)
+        # @nodes = [<expression 1>, <expression 2>, ... ]
+        super(nil)
+      end
+
+      def add_expression(node)
+        @nodes << node
+      end
+    end
+
     class ConditionalNode < ListNode
       def initialize(_ = nil)
         # @nodes = [<test>, <consequent>] or
@@ -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,13 +318,53 @@ module Rubasteme
       def test=(node)
         @nodes[0] = node
       end
+    end
+
+    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 sequence
-        @nodes[1..-1]
+      def recipient
+        @nodes[@recipient_pos]
       end
 
-      def add_expression(node)
-        @nodes << node
+      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 ElseRecipientClauseNode < RecipientClauseBaseNode
+      def initialize(_ = nil)
+        # ( else => <recipient> )
+        # @nodes = [<recipient>]
+        super(1, 0)
       end
     end
 
@@ -273,9 +382,10 @@ module Rubasteme
       end
     end
 
-    class TestAndSequenceNode < ListNode
+    class TestAndSequenceBaseNode < HoldingSequenceBaseNode
       def initialize(_ = nil)
-        super(1)
+        # @nodes = [<test>, <sequence>]
+        super(2, 1, _)
       end
 
       def test
@@ -285,26 +395,18 @@ 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>, ...]
+        # @nodes = [<bindings>, <body>] or
+        #          [<identifier>, <bindings>, <body>]
         super(1)
       end
 
@@ -329,14 +431,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 +448,8 @@ module Rubasteme
 
     class LetBaseNode < ListNode
       def initialize(_ = nil)
-        # @nodes = [<bindings>, <body>, ...]
-        super(1)
+        # @nodes = [<bindings>, <body>]
+        super(2)
       end
 
       def bindings
@@ -361,13 +461,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
 
@@ -413,9 +511,10 @@ module Rubasteme
       end
     end
 
-    class BeginNode < ListNode
+    class BeginNode < HoldingSequenceBaseNode
       def initialize(_ = nil)
-        super(nil)
+        # @nodes = [<sequnece>]
+        super(1, 0, _)
       end
     end
 

data/lib/rubasteme/parser.rb

@@ -9,7 +9,7 @@ module Rubasteme
   class Parser
 
     def self.version
-      "rubasteme.parser :version #{VERSION} :relase #{RELEASE}"
+      "(rubasteme.parser :version #{VERSION} :release #{RELEASE})"
     end
 
     def initialize
@@ -187,7 +187,7 @@ module Rubasteme
 
     def parse_lambda_expression
       @lexer.skip_token         # skip :lambda
-      lambda_node = make_lambda_expression_node(parse_formals, read_body)
+      lambda_node = make_lambda_expression_node(parse_formals, parse_body)
       skip_rparen
       lambda_node
     end
@@ -219,15 +219,33 @@ module Rubasteme
       formals_node
     end
 
-    def read_body
-      body = []
+    def parse_body
+      body = AST.instantiate(:ast_body, nil)
+
+      definitions = AST.instantiate(:ast_internal_definitions, nil)
+      body.definitions = definitions
+
+      # read definitions
       Kernel.loop {
         break if @lexer.peek_token.type == :rparen # the end of lambda exp.
-        body << parse_expression
+        break unless is_definition?
+        body.definitions.add_definition(parse_expression)
       }
+
+      body.sequence = parse_sequence
       body
     end
 
+    def parse_sequence
+      seq_node = AST.instantiate(:ast_sequence, nil)
+      Kernel.loop {
+        break if @lexer.peek_token.type == :rparen # the end of parent list
+        exp = parse_expression
+        seq_node.add_expression(exp)
+      }
+      seq_node
+    end
+
     def parse_conditional
       if_node = AST.instantiate(:ast_conditional, @lexer.next_token.literal)
       if_node.test = parse_test
@@ -263,6 +281,22 @@ module Rubasteme
       not_implemented_yet("MACRO block")
     end
 
+    DEFINITION_IDENTIFIERS = [
+      "define",
+      "define-syntax",
+      "define-values",
+      "define-record-type",
+    ]
+
+    def is_definition?
+      if @lexer.peek_token.type == :lparen
+        type, literal = *@lexer.peek_token(1)
+        type == :identifier and DEFINITION_IDENTIFIERS.include?(literal)
+      else
+        false
+      end
+    end
+
     def parse_definition
       case @lexer.peek_token.literal
       when "define"
@@ -302,7 +336,7 @@ module Rubasteme
         }
         skip_rparen
 
-        lambda_node = make_lambda_expression_node(def_formals_node, read_body)
+        lambda_node = make_lambda_expression_node(def_formals_node, parse_body)
         skip_rparen
 
         define_node.expression = lambda_node
@@ -352,18 +386,50 @@ module Rubasteme
 
     def parse_cond_clause
       skip_lparen
-      clause_node = AST.instantiate(:ast_cond_clause, nil)
       # type 1: ( <test> )
-      # type 2: ( <test> => <expression> )
-      # type 3: ( <test> <sequence> )
+      # type 2: ( <test> <sequence> )
+      # type 3: ( <test> => <recipient> )
       # type 4: ( else <sequence> )
-      clause_node.test = parse_test
-      Kernel.loop {
-        break if @lexer.peek_token.type == :rparen
-        clause_node.add_expression(parse_expression)
-      }
+      if identifier_name?(@lexer.peek_token, "else")
+        # type 4
+        parse_else_clause
+      else
+        clause_node = nil
+        test_node = parse_test
+        if identifier_name?(@lexer.peek_token, "=>")
+          # type 3
+          @lexer.skip_token     # skip "=>"
+          clause_node = AST.instantiate(:ast_cond_recipient_clause, nil)
+          clause_node.recipient = parse_recipient
+        else
+          # type 1 and 2
+          clause_node = AST.instantiate(:ast_cond_clause, nil)
+          clause_node.sequence = parse_sequence
+        end
+        skip_rparen
+        clause_node.test = test_node
+        clause_node
+      end
+    end
+
+    def parse_else_clause
+      @lexer.skip_token         # skip "else"
+      else_clause_node = AST.instantiate(:ast_else_clause, nil)
+      else_clause_node.sequence = parse_sequence
       skip_rparen
-      clause_node
+      else_clause_node
+    end
+
+    def parse_else_recipient_clause
+      @lexer.skip_token         # skip "else"
+      @lexer.skip_token         # skip "=>"
+      else_recipient_clause_node = AST.instantiate(:ast_else_recipient_clause, nil)
+      else_recipient_clause_node = parse_recipient
+      else_recipient_clause_node
+    end
+
+    def parse_recipient
+      parse_expression
     end
 
     def parse_case
@@ -401,10 +467,7 @@ module Rubasteme
       ast_type = "ast_#{type}".intern
       node = AST.instantiate(ast_type, nil)
       node.test = parse_test
-      Kernel.loop {
-        break if @lexer.peek_token.type == :rparen
-        node << parse_expression
-      }
+      node.sequence = parse_sequence
       skip_rparen
       node
     end
@@ -415,7 +478,7 @@ module Rubasteme
         let_node.identifier = parse_identifier
       end
       let_node.bindings = parse_bindings
-      let_node.body = read_body
+      let_node.body = parse_body
       skip_rparen
       let_node
     end
@@ -456,7 +519,7 @@ module Rubasteme
       ast_type = "ast_#{type}".intern
       node = AST.instantiate(ast_type, nil)
       node.bindings = parse_bindings
-      node.body = read_body
+      node.body = parse_body
       skip_rparen
       node
     end
@@ -471,10 +534,7 @@ module Rubasteme
 
     def parse_begin
       begin_node = AST.instantiate(:ast_begin, nil)
-      Kernel.loop {
-        break if @lexer.peek_token.type == :rparen
-        begin_node << parse_expression
-      }
+      begin_node.sequence = parse_sequence
       skip_rparen
       begin_node
     end
@@ -581,7 +641,7 @@ module Rubasteme
       when :dot
         :ast_dot
       else
-        :ast_identifier
+        :ast_illegal
       end
     end
 
@@ -594,6 +654,10 @@ module Rubasteme
       end
     end
 
+    def identifier_name?(token, name)
+      token.type == :identifier && token.literal == name
+    end
+
     SCM_CHAR_TO_RB_MAP = {
       "*" => "_star",
       "-" => "_",

data/lib/rubasteme/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Rubasteme
-  VERSION = "0.1.3"
-  RELEASE = "2021-05-20"
+  VERSION = "0.1.4"
+  RELEASE = "2021-05-31"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubasteme
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - mnbi
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-05-20 00:00:00.000000000 Z
+date: 2021-05-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rbscmlex