loxxy 0.0.16 → 0.0.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d7d30d3246aa8a8f06f3456d3996c680e9ddb4ed31bcf9fff99685702e50dd1
-  data.tar.gz: dc428ddd0fc03e153e70873bc2827b6e4aac813e5fdfba40ef2f28bfa7283fc2
+  metadata.gz: 6eed6a7de54b89c276b0f098cd7d824f26c0ce9ba957d4fb9e3a4d12e6dfbc4f
+  data.tar.gz: ba7c00f11c5b69322aec0d447c2fef9cf6d6d74b2ea7bb16096581508a786427
 SHA512:
-  metadata.gz: d90f2494a324be036dae2f3d38636c571009b60f19d2b3d917b242ab98d231e03bb121f577e5598ac63514cc5817814972cabe927f05af2842a5a97c89eb69d9
-  data.tar.gz: e09a70a27baa1408904e1bfe512f4f523b8e4efd1aab00412b993c8f4a35b5498f1f6ddb5e67697108c80a91778301e41c15741451e73e1d869496d96441757a
+  metadata.gz: 1b2c3826f085ce3f723cdbc70c3bdc3563817270985a321db05f97ca1ff81971bf872db49631d3fa20580932f7a0e2910bf3c6c84daf7873cdcd1f04c3392a99
+  data.tar.gz: 4e3d075facaf9c370d78f3f3ac89b7226e375eb32064535e3401c5ef52b8ca43c9d4c6cfb8f027b4037c7baa7c5945b0fd0dbe1e8b1e580fc732c4a38f7c57c6

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,18 @@
+## [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
@@ -36,7 +51,7 @@
 - The interpreter can evaluate addition of numbers and string concatenation
 
 ## Added
-- Method `Ast::ASTVisitor::visit_binary_expr` for visiting binary expressions
+- 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

data/README.md

@@ -154,21 +154,16 @@ The parser knows all the __Lox__ reserved keywords:
 and, class, else, false, fun, for, if, nil, or,
 print, return, super, this, true, var, while
 ```
-Of these, the interpreter implements: `false`, `nil`, `true`
+Of these, the interpreter implements: `false`, `nil`, `print`, `true`
 
 ### Operators and Special Chars
 #### Operators
-The parser recognizes all the __Lox__ operators, delimiters and separators:
+The __loxxy__ interpreter supports all the __Lox__ unary and binary operators:
 - Arithmetic operators: `+`, `-`, `*`, `/`
 - Comparison operators: `>`, `>=`, `<`, `<=`
 - Equality operators: `==`, `!=`
-
-Of these, the interpreter implements: 
-`+` (addition of two numbers or string concatenation)
-`-` (difference between two numbers)
-`*` (product of two numbers)
-`/` (division of two number)
-`==` and `!=` (in)equality testing of two Lox values
+- Unary negate (change sign): `-`
+- Unary not: `!`
 
 #### Delimiters
 The parser knows all the __Lox__ grouping delimiters:  
@@ -196,9 +191,11 @@ loxxy supports  all the standard __Lox__ datatypes:
 ### Implemented expressions
 Loxxy implements expressions:
 - Plain literals only; or,
-- Addition, subtraction, product and division of two numbers; or,
+- (In)equality testing between two values; or,   
+- Basic arithmetic operations (`+`, `-`, `*`, `/`, `unary -`); or,  
+- Comparison between two numbers; or,
 - Concatenation of two strings,
-- (In)equality test of two Lox values
+- Negation `!`
 
 ### Implemented statements
 Loxxy implements the following statements:
@@ -206,7 +203,7 @@ Loxxy implements the following statements:
 - Print statement
 
 ```javascript
