loxxy 0.0.21 → 0.0.26

data/lib/loxxy/ast/ast_visitor.rb

@@ -51,6 +51,14 @@ 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)
@@ -75,6 +83,30 @@ module Loxxy
         broadcast(:after_print_stmt, aPrintStmt)
       end
 
+      # Visit event. The visitor is about to visit a while statement node.
+      # @param aWhileStmt [AST::LOXWhileStmt] the while statement node to visit
+      def visit_while_stmt(aWhileStmt)
+        broadcast(:before_while_stmt, aWhileStmt)
+        traverse_subnodes(aWhileStmt) # The condition is visited/evaluated here...
+        broadcast(:after_while_stmt, aWhileStmt, self)
+      end
+
+      # Visit event. The visitor is about to visit a block statement.
+      # @param aBlockStmt [AST::LOXBlockStmt] the print statement node to visit
+      def visit_block_stmt(aBlockStmt)
+        broadcast(:before_block_stmt, aBlockStmt)
+        traverse_subnodes(aBlockStmt)
+        broadcast(:after_block_stmt, aBlockStmt)
+      end
+
+      # Visit event. The visitor is visiting an assignment node
+      # @param aLiteralExpr [AST::LoxAssignExpr] the variable assignment node to visit.
+      def visit_assign_expr(anAssignExpr)
+        broadcast(:before_assign_expr, anAssignExpr)
+        traverse_subnodes(anAssignExpr)
+        broadcast(:after_assign_expr, anAssignExpr)
+      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.
@@ -121,8 +153,22 @@ module Loxxy
         broadcast(:after_literal_expr, aLiteralExpr)
       end
 
