loxxy 0.0.17 → 0.0.22

data/lib/loxxy/ast/ast_visitor.rb

@@ -51,6 +51,30 @@ module Loxxy
         broadcast(:after_ptree, aParseTree)
       end
 
+      # Visit event. The visitor is about to visit a variable declaration statement.
+      # @param aPrintStmt [AST::LOXVarStmt] the variable declaration node to visit
+      def visit_seq_decl(aSeqDecls)
+        broadcast(:before_seq_decl, aSeqDecls)
+        traverse_subnodes(aSeqDecls)
+        broadcast(:after_seq_decl, aSeqDecls)
+      end
+
+      # Visit event. The visitor is about to visit a variable declaration statement.
+      # @param aPrintStmt [AST::LOXVarStmt] the variable declaration node to visit
+      def visit_var_stmt(aVarStmt)
+        broadcast(:before_var_stmt, aVarStmt)
+        traverse_subnodes(aVarStmt)
+        broadcast(:after_var_stmt, aVarStmt)
+      end
+
+      # Visit event. The visitor is about to visit a if statement.
+      # @param anIfStmt [AST::LOXIfStmt] the if statement node to visit
+      def visit_if_stmt(anIfStmt)
+        broadcast(:before_if_stmt, anIfStmt)
+        traverse_subnodes(anIfStmt) # The condition is visited/evaluated here...
+        broadcast(:after_if_stmt, anIfStmt, self)
+      end
+
       # 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)
@@ -59,6 +83,20 @@ module Loxxy
         broadcast(:after_print_stmt, aPrintStmt)
       end
 
+      # 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)
@@ -75,6 +113,14 @@ module Loxxy
         broadcast(:after_unary_expr, anUnaryExpr)
       end
 
+      # Visit event. The visitor is about to visit a grouping expression.
+      # @param aGroupingExpr [AST::LoxGroupingExpr] grouping expression to visit
+      def visit_grouping_expr(aGroupingExpr)
+        broadcast(:before_grouping_expr, aGroupingExpr)
+        traverse_subnodes(aGroupingExpr)
+        broadcast(:after_grouping_expr, aGroupingExpr)
+      end
+
       # Visit event. The visitor is visiting the
       # given terminal node containing a datatype object.
       # @param aLiteralExpr [AST::LoxLiteralExpr] the leaf node to visit.
@@ -83,8 +129,15 @@ module Loxxy
         broadcast(:after_literal_expr, aLiteralExpr)
       end
 
+      # Visit event. The visitor is visiting a variable reference node
+      # @param aLiteralExpr [AST::LoxVariableExpr] the variable reference node to visit.
+      def visit_variable_expr(aVariableExpr)
+        broadcast(:before_variable_expr, aVariableExpr)
+        broadcast(:after_variable_expr, aVariableExpr, self)
+      end
+
       # Visit event. The visitor is about to visit the given non terminal node.
-      # @param aNonTerminalNode [Rley::PTre::NonTerminalNode] the node to visit.
+      # @param aNonTerminalNode [Rley::PTree::NonTerminalNode] the node to visit.
       def visit_nonterminal(_non_terminal_node)
         # Loxxy interpreter encountered a CST node (Concrete Syntax Tree)
         # that it cannot handle.
@@ -106,6 +159,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_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_seq_decl.rb

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

