loxxy 0.0.15 → 0.0.20

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_if_stmt.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'lox_compound_expr'
+
+module Loxxy
+  module Ast
+    class LoxIfStmt < LoxCompoundExpr
+      # @return [LoxNode] code of then branch
+      attr_reader :then_stmt
+
+      # @return [LoxNode, NilClass] code of else branch
+      attr_reader :else_stmt
+
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      # @param subExpr [Loxxy::Ast::LoxNode]
+      def initialize(aPosition, condExpr, thenStmt, elseStmt)
+        super(aPosition, [condExpr])
+        @then_stmt = thenStmt
+        @else_stmt = elseStmt
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [Ast::ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_if_stmt(self)
+      end
+
+      # Accessor to the condition expression
+      # @return [LoxNode]
+      def condition
+        subnodes[0]
+      end
+    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]
@@ -33,19 +33,61 @@ module Loxxy
         stack.empty? ? Datatype::Nil.instance : stack.pop
       end
 
+      ##########################################################################
       # Visit event handling
+      ##########################################################################
+      def after_if_stmt(anIfStmt, aVisitor)
+        # Retrieve the result of the condition evaluation
+        condition = stack.pop
+        if condition.truthy?
+          result = anIfStmt.then_stmt.accept(aVisitor)
+        elsif anIfStmt.else_stmt
+          anIfStmt.else_stmt.accept(aVisitor)
+        end
+      end
 
       def after_print_stmt(_printStmt)
         tos = stack.pop
         @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 = %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 +95,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,21 +7,6 @@ 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]
-      # @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
-          err_msg = "Cannot compare a #{self.class} with #{other.class}"
-          raise StandardError, err_msg
-        end
-      end
-
       # Perform the addition of two Lox numbers or
       # one Lox number and a Ruby Numeric
       # @param other [Loxxy::Datatype::Number, Numeric]
@@ -54,6 +39,104 @@ module Loxxy
         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
+        when Number
+          (value == other.value) ? True.instance : False.instance
+        when Numeric
+          (value == other) ? True.instance : False.instance
+        else
+          False.instance
+        end
+      end
+
+      # 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)
+        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)