loxxy 0.0.14 → 0.0.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 18b1d3e9f498ca8249775f55cc3950622d9f5a49cd67db912816cc60f15b3d16
-  data.tar.gz: 5766130089ebbe6d85a90a9f59ac1a505202c0e2646d4d7da93af025a80b0651
+  metadata.gz: eced55bddfd7918cbc7aea8eff5f7ecd37aa88baa6e5a6f7350f5bd7606e99af
+  data.tar.gz: f9b8104a0f3a273466ff568a014e345437f4c568621828de8da44961fb52f0e5
 SHA512:
-  metadata.gz: 621832b48a5625081a0b82a8f8992d78709a1d4a053d8e4719140510242ce14d4418ca23c82d9f52186453c42d5d432203e7af496d7f92726f75622c743119e2
-  data.tar.gz: aa67901fae29e13d3154e274c7014fe2002fb7e054c62cf253e87e44ac421747db9f5f05ef1e108cd92c8c0124ceb93b31fa537de64f875607c096465f89aee4
+  metadata.gz: d5b23defe380228bda4e32d9cb94909767fdc42242111f00be214bfbead6323a5e6acda0d78dcaf4e1c2e1fa7d13cd0363661af959a62b093bfcc50c34c290a0
+  data.tar.gz: 96a6a77824cd97b248ad6a78d66d4757c81549fa199021f446883d690f2702dbf4d9879950505d9aa54f45376bd7e6204be8b054e27b43a5576aca744be40047

data/.rubocop.yml

@@ -250,7 +250,7 @@ Style/IfUnlessModifier:
   Enabled: false
 
 Style/InverseMethods:
-  Enabled: true
+  Enabled: false
 
 Style/MissingRespondToMissing:
   Enabled: false

data/CHANGELOG.md

@@ -1,3 +1,85 @@
+## [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 ``-@`
+- 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?`, `!`, `!=`
+- In class `Datatype::Number`the methods `<`, `<=`, ´>´, `>=` and `-@`
+
+## Changed
+- File `README.md` updated.
+
+## [0.0.16] - 2021-01-11
+- The interpreter can evaluate product and division of two numbers.
+- It also implements equality `==` and inequality `!=` operators
+
+## Added
+- Method `Datatype::False#==` for equality testing
+- Method `Datatype::False#!=` for inequality testing
+- Method `Datatype::LXString#==` for equality testing
+- Method `Datatype::LXString#!=` for inequality testing
+- Method `Datatype::Nil#==` for equality testing
+- Method `Datatype::Nil#!=` for inequality testing
+- Method `Datatype::Number#==` for equality testing
+- Method `Datatype::Number#!=` for inequality testing
+- Method `Datatype::Number#*` for multiply operator
+- Method `Datatype::Number#/` for divide operator
+- Method `Datatype::True#==` for equality testing
+- Method `Datatype::True#!=` for inequality testing
+
+## Changed
+- Method `BackEnd::Engine#after_binary_expr` to allow `*`, `/`, `==`, `!=` operators
+- File `README.md` updated for the newly implemented operators
+
+## [0.0.15] - 2021-01-11
+- The interpreter can evaluate substraction between two numbers.
+
+## Added
+- Method `Datatype::Number#-` implmenting the subtraction operation
+
+## Changed
+- File `README.md` minor editorial changes.
+- File `lx_string_spec.rb` Added test for string concatentation
+- File `number_spec.rb` Added tests for addition and subtraction operations
+- File `interpreter_spec.rb` Added tests for subtraction operation
+
+## [0.0.14] - 2021-01-10
+- The interpreter can evaluate addition of numbers and string concatenation
+
+## Added
+- Method `Ast::ASTVisitor#visit_binary_expr` for visiting binary expressions
+- Method `Ast::LoxBinaryExpr#accept` for visitor pattern
+- Method `BackEnd::Engine#after_binary_expr` to trigger execution of binary operator
+- `Boolean` class hierarchy: added methos `true?` and `false?` to ease spec test writing
+- Method `Datatype::LXString#+` implementation of the string concatenation
+- Method `Datatype::Number#+` implementation of the addition of numbers
+
+## Changed
+- File `interpreter_spec.rb` Added tests for addition operation and string concatenation
+
+
 ## [0.0.13] - 2021-01-10
 - The interpreter can evaluate directly simple literals.
 

data/README.md

