loxxy 0.0.8 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ed8bad2906a9ffd76c81a1fe14d89088f913f84996f0a6d98e7f104e0eccfdc9
-  data.tar.gz: 40ee48dc0f4d7e0ce1028820b9c5cf56d0c78d9853916f3bf9e5f32a7106887a
+  metadata.gz: 74cd4aa3bd58cad64cad8ac452535052c761f166da883b06b593590310edd97d
+  data.tar.gz: 15af4b4a4c86c7b8e6a14bda16433a9d1663ab581eae78331d29adeed02313d3
 SHA512:
-  metadata.gz: 69c3c6e6b2a60c3f27284be820ac8f2687de0073c28719bd9414578ab37ac59de267dc1e69897966fef33d4ba725597587fe991b8e20ce6d40ec1587f3aa53c4
-  data.tar.gz: c296dcedcf97fe7426a59cfb2df2144685f2809c64becb18483e62a5aea536c2ca3ae2ab697b865c0945456e191a0a011f01123d34160acfa554761b8a2f917e
+  metadata.gz: 0dbd9244c36913eed955b1ff92bdc63fd77cc6f7cda3d6b037f3ee87cdcc8d4450673f852426a7395d968711aaf9a3a539efeeaf5e2a0d46865f4f4fa7276c74
+  data.tar.gz: c8c65b58fa53d0cce81a3e7508317dfbeb5d8e10f883a0a011d278ca33ee647967bfd34e79fc4703ad7a5b4a3a88aece8d17ca0d0db107f0ec0fcb9ac12e4280

data/CHANGELOG.md

@@ -1,8 +1,16 @@
+## [0.0.9] - 2021-01-07
+- AST node generation for comparison expression.
+
+## Changed
+- Class `AST::ASTBuilder` added `reduce_` methods for comparison operations.
+- File `grammar.rb`added name to comparison rules
+
 ## [0.0.8] - 2021-01-07
 - AST node generation for arithmetic operations of number literals.
 
 ## Changed
 - Class `AST::ASTBuilder` added `reduce_` methods for arithmetic operations.
+- File `grammar.rb`added name to arithmetic rules
 
 ## Fixed
 - File `grammar.rb`: second rule for `factor` had a missing member in rhs.

data/lib/loxxy/ast/ast_builder.rb

@@ -72,8 +72,8 @@ module Loxxy
         node
       end
 
-      # rule('term' => 'factor additive_plus')
-      def reduce_term_additive(_production, _range, tokens, theChildren)
+      # rule('lhs' => 'nonterm_i nonterm_k_plus')
+      def reduce_binary_operator(_production, _range, tokens, theChildren)
         operand1 = theChildren[0]
 
         # Second child is anray with couples [operator, operand2]
@@ -84,6 +84,32 @@ module Loxxy
         operand1
       end
 
+      # rule('comparison' => 'term comparisonTest_plus')
+      def reduce_comparison_plus(production, range, tokens, theChildren)
+        reduce_binary_operator(production, range, tokens, theChildren)
+      end
+
+      # rule('comparisonTest_plus' => 'comparisonTest_plus comparisonTest term').as 'comparison_t_plus_more'
+      # TODO: is it meaningful to implement this rule?
+
+      # rule('comparisonTest_plus' => 'comparisonTest term')
+      def reduce_comparison_t_plus_end(_production, _range, _tokens, theChildren)
+        name2operators = {
+          'GREATER' => '>',
+          'GREATER_EQUAL' => '>=',
+          'LESS' =>  '<',
+          'LESS_EQUAL' => '<='
+        }
+        operator = name2operators[theChildren[0].symbol.name].to_sym
+        operand2 = theChildren[1]
+        [[operator, operand2]]
+      end
+
+      # rule('term' => 'factor additive_plus')
+      def reduce_term_additive(production, range, tokens, theChildren)
+        reduce_binary_operator(production, range, tokens, theChildren)
+      end
+
       # rule('additive_star' => 'additive_star additionOp factor').as 'additionOp_expr'
       def reduce_additive_plus_more(_production, _range, _tokens, theChildren)
         result = theChildren[0]
@@ -100,15 +126,8 @@ module Loxxy
       end
 
       # rule('factor' => 'multiplicative_plus')
