loxxy 0.0.18 → 0.0.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 43f600b63e6a264cf14a760e82537693068118152aa41e2b6d87f99d993280ea
-  data.tar.gz: 5ea73cae221b5039ec8257ef29c49bd63d22bb2477cde37b60f4f3799fe06534
+  metadata.gz: eced55bddfd7918cbc7aea8eff5f7ecd37aa88baa6e5a6f7350f5bd7606e99af
+  data.tar.gz: f9b8104a0f3a273466ff568a014e345437f4c568621828de8da44961fb52f0e5
 SHA512:
-  metadata.gz: 8d4944a0b164730ddf0839abc325fc0389d895abecb1cd37f22909dc5a17243c29965eb194c351044fb3087bebc1d3dfd319aa6188f05e7a31df09bb41326e18
-  data.tar.gz: e7f857a51b74337724fa4cfd16816d79f9a0dec2b51dcdc8c297a52773048ea2dd2349a110fbf9b0d5eea6f2c57c6397f8196d14520cff59edab1e99444d7a60
+  metadata.gz: d5b23defe380228bda4e32d9cb94909767fdc42242111f00be214bfbead6323a5e6acda0d78dcaf4e1c2e1fa7d13cd0363661af959a62b093bfcc50c34c290a0
+  data.tar.gz: 96a6a77824cd97b248ad6a78d66d4757c81549fa199021f446883d690f2702dbf4d9879950505d9aa54f45376bd7e6204be8b054e27b43a5576aca744be40047

data/CHANGELOG.md

@@ -1,15 +1,28 @@
+## [0.0.18] - 2021-01-14
+- The interpreter supports expressions between parentheses (grouping).
+
+## Added
+- Class `Ast::LoxLogicalExpr`
+- Method `Ast::ASTBuilder#reduce_grouping_expr` as semantic action for grouping expression
+- Method `Ast::ASTVisitor#visit_grouping_expr` for visiting grouping expressions
+- Method `Engine::after_grouping_expr`for the evaluation of grouping expressions
+
 ## [0.0.18] - 2021-01-13
 - The interpreter can evaluate `and`, `or`expressions.
 
-
+## Added
+- Class `Ast::LoxLogicalExpr`
+- Method `Ast::ASTBuilder#reduce_logical_expr` for the semantic action require for `and`, `or`
+- Method `Ast::ASTVisitor#visit_logical_expr` for visiting logical expressions
+- Method `Backend::Engine#after_logical_expr` implements the evaluation of the logical expressions
 
 ## [0.0.17] - 2021-01-12
 - The interpreter can evaluate all arithmetic and comparison operations.
 - It implements `==`, `!=` and the unary operations `!`, `-`
 
 ## Added
-- Class `AST::LoxUnaryExpr`
-- Method `AST::ASTBuilder#reduce_unary_expr` to support the evaluation of `!` and ``-@`
+- Class `Ast::LoxUnaryExpr`
+- Method `Ast::ASTBuilder#reduce_unary_expr` to support the evaluation of `!` and ``-@`
 - Method `Ast::ASTVisitor#visit_unnary_expr` for visiting unary expressions
 - Method `Backend::Engine#after_unary_expr` evaluating an unary expression
 - In class `Datatype::BuiltinDatatype` the methods `falsey?`, `truthy?`, `!`, `!=`

data/README.md

@@ -245,6 +245,15 @@ REMINDER: In __Lox__, `false` and `nil` are considered falsey, everything else i
   `!!true; // => true`  
   `!0; // => false`
 
+#####  Grouping expressions
+Use parentheses `(` `)` for a better control in expression/operator precedence.
+
+``` javascript
+print 3 + 4 * 5;  // => 23
+print (3 + 4) * 5; // => 35
+```
+
+
 #####  Print Statement
 
 The statement print + expression + ; prints the result of the expression to stdout.

data/lib/loxxy/ast/all_lox_nodes.rb

@@ -2,6 +2,7 @@
 
 require_relative 'lox_literal_expr'
 require_relative 'lox_noop_expr'
+require_relative 'lox_grouping_expr'
 require_relative 'lox_unary_expr'
 require_relative 'lox_binary_expr'
 require_relative 'lox_logical_expr'

data/lib/loxxy/ast/ast_builder.rb

@@ -134,6 +134,11 @@ module Loxxy
         [[operator, operand2]]
       end
 
