loxxy 0.0.18 → 0.0.23

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)
@@ -89,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.
@@ -97,8 +129,22 @@ 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 terminal datatype value.
+      # @param aNonTerminalNode [Ast::BuiltinDattype] the built-in datatype value
+      def visit_builtin(aValue)
+        broadcast(:before_visit_builtin, aValue)
+        broadcast(:after_visit_builtin, aValue)
+      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.

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'lox_compound_expr'
+
+module Loxxy
+  module Ast
+    class LoxSeqDecl < LoxCompoundExpr
+      # 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] : [Datatype::Nil.instance]
+        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,7 +38,28 @@ 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?
+          anIfStmt.then_stmt.accept(aVisitor)
+        elsif anIfStmt.else_stmt
+          anIfStmt.else_stmt.accept(aVisitor)
+        end
+      end
 
       def after_print_stmt(_printStmt)
         tos = stack.pop
@@ -95,10 +121,27 @@ 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)
       end
+
+      # @param aNonTerminalNode [Ast::BuiltinDattype] the built-in datatype value
+      def before_visit_builtin(aValue)
+        stack.push(aValue)
+      end
     end # class
   end # module
 end # module

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

data/lib/loxxy/back_end/symbol_table.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require_relative 'environment'
+
+module Loxxy
+  module BackEnd
+    # A symbol table is basically a mapping from a name onto an object
+    # that holds information associated with that name. It is a data structure
+    # that keeps track of variables and their respective environment where they are
+    # declared. The key requirements for the symbol are:
+    # - To perform fast lookup operations: given a name, retrieve the corresponding
+    #   object.
+    # - To allow the efficient insertion of names and related information
+    # - To support the nesting of environments
+    # - To handle the entry environment and exit environment events,
+    # - To cope with variable redefinition in nested environment
+    # The terminology 'symbol table' comes from the compiler design
+    # community.
+    class SymbolTable
+      # Mapping between a name and the environment(s) where it is defined
+      # @return [Hash{String => Array<Environment>}]
+      attr_reader :name2envs
+
+      # @return [Environment] The top-level environment (= root of environment tree)
+      attr_reader :root
+
+      # @return [Environment] The current environment.
+      attr_reader :current_env
+
+      # Build symbol table with given environment as root.
+      # @param anEnv [BackEnd::Environment,NilClass] The top-level Environment
+      def initialize(anEnv = nil)
+        @name2envs = {}
+        init_root(anEnv) # Set default (global) environment
+      end
+
+      # Returns iff there is no entry in the symbol table
+      # @return [Boolean]
+      def empty?
+        name2envs.empty?
+      end
+
+      # Use this method to signal the interpreter that a given environment
+      # to be a child of current environment and to be itself the new current environment.
+      # @param anEnv [BackEnd::Environment] the Environment that
+      def enter_environment(anEnv)
+        anEnv.parent = current_env
+        @current_env = anEnv
+      end
+
+      def leave_environment
+        current_env.defns.each_pair do |nm, _item|
+          environments = name2envs[nm]
+          if environments.size == 1
+            name2envs.delete(nm)
+          else
+            environments.pop
+            name2envs[nm] = environments
+          end
+        end
+        raise StandardError, 'Cannot remove root environment.' if current_env == root
+
+        @current_env = current_env.parent
+      end
+
+      # Add an entry with given name to current environment.
+      # @param anEntry [Variable]
+      # @return [String] Internal name of the entry
+      def insert(anEntry)
+        current_env.insert(anEntry)
+        name = anEntry.name
+        if name2envs.include?(name)
+          name2envs[name] << current_env
+        else
+          name2envs[name] = [current_env]
+        end
+
+        anEntry.name # anEntry.i_name
+      end
+
+      # Search for the object with the given name
+      # @param aName [String]
+      # @return [BackEnd::Variable]
+      def lookup(aName)
+        environments = name2envs.fetch(aName, nil)
+        return nil if environments.nil?
+
+        sc = environments.last
+        sc.defns[aName]
+      end
+
+      # Search for the object with the given i_name
+      # @param anIName [String]
+      # @return [BackEnd::Variable]
+      # def lookup_i_name(anIName)
+        # found = nil
+        # environment = current_env
+
+        # begin
+          # found = environment.defns.values.find { |e| e.i_name == anIName }
+          # break if found
+
+          # environment = environment.parent
+        # end while environment
+
+        # found
+      # end
+
+      # Return all variables defined in the current .. root chain.
+      # Variables are sorted top-down and left-to-right.
+      def all_variables
+        vars = []
+        skope = current_env
+        while skope
+          vars_of_environment = skope.defns.select { |_, item| item.kind_of?(Variable) }
+          vars = vars_of_environment.values.concat(vars)
+          skope = skope.parent
+        end
+
+        vars
+      end
+
+      private
+
+      def init_root(anEnv)
+        @root = valid_environment(anEnv)
+        @current_env = @root
+      end
+
+      def valid_environment(anEnv)
+        anEnv.nil? ? Environment.new : anEnv
+      end
+    end # class
+  end # module
+end # module