loxxy 0.0.11 → 0.0.16

data/lib/loxxy/ast/ast_visitor.rb

@@ -39,75 +39,63 @@ module Loxxy
         top.accept(self)
       end
 
-      # Visit event. The visitor is visiting the
-      # given terminal node containing a datatype object.
-      # @param aLiteralExpr [AST::LoxLiteralExpr] the leaf node to visit.
-      def visit_literal_expr(aLiteralExpr)
-        broadcast(:before_literal_expr, aLiteralExpr)
-        broadcast(:after_literal_expr, aLiteralExpr)
+      # Visit event. The visitor is about to visit the ptree.
+      # @param aParseTree [Rley::PTre::ParseTree] the ptree to visit.
+      def start_visit_ptree(aParseTree)
+        broadcast(:before_ptree, aParseTree)
       end
 
-=begin
+      # Visit event. The visitor has completed the visit of the ptree.
+      # @param aParseTree [Rley::PTre::ParseTree] the visited ptree.
+      def end_visit_ptree(aParseTree)
+        broadcast(:after_ptree, aParseTree)
+      end
 
+      # Visit event. The visitor is about to visit a print statement expression.
+      # @param aPrintStmt [AST::LOXPrintStmt] the print statement node to visit
+      def visit_print_stmt(aPrintStmt)
+        broadcast(:before_print_stmt, aPrintStmt)
+        traverse_subnodes(aPrintStmt)
+        broadcast(:after_print_stmt, aPrintStmt)
+      end
 
-      def visit_compound_datum(aCompoundDatum)
-        broadcast(:before_compound_datum, aCompoundDatum)
-        traverse_children(aCompoundDatum)
-        broadcast(:after_compound_datum, aCompoundDatum)
+      # Visit event. The visitor is about to visit a print statement expression.
+      # @param aBinaryExpr [AST::LOXBinaryExpr] the binary expression node to visit
+      def visit_binary_expr(aBinaryExpr)
+        broadcast(:before_binary_expr, aBinaryExpr)
+        traverse_subnodes(aBinaryExpr)
+        broadcast(:after_binary_expr, aBinaryExpr)
       end
 
       # Visit event. The visitor is visiting the
-      # given empty list object.
-      # @param anEmptyList [SkmEmptyList] the empty list object to visit.
-      def visit_empty_list(anEmptyList)
-        broadcast(:before_empty_list, anEmptyList)
-        broadcast(:after_empty_list, anEmptyList)
+      # given terminal node containing a datatype object.
+      # @param aLiteralExpr [AST::LoxLiteralExpr] the leaf node to visit.
+      def visit_literal_expr(aLiteralExpr)
+        broadcast(:before_literal_expr, aLiteralExpr)
+        broadcast(:after_literal_expr, aLiteralExpr)
       end
 
-      def visit_pair(aPair)
-        broadcast(:before_pair, aPair)
-        traverse_car_cdr(aPair)
-        broadcast(:after_pair, aPair)
-      end
-=end
-=begin
-   # Visit event. The visitor is about to visit the given non terminal node.
-    # @param aNonTerminalNode [NonTerminalNode] the node to visit.
-    def visit_nonterminal(aNonTerminalNode)
-      if @traversal == :post_order
-        broadcast(:before_non_terminal, aNonTerminalNode)
-        traverse_subnodes(aNonTerminalNode)
-      else
-        traverse_subnodes(aNonTerminalNode)
-        broadcast(:before_non_terminal, aNonTerminalNode)
+      # Visit event. The visitor is about to visit the given non terminal node.
+      # @param aNonTerminalNode [Rley::PTre::NonTerminalNode] the node to visit.
+      def visit_nonterminal(_non_terminal_node)
+        # Loxxy interpreter encountered a CST node (Concrete Syntax Tree)
+        # that it cannot handle.
+        raise NotImplementedError, 'Loxxy cannot execute this code yet.'
       end
-      broadcast(:after_non_terminal, aNonTerminalNode)
-    end
-=end
 
       private
 
-      def traverse_children(aParent)
-        children = aParent.children
-        broadcast(:before_children, aParent, children)
+      # Visit event. The visitor is about to visit the subnodes of a non
+      # terminal node.
+      # @param aParentNode [Ast::LocCompoundExpr] the parent node.
+      def traverse_subnodes(aParentNode)
+        subnodes = aParentNode.subnodes
+        broadcast(:before_subnodes, aParentNode, subnodes)
 
-        # Let's proceed with the visit of children
-        children.each { |a_child| a_child.accept(self) }
+        # Let's proceed with the visit of subnodes
+        subnodes.each { |a_node| a_node.accept(self) }
 
-        broadcast(:after_children, aParent, children)
-      end
-
-      def traverse_car_cdr(aPair)
-        if aPair.car
-          broadcast(:before_car, aPair, aPair.car)
-          aPair.car.accept(self)
-          broadcast(:after_car, aPair, aPair.car)
-        end
-        if aPair.cdr
-          broadcast(:before_cdr, aPair, aPair.cdr)
-          aPair.cdr.accept(self)
-          broadcast(:after_cdr, aPair, aPair.cdr)
-        end
+        broadcast(:after_subnodes, aParentNode, subnodes)
       end
 
       # Send a notification to all subscribers.
@@ -117,7 +105,7 @@ module Loxxy
         subscribers.each do |subscr|
           next unless subscr.respond_to?(msg) || subscr.respond_to?(:accept_all)
 
-          subscr.send(msg, runtime, *args)
+          subscr.send(msg, *args)
         end
       end
     end # class

data/lib/loxxy/ast/lox_binary_expr.rb