+      # Return the AST node corresponding to the second symbol in the rhs
+      def reduce_keep_symbol2(_production, _range, _tokens, theChildren)
+        theChildren[1]
+      end
+
       #####################################
       #  SEMANTIC ACTIONS
       #####################################
@@ -253,6 +258,12 @@ module Loxxy
         LoxUnaryExpr.new(tokens[0].position, operator, operand)
       end
 
+      # rule('primary' => 'LEFT_PAREN expression RIGHT_PAREN')
+      def reduce_grouping_expr(_production, _range, tokens, theChildren)
+        subexpr = theChildren[1]
+        LoxGroupingExpr.new(tokens[0].position, subexpr)
+      end
+
       # rule('primary' => 'FALSE' | TRUE').as 'literal_expr'
       def reduce_literal_expr(_production, _range, _tokens, theChildren)
         first_child = theChildren.first

data/lib/loxxy/ast/ast_visitor.rb

@@ -89,6 +89,14 @@ module Loxxy
         broadcast(:after_unary_expr, anUnaryExpr)
       end
 
+      # Visit event. The visitor is about to visit a grouping expression.
+      # @param aGroupingExpr [AST::LoxGroupingExpr] grouping expression to visit
+      def visit_grouping_expr(aGroupingExpr)
+        broadcast(:before_grouping_expr, aGroupingExpr)
+        traverse_subnodes(aGroupingExpr)
+        broadcast(:after_grouping_expr, aGroupingExpr)
+      end
+
       # Visit event. The visitor is visiting the
       # given terminal node containing a datatype object.
       # @param aLiteralExpr [AST::LoxLiteralExpr] the leaf node to visit.

data/lib/loxxy/ast/lox_grouping_expr.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'lox_compound_expr'
+
+module Loxxy
+  module Ast
+    class LoxGroupingExpr < LoxCompoundExpr
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      # @param subExpr [Loxxy::Ast::LoxNode]
+      def initialize(aPosition, subExpr)
+        super(aPosition, [subExpr])
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [Ast::ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_grouping_expr(self)
+      end
+
+      alias operands subnodes
+    end # class
+  end # module
+end # module

data/lib/loxxy/back_end/engine.rb

@@ -95,6 +95,10 @@ module Loxxy
         end
       end
 
+      def after_grouping_expr(_groupingExpr)
+        # Do nothing: work was already done by visiting /evaluating the subexpression
+      end
+
       # @param literalExpr [Ast::LoxLiteralExpr]
       def before_literal_expr(literalExpr)
         stack.push(literalExpr.literal)

data/lib/loxxy/front_end/grammar.rb

@@ -138,7 +138,7 @@ module Loxxy
       rule('primary' => 'NUMBER').as 'literal_expr'
       rule('primary' => 'STRING').as 'literal_expr'
       rule('primary' => 'IDENTIFIER')
-      rule('primary' => 'LEFT_PAREN expression RIGHT_PAREN')
+      rule('primary' => 'LEFT_PAREN expression RIGHT_PAREN').as 'grouping_expr'
       rule('primary' => 'SUPER DOT IDENTIFIER')
 
       # Utility rules

data/lib/loxxy/version.rb

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

data/spec/interpreter_spec.rb

@@ -211,6 +211,18 @@ module Loxxy
         end
       end
 
+      it 'should supprt expressions between parentheses' do
+        [
+          ['3 + 4 * 5;', 23],
+          ['(3 + 4) * 5;', 35],
+          ['(5 - (3 - 1)) + -(1);', 2]
+        ].each do |(source, predicted)|
+          lox = Loxxy::Interpreter.new
+          result = lox.evaluate(source)
+          expect(result.value == predicted).to be_truthy
+        end
+      end
+
       it 'should print the hello world message' do
         expect { subject.evaluate(hello_world) }.not_to raise_error
         expect(sample_cfg[:ostream].string).to eq('Hello, world!')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: loxxy
 version: !ruby/object:Gem::Version
-  version: 0.0.18
+  version: 0.0.19
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-13 00:00:00.000000000 Z
+date: 2021-01-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -89,6 +89,7 @@ files:
 - lib/loxxy/ast/ast_visitor.rb
 - lib/loxxy/ast/lox_binary_expr.rb
 - lib/loxxy/ast/lox_compound_expr.rb
+- lib/loxxy/ast/lox_grouping_expr.rb
 - lib/loxxy/ast/lox_literal_expr.rb
 - lib/loxxy/ast/lox_logical_expr.rb
 - lib/loxxy/ast/lox_node.rb