@@ -2,7 +2,7 @@
 [![Gem Version](https://badge.fury.io/rb/loxxy.svg)](https://badge.fury.io/rb/loxxy)
 [![License](https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat)](https://github.com/famished-tiger/loxxy/blob/main/LICENSE.txt)
 
-
+### What is loxxy?
 A Ruby implementation of the [Lox programming language](https://craftinginterpreters.com/the-lox-language.html ),
 a simple language used in Bob Nystrom's online book [Crafting Interpreters](https://craftinginterpreters.com/ ).
 
@@ -16,7 +16,7 @@ a simple language used in Bob Nystrom's online book [Crafting Interpreters](http
 The project is still in inception and the interpreter is being implemented...  
 Currently it can execute a tiny subset of __Lox__ language.
 
-The __loxxy__ gem also a parser class `RawPaser` that can parse, in principle, any valid Lox input.
+But the __loxxy__ gem hosts also a parser class `RawPaser` that can parse, in principle, any valid Lox input.
 
 ## What's the fuss about Lox?
 ... Nothing...  
@@ -74,7 +74,7 @@ require 'loxxy'
 
 lox = Loxxy::Interpreter.new
 
-lox_program = '37 + 5; // THE answer'
+lox_program = '47 - 5; // THE answer'
 result = lox.evaluate(lox_program) # => Loxxy::Datatype::Number
 
 # `result` is a Ruby object, so let's use it...
@@ -128,17 +128,20 @@ program
 ```
 
 ## Suppported Lox language features
-Although the interpreter should parse almost any valid Lox program,
-it currently can evaluate a tiny set of AST node (AST = Abstract Syntax Tree).
+On one hand, the parser covers the complete Lox grammar and should therefore, in principle,
+parse any valid Lox program.
+
+On the other hand, the interpreter is under development and currently it can evaluate only a tiny subset of __Lox__.
+But the situation is changing almost daily, stay tuned...
 
 Here are the language features currently supported by the interpreter:
 
 - [Comments](#comments)
 - [Keywords](#keywords)
-- [Operators and Special Chars](#operators-and-special-chars)
 - [Datatypes](#datatypes)
-- [Statements](#statements)
-- `print` statement.
+- [Statements](#statements)  
+  -[Expressions](#expressions)  
+  -[Print Statement](#print-statement)
 
 ### Comments
 
@@ -149,66 +152,116 @@ Loxxy supports single line C-style comments.
 ```
 
 ### Keywords
-
-The parser knows all the __Lox__ reserved keywords:
+Loxxy implements the following __Lox__ reserved keywords:
 ```lang-none
-and, class, else, false, fun, for, if, nil, or,
-print, return, super, this, true, var, while
+and, false, nil, or, print, true
 ```
-Of these, the interpreter implements: `false`, `nil`, `true`
-
-### Operators and Special Chars
-#### Operators
-The parser recognizes all the __Lox__ operators, delimiters and separators:
-- Arithmetic operators: `+`, `-`, `*`, `/`
-- Comparison operators: `>`, `>=`, `<`, `<=`
-- Equality operators: `==`, `!=`
-
-Of these, the interpreter implements: 
-`+` (addition of two numbers or string concatenation)
-
-#### Delimiters
-The parser knows all the __Lox__ grouping delimiters:  
-(`, ), `{`, `}`
-
-These aren't yet implemented in the interpreter.
-
-The other characters that have a special meaning in __Lox__ are:
-- `,` Used in parameter list
-- `.` For the dot notation (i.e. calling a method)
-- `;` The semicolon is used to terminates expressions
-- `=` Assignment
-
-The parser recognizes them all but the interpreter accepts the semicolons only.
 
 ### Datatypes
 
-Loxxy supports the following standard __Lox__ datatypes:
+loxxy supports  all the standard __Lox__ datatypes:
 - `Boolean`: Can be `true` or `false`
 - `Number`: Can be an integer or a floating-point numbers. For example: `123, 12.34, -45.67`
 - `String`: Sequence of characters surrounded by `"`. For example: `"Hello!"`
 - `Nil`: Used to define a null value, denoted by the `nil` keyword
 
-All the Lox literals (booleans, numbers, strings and nil),
+### Statements
+
+Loxxy supports the following statements:  
+-[Expressions](#expressions)  
+  -[Arithmetic expressions](#arithmetic-expressions)  
+  -[String concatenation](#string-concatenation)  
+  -[Comparison expressions](#comparison-expressions)  
+  -[Logical expressions](#logical-expressions)  
+  -[Grouping expressions](#grouping-expressions)  
+-[Print Statement](#print-statement)
+
+#### Expressions
+
+##### Arithmetic expressions
+Loxxy supports the following operators for arithmetic expressions:
+
+- `+`: Adds of two numbers. Both operands must be of the type Number  
+  E.g. `37 + 5; // => 42`  
+  `7 + -3; // => 4`
+- `-`: (Binary) Subtracts right operand from left operand. Both operands must be numbers.  
+  E.g. `47 - 5; // => 42`
+- `-`: (Unary) Negates (= changes the sign) of the given number operand.  
+  E.g. `- -3; // => 3`
+- `*`: Multiplies two numbers  
+  E.g. `2 * 3; // => 6`
+- `/`: Divides two numbers  
+  E.g. `8 / 2; // => 4`
+  `5 / 2; // => 2.5`
+
+##### String concatenation
+- `+`: Concatenates two strings. Both operands must be of the String type.  
+  E.g. `"Hello" + ", " + "world! // => "Hello, world!"`
+
+##### Comparison expressions
+
+- `==`: Returns `true` if left operand is equal to right operand, otherwise `false`  
+  E.g. `false == false; // => true`  
+  `5 + 2 == 3 + 4; // => true`  
+  `"" == ""; // => true`
+- `!=`: Returns `true` if left operand is not equal to right operand, otherwise `false`  
+  E.g. `false != "false"; // => true`  
+  `5 + 2 != 4 + 3; // => false`
+- `<`: Returns `true` if left operand is less than right operand, otherwise `false`. Both operands must be numbers  
+  E.g. `1 < 3; // => true`  
+  `1 < 0; // => false`  
+  `2 < 2; // => false`
+- `<=`: Returns `true` if left operand is equal to right operand, otherwise `false`. Both operands must be numbers  
+  E.g. `1 <= 3; // => true`  
+  `1 <= 0; // => false`  
+  `2 <= 2; // => true`
+- `>`: Returns `true` if left operand is equal to right operand, otherwise `false`. Both operands must be numbers  
+  E.g. `1 > 3; // => false`  
+  `1 > 0; // => true`  
+  `2 > 2; // => false`
+- `>=`: Returns `true` if left operand is equal to right operand, otherwise `false`. Both operands must be numbers  
+  E.g. `1 > 3; // => false`  
+  `1 > 0; // => true`  
+  `2 > 2; // => false`
+
+##### Logical expressions
+
+REMINDER: In __Lox__, `false` and `nil` are considered falsey, everything else is truthy.
+
+- `and`: When both operands are booleans, then returns `true` if both left and right operands are truthy, otherwise `false`.   
+  If at least one operand isn't a boolean then returns first falsey operand else (both operands are truthy) returns the second operand.
+  truthy returns the second operand.  
+  E.g. `false and true; // => false`  
+  `true and nil; // => nil`  
+  `0 and true and ""; // => ""`
+- `or`: When both operands are booleans, then returns `true` if left or right operands are truthy, otherwise `false`.  
+  If at least one operand isn't a boolean then returns first truthy operand else (both operands are truthy) returns the second operand.
+  E.g. `false or true; // => true`  
+  `true or nil; // => nil`  
+  `false or nil; // => nil`  
+  `0 or true or ""; // => 0`
+- `!`: Performs a logical negation on its operand  
+  E.g. `!false; // => true`  
+  `!!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
+```
 
-## Statements
-### Implemented expressions
-Loxxy implements expressions:
-- Consisting of literals only; or,
-- Addition of two numbers; or,
-- Concatenation of two strings
 
-### Implemented statements
-Loxxy implements the following statements:
-- Expressions (see above sub-section)
-- Print statement
+#####  Print Statement
 
-```javascript
-// Print statement with nested concatenation
-print "Hello" + ", " + "world!";
-```
+The statement print + expression + ; prints the result of the expression to stdout.
 
+``` javascript
+print "Hello, world!";  // Output: Hello, world!
 
+```
 
 ## Installation
 

data/lib/loxxy/ast/all_lox_nodes.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
-require_relative 'lox_print_stmt'
 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'
+require_relative 'lox_print_stmt'

data/lib/loxxy/ast/ast_builder.rb

@@ -15,7 +15,6 @@ module Loxxy
         # @return [Hash{String => String}]
         Name2special = {
           'AND' => 'and',
-          'BANG' => '!',
           'BANG_EQUAL' => '!=',
           'COMMA' =>  ',',
           'DOT' => '.',
@@ -36,6 +35,11 @@ module Loxxy
           'SLASH' =>  '/',
           'STAR' => '*'
         }.freeze
+
+        Name2unary = {
+          'BANG' => '!',
+          'MINUS' => '-@'
+        }.freeze
       end # defined
 
       attr_reader :strict
@@ -92,6 +96,17 @@ module Loxxy
         node
       end
 
+      def reduce_logical_expr(_production, _range, tokens, theChildren)
+        operand1 = theChildren[0]
+
+        # Second child is array with couples [operator, operand2]
+        theChildren[1].each do |(operator, operand2)|
+          operand1 = LoxLogicalExpr.new(tokens[0].position, operator, operand1, operand2)
+        end
+
+        operand1
+      end
+
       # rule('lhs' => 'nonterm_i nonterm_k_plus')
       def reduce_binary_operator(_production, _range, tokens, theChildren)
         operand1 = theChildren[0]
@@ -119,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
       #####################################
@@ -145,7 +165,7 @@ module Loxxy
 
       # rule('logic_or' => 'logic_and disjunct_plus')
       def reduce_logic_or_plus(production, range, tokens, theChildren)
-        reduce_binary_operator(production, range, tokens, theChildren)
+        reduce_logical_expr(production, range, tokens, theChildren)
       end
 
       # rule('disjunct_plus' => 'disjunct_plus OR logic_and')
@@ -160,7 +180,7 @@ module Loxxy
 
       # rule('logic_and' => 'equality conjunct_plus')
       def reduce_logic_and_plus(production, range, tokens, theChildren)
-        reduce_binary_operator(production, range, tokens, theChildren)
+        reduce_logical_expr(production, range, tokens, theChildren)
       end
 
       # rule('conjunct_plus' => 'conjunct_plus AND equality')
@@ -231,6 +251,19 @@ module Loxxy
         reduce_binary_plus_end(production, range, tokens, theChildren)
       end
 
+      # rule('unary' => 'unaryOp unary')
+      def reduce_unary_expr(_production, _range, tokens, theChildren)
+        operator = Name2unary[theChildren[0].symbol.name].to_sym
+        operand = theChildren[1]
+        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

@@ -51,7 +51,7 @@ module Loxxy
         broadcast(:after_ptree, aParseTree)
       end
 
-      # Visit event. The visitor is about to visit a print statement expression.
+      # Visit event. The visitor is about to visit a print statement.
       # @param aPrintStmt [AST::LOXPrintStmt] the print statement node to visit
       def visit_print_stmt(aPrintStmt)
         broadcast(:before_print_stmt, aPrintStmt)
@@ -59,7 +59,21 @@ module Loxxy
         broadcast(:after_print_stmt, aPrintStmt)
       end
 
-      # Visit event. The visitor is about to visit a print statement expression.
+      # Visit event. The visitor is about to visit a logical expression.
+      # Since logical expressions may take shorcuts by not evaluating all their
+      # sub-expressiosns, they are responsible for visiting or not their children.
+      # @param aBinaryExpr [AST::LOXBinaryExpr] the logical expression node to visit
+      def visit_logical_expr(aLogicalExpr)
+        broadcast(:before_logical_expr, aLogicalExpr)
+
+        # As logical connectors may take a shortcut only the first argument is visited
+        traverse_given_subnode(aLogicalExpr, 0)
+
+        # The second child could be visited: this action is deferred in handler
+        broadcast(:after_logical_expr, aLogicalExpr, self)
+      end
+
+      # Visit event. The visitor is about to visit a binary expression.
       # @param aBinaryExpr [AST::LOXBinaryExpr] the binary expression node to visit
       def visit_binary_expr(aBinaryExpr)
         broadcast(:before_binary_expr, aBinaryExpr)
@@ -67,6 +81,22 @@ module Loxxy
         broadcast(:after_binary_expr, aBinaryExpr)
       end
 
+      # Visit event. The visitor is about to visit an unary expression.
+      # @param anUnaryExpr [AST::anUnaryExpr] unary expression node to visit
+      def visit_unary_expr(anUnaryExpr)
+        broadcast(:before_unary_expr, anUnaryExpr)
+        traverse_subnodes(anUnaryExpr)
+        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.
@@ -98,6 +128,20 @@ module Loxxy
         broadcast(:after_subnodes, aParentNode, subnodes)
       end
 
+      # Visit event. The visitor is about to visit one given subnode of a non
+      # terminal node.
+      # @param aParentNode [Ast::LocCompoundExpr] the parent node.
+      # @param index [integer] index of child subnode
+      def traverse_given_subnode(aParentNode, index)
+        subnode = aParentNode.subnodes[index]
+        broadcast(:before_given_subnode, aParentNode, subnode)
+
+        # Now, let's proceed with the visit of that subnode
+        subnode.accept(self)
+
+        broadcast(:after_given_subnode, aParentNode, subnode)
+      end
+
       # Send a notification to all subscribers.
       # @param msg [Symbol] event to notify
       # @param args [Array] arguments of the notification.

data/lib/loxxy/ast/lox_binary_expr.rb

@@ -5,7 +5,7 @@ require_relative 'lox_compound_expr'
 module Loxxy
   module Ast
     class LoxBinaryExpr < LoxCompoundExpr
-      # @return [Symbol]
+      # @return [Symbol] message name to be sent to receiver
       attr_reader :operator
 
       # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'lox_compound_expr'
+
+module Loxxy
+  module Ast
+    class LoxLogicalExpr < LoxCompoundExpr
+      # @return [Symbol] message name to be sent to receiver
+      attr_reader :operator
+
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      # @param operand1 [Loxxy::Ast::LoxNode]
+      # @param operand2 [Loxxy::Ast::LoxNode]
+      def initialize(aPosition, anOperator, operand1, operand2)
+        super(aPosition, [operand1, operand2])
+        @operator = anOperator
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [Ast::ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_logical_expr(self)
+      end
+
+      alias operands subnodes
+    end # class
+  end # module
+end # module

data/lib/loxxy/ast/lox_unary_expr.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'lox_compound_expr'
+
+module Loxxy
+  module Ast
+    class LoxUnaryExpr < LoxCompoundExpr
+      # @return [Symbol] message name to be sent to receiver
+      attr_reader :operator
+
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      # @param operand [Loxxy::Ast::LoxNode]
+      def initialize(aPosition, anOperator, operand)
+        super(aPosition, [operand])
+        @operator = anOperator
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [Ast::ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_unary_expr(self)
+      end
+
+      alias operands subnodes
+    end # class
+  end # module
+end # module

data/lib/loxxy/back_end/engine.rb

@@ -22,7 +22,7 @@ module Loxxy
         @stack = []
       end
 
-      # Given an abstract syntax parse tree visitor, luanch the visit
+      # Given an abstract syntax parse tree visitor, launch the visit
       # and execute the visit events in the output stream.
       # @param aVisitor [AST::ASTVisitor]
       # @return [Loxxy::Datatype::BuiltinDatatype]
@@ -40,12 +40,43 @@ module Loxxy
         @ostream.print tos.to_str
       end
 
+      def after_logical_expr(aLogicalExpr, visitor)
+        op = aLogicalExpr.operator
+        operand1 = stack.pop # only first operand was evaluated
+        result = nil
+        if ((op == :and) && operand1.falsey?) || ((op == :or) && operand1.truthy?)
+          result = operand1
+        else
+          raw_operand2 = aLogicalExpr.subnodes[1]
+          raw_operand2.accept(visitor) # Visit means operand2 is evaluated
+          operand2 = stack.pop
+          result = logical_2nd_arg(operand2)
+        end
+
+        stack.push result
+      end
+
+      def logical_2nd_arg(operand2)
+        case operand2
+           when false
+             False.instance # Convert to Lox equivalent
+           when nil
+             Nil.instance # Convert to Lox equivalent
+           when true
+             True.instance # Convert to Lox equivalent
+           when Proc
+             # Second operand wasn't yet evaluated...
+             operand2.call
+           else
+             operand2
+        end
+      end
+
       def after_binary_expr(aBinaryExpr)
         op = aBinaryExpr.operator
         operand2 = stack.pop
         operand1 = stack.pop
-        implemented = [:+].include?(op)
-        if implemented && operand1.respond_to?(op)
+        if operand1.respond_to?(op)
           stack.push operand1.send(op, operand2)
         else
           msg1 = "`#{op}': Unimplemented operator for a #{operand1.class}."
@@ -53,6 +84,21 @@ module Loxxy
         end
       end
 
+      def after_unary_expr(anUnaryExpr)
+        op = anUnaryExpr.operator
+        operand = stack.pop
+        if operand.respond_to?(op)
+          stack.push operand.send(op)
+        else
+          msg1 = "`#{op}': Unimplemented operator for a #{operand1.class}."
+          raise StandardError, msg1
+        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/datatype/builtin_datatype.rb

@@ -14,6 +14,48 @@ module Loxxy
         @value = validated_value(aValue)
       end
 
+      # Is the value considered falsey in Lox?
+      # Rule: false and nil are falsey and everything else is truthy.
+      # This test used in conditional statements (i.e. if, while)
+      def falsey?
+        false # Default implementation
+      end
+
+      # Is the value considered truthy in Lox?
+      # Rule: false and nil are falsey and everything else is truthy.
+      # This test used in conditional statements (i.e. if, while)
+      def truthy?
+        true # Default implementation
+      end
+
+      # Check for inequality of this object with another Lox object
+      # @param other [Datatype::BuiltinDatatype, Object]
+      # @return [Datatype::Boolean]
+      def !=(other)
+        !(self == other)
+      end
+
+      # Negation ('not')
+      # Returns a boolean with opposite truthiness value.
+      # @return [Datatype::Boolean]
+      def !
+        falsey? ? True.instance : False.instance
+      end
+
+      # Returns the first falsey argument (if any),
+      # otherwise returns the last truthy argument.
+      # @param operand2 [Loxxy::Datatype::BuiltinDatatype, Proc]
+      def and(operand2)
+        falsey? ? self : logical_2nd_arg(operand2)
+      end
+
+      # Returns the first truthy argument (if any),
+      # otherwise returns the last falsey argument.
+      # @param operand2 [Loxxy::Datatype::BuiltinDatatype, Proc]
+      def or(operand2)
+        truthy? ? self : logical_2nd_arg(operand2)
+      end
+
       # Method called from Lox to obtain the text representation of the boolean.
       # @return [String]
       def to_str
@@ -25,6 +67,19 @@ module Loxxy
       def validated_value(aValue)
         aValue
       end
+
+      def logical_2nd_arg(operand2)
+        case operand2
+          when false
+            False.instance # Convert to Lox equivalent
+          when nil
+            Nil.instance # Convert to Lox equivalent
+          when true
+            True.instance # Convert to Lox equivalent
+          else
+            operand2
+        end
+      end
     end # class
   end # module
 end # module

data/lib/loxxy/datatype/false.rb

@@ -19,6 +19,28 @@ module Loxxy
       def false?
         true
       end
+
+      # Is the value considered falsey in Lox?
+      # Rule: false and nil are falsey and everything else is truthy.
+      # This test used in conditional statements (i.e. if, while)
+      def falsey?
+        true
+      end
+
+      # Is the value considered truthy in Lox?
+      # Rule: false and nil are falsey and everything else is truthy.
+      # This test used in conditional statements (i.e. if, while)
+      def truthy?
+        false
+      end
+
+      # Check for equality of a Lox False with another Lox object
+      # @param other [Datatype::BuiltinDatatype, FalseClass, Object]
+      # @return [Datatype::Boolean]
+      def ==(other)
+        falsey = other.kind_of?(False) || other.kind_of?(FalseClass)
+        falsey ? True.instance : False.instance
+      end
     end # class
 
     False.instance.freeze # Make the sole instance immutable

data/lib/loxxy/datatype/lx_string.rb

@@ -7,8 +7,8 @@ module Loxxy
   module Datatype
     # Class for representing a Lox string of characters value.
     class LXString < BuiltinDatatype
-      # Compare a Lox String with another Lox (or genuine Ruby) String
-      # @param other [Datatype::LxString, String]
+      # Check the equality of a Lox String with another Lox object.
+      # @param other [Datatype::LxString, String, Object]
       # @return [Datatype::Boolean]
       def ==(other)
         case other
@@ -17,8 +17,7 @@ module Loxxy
         when String
           (value == other) ? True.instance : False.instance
         else
-          err_msg = "Cannot compare a #{self.class} with #{other.class}"
-          raise StandardError, err_msg
+          False.instance
         end
       end
 

data/lib/loxxy/datatype/nil.rb

@@ -14,6 +14,28 @@ module Loxxy
         super(nil)
       end
 
+      # Check the equality with another object.
+      # @param other [Datatype::BuiltinDatatype, NilClass, Object]
+      # @return [Datatype::Boolean]
+      def ==(other)
+        is_nil = other.kind_of?(Nil) || other.kind_of?(NilClass)
+        is_nil ? True.instance : False.instance
+      end
+
+      # Is the value considered falsey in Lox?
+      # Rule: false and nil are falsey and everything else is truthy.
+      # This test used in conditional statements (i.e. if, while)
+      def falsey?
+        true
+      end
+
+      # Is the value considered truthy in Lox?
+      # Rule: false and nil are falsey and everything else is truthy.
+      # This test used in conditional statements (i.e. if, while)
+      def truthy?
+        false
+      end
+
       # Method called from Lox to obtain the text representation of nil.
       # @return [String]
       def to_str

data/lib/loxxy/datatype/number.rb

@@ -7,8 +7,78 @@ module Loxxy
   module Datatype
     # Class for representing a Lox numeric value.
     class Number < BuiltinDatatype
-      # Compare a Lox Number with another Lox (or genuine Ruby) Number
-      # @param other [Datatype::Number, Numeric]
+      # Perform the addition of two Lox numbers or
+      # one Lox number and a Ruby Numeric
+      # @param other [Loxxy::Datatype::Number, Numeric]
+      # @return [Loxxy::Datatype::Number]
+      def +(other)
+        case other
+        when Number
+          self.class.new(value + other.value)
+        when Numeric
+          self.class.new(value + other)
+        else
+          err_msg = "`+': #{other.class} can't be coerced into #{self.class} (TypeError)"
+          raise TypeError, err_msg
+        end
+      end
+
+      # Perform the subtraction of two Lox numbers or
+      # one Lox number and a Ruby Numeric
+      # @param other [Loxxy::Datatype::Number, Numeric]
+      # @return [Loxxy::Datatype::Number]
+      def -(other)
+        case other
+        when Number
+          self.class.new(value - other.value)
+        when Numeric
+          self.class.new(value - other)
+        else
+          err_msg = "`-': #{other.class} can't be coerced into #{self.class} (TypeError)"
+          raise TypeError, err_msg
+        end
+      end
+
+      # Perform the multiplication of two Lox numbers or
+      # one Lox number and a Ruby Numeric
+      # @param other [Loxxy::Datatype::Number, Numeric]
+      # @return [Loxxy::Datatype::Number]
+      def *(other)
+        case other
+        when Number
+          self.class.new(value * other.value)
+        when Numeric
+          self.class.new(value * other)
+        else
+          err_msg = "'*': Operands must be numbers."
+          raise TypeError, err_msg
+        end
+      end
+
+      # Perform the division of two Lox numbers or
+      # one Lox number and a Ruby Numeric
+      # @param other [Loxxy::Datatype::Number, Numeric]
+      # @return [Loxxy::Datatype::Number]
+      def /(other)
+        case other
+        when Number
+          self.class.new(value / other.value)
+        when Numeric
+          self.class.new(value / other)
+        else
+          err_msg = "'/': Operands must be numbers."
+          raise TypeError, err_msg
+        end
+      end
+
+      # Unary minus (return value with changed sign)
+      # @return [Loxxy::Datatype::Number]
+      def -@
+        self.class.new(-value)
+      end
+
+      # Check the equality of a Lox number object with another object
+      # @param other [Datatype::BuiltinDatatype, Numeric, Object]
       # @return [Datatype::Boolean]
       def ==(other)
         case other
@@ -17,27 +87,56 @@ module Loxxy
         when Numeric
           (value == other) ? True.instance : False.instance
         else
-          err_msg = "Cannot compare a #{self.class} with #{other.class}"
-          raise StandardError, err_msg
+          False.instance
         end
       end
 
-      # Perform the addition of two Lox numbers or
-      # one Lox number and a Ruby Numeric
-      # @param numeric [Loxxy::Datatype::Number, Numeric]
-      # @return [Loxxy::Datatype::Number]
-      def +(numeric)
-        case numeric
+      # Check whether this Lox number has a greater value than given argument.
+      # @param other [Datatype::Number, Numeric]
+      # @return [Datatype::Boolean]
+      def >(other)
+        case other
         when Number
-          self.class.new(value + numeric.value)
+          (value > other.value) ? True.instance : False.instance
         when Numeric
-          self.class.new(value + numeric)
+          (value > other) ? True.instance : False.instance
         else
-          err_msg = "`+': #{numeric.class} can't be coerced into #{self.class} (TypeError)"
-          raise TypeError, err_msg
+          msg = "'>': Operands must be numbers."
+          raise StandardError, msg
         end
       end
 
+      # Check whether this Lox number has a greater or equal value
+      # than given argument.
+      # @param other [Datatype::Number, Numeric]
+      # @return [Datatype::Boolean]
+      def >=(other)
+        case other
+        when Number
+          (value >= other.value) ? True.instance : False.instance
+        when Numeric
+          (value >= other) ? True.instance : False.instance
+        else
+          msg = "'>': Operands must be numbers."
+          raise StandardError, msg
+        end
+      end
+
+      # Check whether this Lox number has a lesser value than given argument.
+      # @param other [Datatype::Number, Numeric]
+      # @return [Datatype::Boolean]
+      def <(other)
+        !(self >= other)
+      end
+
+      # Check whether this Lox number has a lesser or equal value
+      # than given argument.
+      # @param other [Datatype::Number, Numeric]
+      # @return [Datatype::Boolean]
+      def <=(other)
+        !(self > other)
+      end
+
       protected
 
       def validated_value(aValue)

data/lib/loxxy/datatype/true.rb

@@ -19,6 +19,14 @@ module Loxxy
       def true?
         true
       end
+
+      # Check for equality of a Lox True with another Lox object / Ruby true
+      # @param other [Datatype::True, TrueClass, Object]
+      # @return [Datatype::Boolean]
+      def ==(other)
+        thruthy = other.kind_of?(True) || other.kind_of?(TrueClass)
+        thruthy ? True.instance : False.instance
+      end
     end # class
 
     True.instance.freeze # Make the sole instance immutable

data/lib/loxxy/front_end/grammar.rb

@@ -121,7 +121,7 @@ module Loxxy
       rule('multiplicative_plus' => 'multOp unary').as 'multiplicative_plus_end'
       rule('multOp' => 'SLASH')
       rule('multOp' => 'STAR')
-      rule('unary' => 'unaryOp unary')
+      rule('unary' => 'unaryOp unary').as 'unary_expr'
       rule('unary' => 'call')
       rule('unaryOp' => 'BANG')
       rule('unaryOp' => 'MINUS')
@@ -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.14'
+  VERSION = '0.0.19'
 end

data/spec/datatype/lx_string_spec.rb

@@ -51,6 +51,11 @@ module Loxxy
           result = subject == ''
           expect(result).to be_false
         end
+
+        it 'performs the concatenation with another string' do
+          concatenation = LXString.new('str') + LXString.new('ing')
+          expect(concatenation == 'string').to be_true
+        end
       end
     end # describe
   end # module

data/spec/datatype/number_spec.rb

@@ -41,6 +41,16 @@ module Loxxy
         it 'should give its display representation' do
           expect(subject.to_str).to eq(sample_value.to_s)
         end
+
+        it 'should compute the addition with another number' do
+          addition = subject + Number.new(10)
+          expect(addition == -2.34).to be_true
+        end
+
+        it 'should compute the subtraction with another number' do
+          subtraction = subject - Number.new(10)
+          expect(subtraction == -22.34).to be_true
+        end
       end
     end # describe
   end # module

data/spec/front_end/parser_spec.rb

@@ -262,12 +262,12 @@ LOX_END
       end # context
 
       context 'Parsing logical expressions' do
-        it 'should parse the logical operations betweentwo sub-expression' do
+        it 'should parse the logical operations between two sub-expression' do
           %w[or and].each do |connector|
             input = "5 > 2 #{connector} 3 <= 4;"
             ptree = subject.parse(input)
             expr = ptree.root
-            expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+            expect(expr).to be_kind_of(Ast::LoxLogicalExpr)
             expect(expr.operator).to eq(connector.to_sym)
             expect(expr.operands[0]).to be_kind_of(Ast::LoxBinaryExpr)
             expect(expr.operands[0].operator).to eq(:>)
@@ -284,9 +284,9 @@ LOX_END
           input = '4 > 3 and 1 < 2 or 4 >= 5;'
           ptree = subject.parse(input)
           expr = ptree.root
-          expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr).to be_kind_of(Ast::LoxLogicalExpr)
           expect(expr.operator).to eq(:or) # or has lower precedence than and
-          expect(expr.operands[0]).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr.operands[0]).to be_kind_of(Ast::LoxLogicalExpr)
           expect(expr.operands[0].operator).to eq(:and)
           conjuncts = expr.operands[0].operands
           expect(conjuncts[0]).to be_kind_of(Ast::LoxBinaryExpr)

data/spec/interpreter_spec.rb

@@ -25,6 +25,32 @@ module Loxxy
       end
     end # context
 
+    context 'Evaluating arithmetic operations code:' do
+      it 'should evaluate an addition of two numbers' do
+        result = subject.evaluate('123 + 456; // => 579')
+        expect(result).to be_kind_of(Loxxy::Datatype::Number)
+        expect(result == 579).to be_true
+      end
+
+      it 'should evaluate a subtraction of two numbers' do
+        result = subject.evaluate('4 - 3; // => 1')
+        expect(result).to be_kind_of(Loxxy::Datatype::Number)
+        expect(result == 1).to be_true
+      end
+
+      it 'should evaluate a multiplication of two numbers' do
+        result = subject.evaluate('5 * 3; // => 15')
+        expect(result).to be_kind_of(Loxxy::Datatype::Number)
+        expect(result == 15).to be_true
+      end
+
+      it 'should evaluate a division of two numbers' do
+        result = subject.evaluate('8 / 2; // => 4')
+        expect(result).to be_kind_of(Loxxy::Datatype::Number)
+        expect(result == 4).to be_true
+      end
+    end # context
+
     context 'Evaluating Lox code:' do
       let(:hello_world) { 'print "Hello, world!";' }
 
@@ -33,18 +59,170 @@ module Loxxy
         expect(result).to be_kind_of(Loxxy::Datatype::True)
       end
 
-      it 'should evaluate arithmetic operation' do
-        result = subject.evaluate('123 + 456; // => 579')
-        expect(result).to be_kind_of(Loxxy::Datatype::Number)
-        expect(result == 579).to be_true
-      end
-
       it 'should evaluate string concatenation' do
         result = subject.evaluate('"str" + "ing"; // => "string"')
         expect(result).to be_kind_of(Loxxy::Datatype::LXString)
         expect(result == 'string').to be_true
       end
 
+      it 'should perform the equality tests of two values' do
+        [
+          ['nil == nil;', true],
+          ['true == true;', true],
+          ['true == false;', false],
+          ['1 == 1;', true],
+          ['1 == 2;', false],
+          ['0 == 0;', true],
+          ['"str" == "str";', true],
+          ['"str" == "ing";', false],
+          ['"" == "";', true],
+          ['nil == false;', false],
+          ['false == 0;', false],
+          ['0 == "0";', false]
+        ].each do |(source, predicted)|
+          lox = Loxxy::Interpreter.new
+          result = lox.evaluate(source)
+          expect(result.value == predicted).to be_truthy
+        end
+      end
+
+      it 'should perform the inequality test of two values' do
+        [
+          ['nil != nil;', false],
+          ['true != true;', false],
+          ['true != false;', true],
+          ['1 != 1;', false],
+          ['1 != 2;', true],
+          ['0 != 0;', false],
+          ['"str" != "str";', false],
+          ['"str" != "ing";', true],
+          ['"" != "";', false],
+          ['nil != false;', true],
+          ['false != 0;', true],
+          ['0 != "0";', true]
+        ].each do |(source, predicted)|
+          lox = Loxxy::Interpreter.new
+          result = lox.evaluate(source)
+          expect(result.value == predicted).to be_truthy
+        end
+      end
+
+      it 'should evaluate a comparison of two numbers' do
+        [
+          ['1 < 2;', true],
+          ['2 < 2;', false],
+          ['2 < 1;', false],
+          ['1 <= 2;', true],
+          ['2 <= 2;', true],
+          ['2 <= 1;', false],
+          ['1 > 2;', false],
+          ['2 > 2;', false],
+          ['2 > 1;', true],
+          ['1 >= 2;', false],
+          ['2 >= 2;', true],
+          ['2 >= 1;', true],
+          ['0 < -0;', false],
+          ['-0 < 0;', false],
+          ['0 > -0;', false],
+          ['-0 > 0;', false],
+          ['0 <= -0;', true],
+          ['-0 <= 0;', true],
+          ['0 >= -0;', true],
+          ['-0 >= 0;', true]
+        ].each do |(source, predicted)|
+          lox = Loxxy::Interpreter.new
+          result = lox.evaluate(source)
+          expect(result.value == predicted).to be_truthy
+        end
+      end
+
+      it 'should evaluate the change sign of a number' do
+        [
+          ['- 3;', -3],
+          ['- - 3;', 3],
+          ['- - - 3;', -3]
+        ].each do |(source, predicted)|
+          lox = Loxxy::Interpreter.new
+          result = lox.evaluate(source)
+          expect(result.value == predicted).to be_truthy
+        end
+      end
+
+      it 'should evaluate the negation of an object' do
+        [
+          ['!true;', false],
+          ['!false;', true],
+          ['!!true;', true],
+          ['!123;', false],
+          ['!0;', false],
+          ['!nil;', true],
+          ['!"";', false]
+        ].each do |(source, predicted)|
+          lox = Loxxy::Interpreter.new
+          result = lox.evaluate(source)
+          expect(result.value == predicted).to be_truthy
+        end
+      end
+
+      it 'should evaluate the "conjunction" of two values' do
+        [
+          # Return the first falsey argument
+          ['false and 1;', false],
+          ['nil and 1;', nil],
+          ['true and 1;', 1],
+          ['1 and 2 and false;', false],
+          ['1 and 2 and nil;', nil],
+
+          # Return the last argument if all are truthy
+          ['1 and true;', true],
+          ['0 and true;', true],
+          ['"false" and 0;', 0],
+          ['1 and 2 and 3;', 3]
+
+          # TODO test short-circuit at first false argument
+        ].each do |(source, predicted)|
+          lox = Loxxy::Interpreter.new
+          result = lox.evaluate(source)
+          expect(result.value == predicted).to be_truthy
+        end
+      end
+
+      it 'should evaluate the "disjunction" of two values' do
+        [
+          # Return the first truthy argument
+          ['1 or true;', 1],
+          ['false or 1;', 1],
+          ['nil or 1;', 1],
+          ['false or false or true;', true],
+          ['1 and 2 and nil;', nil],
+
+          # Return the last argument if all are falsey
+          ['false or false;', false],
+          ['nil or false;', false],
+          ['false or nil;', nil],
+          ['false or false or false;', false],
+          ['false or false or nil;', nil]
+
+          # TODO test short-circuit at first false argument
+        ].each do |(source, predicted)|
+          lox = Loxxy::Interpreter.new
+          result = lox.evaluate(source)
+          expect(result.value == predicted).to be_truthy
+        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.14
+  version: 0.0.19
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-10 00:00:00.000000000 Z
+date: 2021-01-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -89,10 +89,13 @@ 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
 - lib/loxxy/ast/lox_noop_expr.rb
 - lib/loxxy/ast/lox_print_stmt.rb
+- lib/loxxy/ast/lox_unary_expr.rb
 - lib/loxxy/back_end/engine.rb
 - lib/loxxy/datatype/all_datatypes.rb
 - lib/loxxy/datatype/boolean.rb