-// Print statement with nested concatenation
+// Print statement with nested string concatenation
 print "Hello" + ", " + "world!";
 ```
 

data/lib/loxxy/ast/all_lox_nodes.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
-require_relative 'lox_print_stmt'
 require_relative 'lox_literal_expr'
 require_relative 'lox_noop_expr'
+require_relative 'lox_binary_expr'
+require_relative 'lox_unary_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
@@ -231,6 +235,13 @@ 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' => '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,7 @@ 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 binary expression.
       # @param aBinaryExpr [AST::LOXBinaryExpr] the binary expression node to visit
       def visit_binary_expr(aBinaryExpr)
         broadcast(:before_binary_expr, aBinaryExpr)
@@ -67,6 +67,14 @@ 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 visiting the
       # given terminal node containing a datatype object.
       # @param aLiteralExpr [AST::LoxLiteralExpr] the leaf node to visit.

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_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]
@@ -44,8 +44,7 @@ module Loxxy
         op = aBinaryExpr.operator
         operand2 = stack.pop
         operand1 = stack.pop
-        implemented = %i[+ - * / == !=].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 +52,17 @@ 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
+
       # @param literalExpr [Ast::LoxLiteralExpr]
       def before_literal_expr(literalExpr)
         stack.push(literalExpr.literal)

data/lib/loxxy/datatype/builtin_datatype.rb

@@ -14,6 +14,34 @@ 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
+
+      # Negation ('not')
+      # Returns a boolean with opposite truthiness value.
+      # @return [Datatype::Boolean]
+      def !
+        falsey? ? True.instance : False.instance
+      end
+
+      # Check for inequality of this object with another Lox object
+      # @param other [Datatype::BuiltinDatatype, Object]
+      # @return [Datatype::Boolean]
+      def !=(other)
+        !(self == other)
+      end
+
       # Method called from Lox to obtain the text representation of the boolean.
       # @return [String]
       def to_str

data/lib/loxxy/datatype/false.rb

@@ -20,6 +20,20 @@ module Loxxy
         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]
@@ -27,14 +41,6 @@ module Loxxy
         falsey = other.kind_of?(False) || other.kind_of?(FalseClass)
         falsey ? True.instance : False.instance
       end
-
-      # Check for inequality 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 ? False.instance : True.instance
-      end
     end # class
 
     False.instance.freeze # Make the sole instance immutable

data/lib/loxxy/datatype/lx_string.rb

@@ -21,20 +21,6 @@ module Loxxy
         end
       end
 
-      # Check the inequality of a Lox String with another Lox object.
-      # @param other [Datatype::LxString, String, Object]
-      # @return [Datatype::Boolean]
-      def !=(other)
-        case other
-        when LXString
-          (value != other.value) ? True.instance : False.instance
-        when String
-          (value != other) ? True.instance : False.instance
-        else
-          True.instance
-        end
-      end
-
       # Perform the concatenation of two Lox stings or
       # one Lox string and a Ruby String
       # @param other [Loxxy::Datatype::LXString, String]

data/lib/loxxy/datatype/nil.rb

@@ -22,12 +22,18 @@ module Loxxy
         is_nil ? True.instance : False.instance
       end
 
-      # Check the inequality 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 ? False.instance : True.instance
+      # 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.

data/lib/loxxy/datatype/number.rb

@@ -71,6 +71,12 @@ module Loxxy
         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]
@@ -85,20 +91,52 @@ module Loxxy
         end
       end
 
-      # Check the inequality of a Lox number object with another object
-      # @param other [Datatype::BuiltinDatatype, Numeric, Object]
+      # 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
+          (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 greater or equal value
+      # than given argument.
+      # @param other [Datatype::Number, Numeric]
       # @return [Datatype::Boolean]
-      def !=(other)
+      def >=(other)
         case other
         when Number
-          (value != other.value) ? True.instance : False.instance
+          (value >= other.value) ? True.instance : False.instance
         when Numeric
-          (value != other) ? True.instance : False.instance
+          (value >= other) ? True.instance : False.instance
         else
-          True.instance
+          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

@@ -20,21 +20,13 @@ module Loxxy
         true
       end
 
-      # Check for equality of a Lox True with another Lox object
+      # 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
-
-      # Check for inequality of a Lox True with another Lox object
-      # @param other [Datatype::BuiltinDatatype, TrueClass, Object]
-      # @return [Datatype::Boolean]
-      def !=(other)
-        thruthy = other.kind_of?(True) || other.kind_of?(TrueClass)
-        thruthy ? False.instance : True.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')

data/lib/loxxy/version.rb

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

data/spec/interpreter_spec.rb

@@ -107,6 +107,63 @@ module Loxxy
         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 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.16
+  version: 0.0.17
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-11 00:00:00.000000000 Z
+date: 2021-01-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -93,6 +93,7 @@ files:
 - 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