-      def reduce_factor_multiplicative(_production, _range, tokens, theChildren)
-        operand1 = theChildren[0]
-
-        # Second child is anray with couples [operator, operand2]
-        theChildren[1].each do |(operator, operand2)|
-          operand1 = LoxBinaryExpr.new(tokens[0].position, operator, operand1, operand2)
-        end
-
-        operand1
+      def reduce_factor_multiplicative(production, range, tokens, theChildren)
+        reduce_binary_operator(production, range, tokens, theChildren)
       end
 
       # rule('multiplicative_plus' => 'multiplicative_plus multOp unary')

data/lib/loxxy/front_end/grammar.rb

@@ -102,9 +102,9 @@ module Loxxy
       rule('equalityTest' => 'BANG_EQUAL')
       rule('equalityTest' => 'EQUAL_EQUAL')
       rule('comparison' => 'term')
-      rule('comparison' => 'term comparisonTest_plus')
-      rule('comparisonTest_plus' => 'comparisonTest_plus comparisonTest term')
-      rule('comparisonTest_plus' => 'comparisonTest term')
+      rule('comparison' => 'term comparisonTest_plus').as 'comparison_plus'
+      rule('comparisonTest_plus' => 'comparisonTest_plus comparisonTest term').as 'comparison_t_plus_more'
+      rule('comparisonTest_plus' => 'comparisonTest term').as 'comparison_t_plus_end'
       rule('comparisonTest' => 'GREATER')
       rule('comparisonTest' => 'GREATER_EQUAL')
       rule('comparisonTest' => 'LESS')

data/lib/loxxy/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Loxxy
-  VERSION = '0.0.8'
+  VERSION = '0.0.9'
 end

data/spec/front_end/parser_spec.rb

@@ -206,7 +206,7 @@ LOX_END
           expect(expr.operands[1].literal.value).to eq(0.3)
         end
 
-        it 'should parse multiple additive operations' do
+        it 'should parse multiple multiplicative operations' do
           input = '5 * 2 / 3;'
           ptree = subject.parse(input)
           parent = ptree.root.subnodes[0]
@@ -221,6 +221,54 @@ LOX_END
           expect(expr.operands[0].operands[1].literal.value).to eq(2)
           expect(expr.operands[1].literal.value).to eq(3)
         end
+
+        it 'should parse combination of terms and factors' do
+          input = '5 + 2 / 3;'
+          ptree = subject.parse(input)
+          parent = ptree.root.subnodes[0]
+          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
+          expect(parent.symbol.name).to eq('exprStmt')
+          expr = parent.subnodes[0]
+          expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr.operator).to eq(:+)
+          expect(expr.operands[0].literal.value).to eq(5)
+          expect(expr.operands[1]).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr.operands[1].operator).to eq(:/)
+          expect(expr.operands[1].operands[0].literal.value).to eq(2)
+          expect(expr.operands[1].operands[1].literal.value).to eq(3)
+        end
+      end # context
+
+      context 'Parsing string concatenation' do
+        it 'should parse the concatenation of two string literals' do
+          input = '"Lo" + "ve";'
+          ptree = subject.parse(input)
+          parent = ptree.root.subnodes[0]
+          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
+          expect(parent.symbol.name).to eq('exprStmt')
+          expr = parent.subnodes[0]
+          expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr.operator).to eq(:+)
+          expect(expr.operands[0].literal.value).to eq('Lo')
+          expect(expr.operands[1].literal.value).to eq('ve')
+        end
+      end # context
+
+      context 'Parsing comparison expressions' do
+        it 'should parse the comparison of two number literals' do
+          %w[> >= < <=].each do |predicate|
+            input = "3 #{predicate} 2;"
+            ptree = subject.parse(input)
+            parent = ptree.root.subnodes[0]
+            expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
+            expect(parent.symbol.name).to eq('exprStmt')
+            expr = parent.subnodes[0]
+            expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+            expect(expr.operator).to eq(predicate.to_sym)
+            expect(expr.operands[0].literal.value).to eq(3)
+            expect(expr.operands[1].literal.value).to eq(2)
+          end
+        end
       end # context
     end # describe
   end # module

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: loxxy
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.9
 platform: ruby
 authors:
 - Dimitri Geshef