@@ -16,6 +16,12 @@ module Loxxy
         @operator = anOperator
       end
 
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [Ast::ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_binary_expr(self)
+      end
+
       alias operands subnodes
     end # class
   end # module

data/lib/loxxy/ast/lox_compound_expr.rb

@@ -5,7 +5,7 @@ require_relative 'lox_node'
 module Loxxy
   module Ast
     class LoxCompoundExpr < LoxNode
-      # @return [Array<Ast::LoxNode>]
+      # @return [Array<Ast::LoxNode>] the children nodes (sub-expressions)
       attr_reader :subnodes
 
       # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.

data/lib/loxxy/ast/lox_node.rb

@@ -11,6 +11,11 @@ module Loxxy
         @position = aPosition
       end
 
+      # Notification that the parsing was successfully completed
+      def done!
+        # Default: do nothing ...
+      end
+
       # Abstract method.
       # Part of the 'visitee' role in Visitor design pattern.
       # @param _visitor [LoxxyTreeVisitor] the visitor

data/lib/loxxy/ast/lox_noop_expr.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative 'lox_node'
+
+module Loxxy
+  module Ast
+    class LoxNoopExpr < LoxNode
+      # Abstract method.
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param _visitor [LoxxyTreeVisitor] the visitor
+      def accept(_visitor)
+        # Do nothing...
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/ast/lox_print_stmt.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'lox_compound_expr'
+
+module Loxxy
+  module Ast
+    class LoxPrintStmt < LoxCompoundExpr
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      # @param anExpression [Ast::LoxNode] expression to output
+      def initialize(aPosition, anExpression)
+        super(aPosition, [anExpression])
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [Ast::ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_print_stmt(self)
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/back_end/engine.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+# Load all the classes implementing AST nodes
+require_relative '../ast/all_lox_nodes'
+
+module Loxxy
+  module BackEnd
+    # An instance of this class executes the statements as when they
+    # occur during the abstract syntax tree walking.
+    # @note WIP: very crude implementation.
+    class Engine
+      # @return [Hash] A set of configuration options
+      attr_reader :config
+
+      # @return [Array] Data stack used for passing data between statements
+      attr_reader :stack
+
+      # @param theOptions [Hash]
+      def initialize(theOptions)
+        @config = theOptions
+        @ostream = config.include?(:ostream) ? config[:ostream] : $stdout
+        @stack = []
+      end
+
+      # Given an abstract syntax parse tree visitor, luanch the visit
+      # and execute the visit events in the output stream.
+      # @param aVisitor [AST::ASTVisitor]
+      # @return [Loxxy::Datatype::BuiltinDatatype]
+      def execute(aVisitor)
+        aVisitor.subscribe(self)
+        aVisitor.start
+        aVisitor.unsubscribe(self)
+        stack.empty? ? Datatype::Nil.instance : stack.pop
+      end
+
+      # Visit event handling
+
+      def after_print_stmt(_printStmt)
+        tos = stack.pop
+        @ostream.print tos.to_str
+      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)
+          stack.push operand1.send(op, operand2)
+        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)
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/datatype/boolean.rb

@@ -8,6 +8,17 @@ module Loxxy
     # An instance acts merely as a wrapper around a Ruby representation
     # of the value.
     class Boolean < BuiltinDatatype
+      # Is this object representing a false value in Lox?
+      # @return [FalseClass, TrueClass]
+      def false?
+        false
+      end
+
+      # Is this object representing the true value in Lox?
+      # @return [FalseClass, TrueClass]
+      def true?
+        false
+      end
     end # class
   end # module
 end # module

data/lib/loxxy/datatype/builtin_datatype.rb

@@ -14,6 +14,12 @@ module Loxxy
         @value = validated_value(aValue)
       end
 
+      # Method called from Lox to obtain the text representation of the boolean.
+      # @return [String]
+      def to_str
+        value.to_s # Default implementation...
+      end
+
       protected
 
       def validated_value(aValue)

data/lib/loxxy/datatype/false.rb

@@ -13,6 +13,28 @@ module Loxxy
       def initialize
         super(false)
       end
+
+      # Is this object representing a false value in Lox?
+      # @return [TrueClass]
+      def false?
+        true
+      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
+
+      # 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

@@ -1,26 +1,62 @@
 # frozen_string_literal: true
 
-require_relative 'builtin_datatype'
+require_relative 'false'
+require_relative 'true'
 
 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]
-      # @return [Boolean]
+      # Check the equality 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
-          when String
-            value == other
+        when LXString
+          (value == other.value) ? True.instance : False.instance
+        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
 
+      # 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]
+      # @return [Loxxy::Datatype::LXString]
+      def +(other)
+        case other
+        when LXString
+          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
+
+      # Method called from Lox to obtain the text representation of the object.
+      # @return [String]
+      def to_str
+        value
+      end
+
       protected
 
       def validated_value(aValue)

data/lib/loxxy/datatype/nil.rb

@@ -13,6 +13,28 @@ module Loxxy
       def initialize
         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
+
+      # 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
+      end
+
+      # Method called from Lox to obtain the text representation of nil.
+      # @return [String]
+      def to_str
+        'nil'
+      end
     end # class
 
     Nil.instance.freeze # Make the sole instance immutable

data/lib/loxxy/datatype/number.rb

@@ -1,11 +1,104 @@
 # frozen_string_literal: true
 
-require_relative 'builtin_datatype'
+require_relative 'false'
+require_relative 'true'
 
 module Loxxy
   module Datatype
     # Class for representing a Lox numeric value.
     class Number < BuiltinDatatype
+      # 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
+
+      # 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 the inequality 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
+          True.instance
+        end
+      end
+
       protected
 
       def validated_value(aValue)