+      # Visit event. The visitor is visiting a variable usage 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_assign_expr.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'lox_compound_expr'
+
+module Loxxy
+  module Ast
+    # This AST node represents the assignment of a value to a variable
+    class LoxAssignExpr < 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] value to assign
+      def initialize(aPosition, aName, aValue)
+        super(aPosition, [aValue])
+        @name = aName
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [Ast::ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_assign_expr(self)
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/ast/lox_block_stmt.rb

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

data/lib/loxxy/ast/lox_if_stmt.rb

@@ -32,4 +32,4 @@ module Loxxy
       end
     end # class
   end # module
-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

@@ -13,7 +13,7 @@ module Loxxy
       # @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] : []
+        initial_value = aValue ? [aValue] : [Datatype::Nil.instance]
         super(aPosition, initial_value)
         @name = aName
       end

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/ast/lox_while_stmt.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'lox_compound_expr'
+
+module Loxxy
+  module Ast
+    class LoxWhileStmt < LoxCompoundExpr
+      # @return [LoxNode] body of the while loop (as a statement)
+      attr_reader :body
+
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      # @param condExpr [Loxxy::Ast::LoxNode] iteration condition
+      # @param theBody [Loxxy::Ast::LoxNode]
+      def initialize(aPosition, condExpr, theBody)
+        super(aPosition, [condExpr])
+        @body = theBody
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [Ast::ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_while_stmt(self)
+      end
+
+      # Accessor to the condition expression
+      # @return [LoxNode]
+      def condition
+        subnodes[0]
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/back_end/engine.rb

@@ -41,6 +41,11 @@ module Loxxy
       ##########################################################################
       # 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)
@@ -50,7 +55,7 @@ module Loxxy
         # Retrieve the result of the condition evaluation
         condition = stack.pop
         if condition.truthy?
-          result = anIfStmt.then_stmt.accept(aVisitor)
+          anIfStmt.then_stmt.accept(aVisitor)
         elsif anIfStmt.else_stmt
           anIfStmt.else_stmt.accept(aVisitor)
         end
@@ -61,6 +66,35 @@ module Loxxy
         @ostream.print tos.to_str
       end
 
+      def after_while_stmt(aWhileStmt, aVisitor)
+        loop do
+          condition = stack.pop
+          break unless condition.truthy?
+
+          aWhileStmt.body.accept(aVisitor)
+          aWhileStmt.condition.accept(aVisitor)
+        end
+      end
+
+      def before_block_stmt(_aBlockStmt)
+        new_env = Environment.new
+        symbol_table.enter_environment(new_env)
+      end
+
+      def after_block_stmt(_aBlockStmt)
+        symbol_table.leave_environment
+      end
+
+      def after_assign_expr(anAssignExpr)
+        var_name = anAssignExpr.name
+        variable = symbol_table.lookup(var_name)
+        raise StandardError, "Unknown variable #{var_name}" unless variable
+
+        value = stack.pop
+        variable.assign(value)
+        stack.push value # An expression produces a value
+      end
+
       def after_logical_expr(aLogicalExpr, visitor)
         op = aLogicalExpr.operator
         operand1 = stack.pop # only first operand was evaluated
@@ -120,10 +154,23 @@ module Loxxy
         # 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

@@ -11,7 +11,7 @@ module Loxxy
 =begin
       # @return [String] Suffix for building the internal name of the entry.
       attr_accessor :suffix
-=end      
+=end
 
       # Initialize the entry with given name
       # @param aName [String] The name of the entry
@@ -35,7 +35,7 @@ module Loxxy
           (suffix.nil? || suffix.empty?) ? label : suffix
         end
       end
-=end      
+=end
     end # module
   end # module
 end # module

data/lib/loxxy/back_end/environment.rb

@@ -9,9 +9,9 @@ module Loxxy
     # 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.
+      # The  enclosing (parent) environment.
       # @return [Environment, NilClass]
-      attr_accessor :parent
+      attr_accessor :enclosing
 
       # Mapping from user-defined name to related definition
       #  (say, a variable object)
@@ -21,7 +21,7 @@ module Loxxy
       # Construct a environment instance.
       # @param aParent [Environment, NilClass] Parent environment to this one.
       def initialize(aParent = nil)
-        @parent = aParent
+        @enclosing = aParent
         @defns = {}
       end
 

data/lib/loxxy/back_end/symbol_table.rb

@@ -44,7 +44,7 @@ module Loxxy
       # 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
+        anEnv.enclosing = current_env
         @current_env = anEnv
       end
 
@@ -60,7 +60,7 @@ module Loxxy
         end
         raise StandardError, 'Cannot remove root environment.' if current_env == root
 
-        @current_env = current_env.parent
+        @current_env = current_env.enclosing
       end
 
       # Add an entry with given name to current environment.
@@ -114,7 +114,7 @@ module Loxxy
         while skope
           vars_of_environment = skope.defns.select { |_, item| item.kind_of?(Variable) }
           vars = vars_of_environment.values.concat(vars)
-          skope = skope.parent
+          skope = skope.enclosing
         end
 
         vars

data/lib/loxxy/back_end/variable.rb

@@ -9,15 +9,20 @@ module Loxxy
     # It is a named slot that can be associated with a value at the time.
     class Variable
       include Entry # Add expected behaviour for symbol table entries
-      
+
       # @return [Datatype::BuiltinDatatype] the value assigned to the variable
-      attr_accessor :value
+      attr_reader :value
 
       # Create a variable with given name and initial value
       # @param aName [String] The name of the variable
       # @param aValue [Datatype::BuiltinDatatype] the initial assigned value
       def initialize(aName, aValue = Datatype::Nil.instance)
         init_name(aName)
+        assign(aValue)
+      end
+
+      # @param aValue [Datatype::BuiltinDatatype] the assigned value
+      def assign(aValue)
         @value = aValue
       end
     end # class

data/lib/loxxy/datatype/builtin_datatype.rb

@@ -62,6 +62,12 @@ module Loxxy
         value.to_s # Default implementation...
       end
 
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [Ast::ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_builtin(self)
+      end
+
       protected
 
       def validated_value(aValue)

data/lib/loxxy/front_end/grammar.rb

@@ -30,8 +30,8 @@ module Loxxy
       rule('program' => 'declaration_plus EOF').as 'lox_program'
 
       # Declarations: bind an identifier to something
-      rule('declaration_plus' => 'declaration_plus declaration')
-      rule('declaration_plus' => 'declaration')
+      rule('declaration_plus' => 'declaration_plus declaration').as 'declaration_plus_more'
+      rule('declaration_plus' => 'declaration').as 'declaration_plus_end'
       rule('declaration' => 'classDecl')
       rule('declaration' => 'funDecl')
       rule('declaration' => 'varDecl')
@@ -75,15 +75,15 @@ module Loxxy
 
       rule('printStmt' => 'PRINT expression SEMICOLON').as 'print_stmt'
       rule('returnStmt' => 'RETURN expression_opt SEMICOLON')
-      rule('whileStmt' => 'WHILE LEFT_PAREN expression RIGHT_PAREN statement')
-      rule('block' => 'LEFT_BRACE declaration_plus RIGHT_BRACE')
+      rule('whileStmt' => 'WHILE LEFT_PAREN expression RIGHT_PAREN statement').as 'while_stmt'
+      rule('block' => 'LEFT_BRACE declaration_plus RIGHT_BRACE').as 'block_stmt'
       rule('block' => 'LEFT_BRACE RIGHT_BRACE')
 
       # Expressions: produce values
       rule('expression_opt' => 'expression')
       rule('expression_opt' => [])
       rule('expression' => 'assignment')
-      rule('assignment' => 'owner_opt IDENTIFIER EQUAL assignment')
+      rule('assignment' => 'owner_opt IDENTIFIER EQUAL assignment').as 'assign_expr'
       rule('assignment' => 'logic_or')
       rule('owner_opt' => 'call DOT')
       rule('owner_opt' => [])
@@ -137,7 +137,7 @@ module Loxxy
       rule('primary' => 'THIS')
       rule('primary' => 'NUMBER').as 'literal_expr'
       rule('primary' => 'STRING').as 'literal_expr'
-      rule('primary' => 'IDENTIFIER')
+      rule('primary' => 'IDENTIFIER').as 'variable_expr'
       rule('primary' => 'LEFT_PAREN expression RIGHT_PAREN').as 'grouping_expr'
       rule('primary' => 'SUPER DOT IDENTIFIER')
 

data/lib/loxxy/version.rb

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