data/lib/loxxy/ast/lox_var_stmt.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'lox_compound_expr'
+
+module Loxxy
+  module Ast
+    # This AST node represents a variable declaration
+    class LoxVarStmt < LoxCompoundExpr
+      # @return [String] variable name
+      attr_reader :name
+
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      # @param aName [String] name of the variable
+      # @param aValue [Loxxy::Ast::LoxNode, NilClass] initial value for the variable
+      def initialize(aPosition, aName, aValue)
+        initial_value = aValue ? [aValue] : []
+        super(aPosition, initial_value)
+        @name = aName
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [Ast::ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_var_stmt(self)
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/ast/lox_variable_expr.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative 'lox_node'
+
+module Loxxy
+  module Ast
+    # This AST node represents a mention of a variable
+    class LoxVariableExpr < LoxNode
+      # @return [String] variable name
+      attr_reader :name
+
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      # @param aName [String] name of the variable
+      def initialize(aPosition, aName)
+        super(aPosition)
+        @name = aName
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [Ast::ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_variable_expr(self)
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/back_end/engine.rb

@@ -2,6 +2,7 @@
 
 # Load all the classes implementing AST nodes
 require_relative '../ast/all_lox_nodes'
+require_relative 'symbol_table'
 
 module Loxxy
   module BackEnd
@@ -12,13 +13,17 @@ module Loxxy
       # @return [Hash] A set of configuration options
       attr_reader :config
 
-      # @return [Array] Data stack used for passing data between statements
+      # @return [BackEnd::SymbolTable]
+      attr_reader :symbol_table
+
+      # @return [Array<Datatype::BuiltinDatatyp>] Stack for the values of expr
       attr_reader :stack
 
       # @param theOptions [Hash]
       def initialize(theOptions)
         @config = theOptions
         @ostream = config.include?(:ostream) ? config[:ostream] : $stdout
+        @symbol_table = SymbolTable.new
         @stack = []
       end
 
@@ -33,13 +38,66 @@ module Loxxy
         stack.empty? ? Datatype::Nil.instance : stack.pop
       end
 
+      ##########################################################################
       # Visit event handling
+      ##########################################################################
+
+      def after_seq_decl(aSeqDecls)
+        # Do nothing, subnodes were already evaluated
+      end
+
+      def after_var_stmt(aVarStmt)
+        new_var = Variable.new(aVarStmt.name, aVarStmt.subnodes[0])
+        symbol_table.insert(new_var)
+      end
+
+      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
@@ -63,6 +121,17 @@ module Loxxy
         end
       end
 
+      def after_grouping_expr(_groupingExpr)
+        # Do nothing: work was already done by visiting /evaluating the subexpression
+      end
+
+      def after_variable_expr(aVarExpr, aVisitor)
+        var_name = aVarExpr.name
+        var = symbol_table.lookup(var_name)
+        raise StandardError, "Unknown variable #{var_name}" unless var
+        var.value.accept(aVisitor) # Evaluate the variable value
+      end
+
       # @param literalExpr [Ast::LoxLiteralExpr]
       def before_literal_expr(literalExpr)
         stack.push(literalExpr.literal)

data/lib/loxxy/back_end/entry.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Loxxy
+  module BackEnd
+    # Mix-in module that implements the expected common behaviour of entries
+    # placed in the symbol table.
+    module Entry
+      # @return [String] User-defined name of the entry.
+      attr_reader :name
+
+=begin
+      # @return [String] Suffix for building the internal name of the entry.
+      attr_accessor :suffix
+=end      
+
+      # Initialize the entry with given name
+      # @param aName [String] The name of the entry
+      def init_name(aName)
+        @name = aName.dup
+        @name.freeze
+      end
+=begin
+      # Return the internal name of the entry
+      # Internal names used to disambiguate entry names.
+      # There might be homonyns between variable because:
+      #   - A child Scope may have a entry with same name as one of its
+      #     ancestor(s).
+      #   - Multiple calls to same defrel or procedure may imply multiple creation
+      #     of a entry given name...
+      # @return [String] internal name
+      def i_name
+        if suffix =~ /^_/
+          label + suffix
+        else
+          (suffix.nil? || suffix.empty?) ? label : suffix
+        end
+      end
+=end      
+    end # module
+  end # module
+end # module

data/lib/loxxy/back_end/environment.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative 'variable'
+
+module Loxxy
+  module BackEnd
+    # A environment is a name space that corresponds either to a specific
+    # delimited region in Loxxy source code or to an activation record
+    # of a relation or a relation definition.
+    # It contains a map of names to the objects they name (e.g. logical var)
+    class Environment
+      # The parent (enclosing) environment.
+      # @return [Environment, NilClass]
+      attr_accessor :parent
+
+      # Mapping from user-defined name to related definition
+      #  (say, a variable object)
+      # @return [Hash{String => Variable}] Pairs of the kind
+      attr_reader :defns
+
+      # Construct a environment instance.
+      # @param aParent [Environment, NilClass] Parent environment to this one.
+      def initialize(aParent = nil)
+        @parent = aParent
+        @defns = {}
+      end
+
+      # Add a new variable to the environment.
+      # @param anEntry [BackEnd::Variable]
+      # @return [BackEnd::Variable] the variable
+      def insert(anEntry)
+        e = validated_entry(anEntry)
+        # e.suffix = default_suffix if e.kind_of?(BackEnd::Variable)
+        defns[e.name] = e
+
+        e
+      end
+
+      # Returns a string with a human-readable representation of the object.
+      # @return [String]
+      def inspect
+        +"#<#{self.class}:#{object_id.to_s(16)}>"
+      end
+
+      private
+
+      def validated_entry(anEntry)
+        name = anEntry.name
+        unless name.kind_of?(String) && !name.empty?
+          err_msg = 'Invalid variable name argument.'
+          raise StandardError, err_msg
+        end
+        if defns.include?(name) && !anEntry.kind_of?(Variable)
+          err_msg = "Variable with name '#{name}' already exists."
+          raise StandardError, err_msg
+        end
+
+        anEntry
+      end
+
+      # def default_suffix
+        # @default_suffix ||= "_#{object_id.to_s(16)}"
+      # end
+    end # class
+  end # module
+end # module