loxxy 0.0.24 → 0.1.0

data/lib/loxxy/ast/ast_visitor.rb

@@ -12,7 +12,7 @@ module Loxxy
       # attr_reader(:runtime)
 
       # Build a visitor for the given top.
-      # @param aRoot [AST::LoxNode] the parse tree to visit.
+      # @param aTop [AST::LoxNode] the parse tree to visit.
       def initialize(aTop)
         raise StandardError if aTop.nil?
 
@@ -52,7 +52,7 @@ module Loxxy
       end
 
       # Visit event. The visitor is about to visit a variable declaration statement.
-      # @param aPrintStmt [AST::LOXVarStmt] the variable declaration node to visit
+      # @param aSeqDecls [AST::LOXSeqDecl] the variable declaration node to visit
       def visit_seq_decl(aSeqDecls)
         broadcast(:before_seq_decl, aSeqDecls)
         traverse_subnodes(aSeqDecls)
@@ -60,13 +60,21 @@ module Loxxy
       end
 
       # Visit event. The visitor is about to visit a variable declaration statement.
-      # @param aPrintStmt [AST::LOXVarStmt] the variable declaration node to visit
+      # @param aVarStmt [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 for statement.
+      # @param aForStmt [AST::LOXForStmt] the for statement node to visit
+      def visit_for_stmt(aForStmt)
+        broadcast(:before_for_stmt, aForStmt)
+        traverse_subnodes(aForStmt) # The condition is visited/evaluated here...
+        broadcast(:after_for_stmt, aForStmt, self)
+      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)
@@ -83,8 +91,24 @@ 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) unless aBlockStmt.empty?
+        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.
+      # @param anAssignExpr [AST::LoxAssignExpr] the variable assignment node to visit.
       def visit_assign_expr(anAssignExpr)
         broadcast(:before_assign_expr, anAssignExpr)
         traverse_subnodes(anAssignExpr)
@@ -94,7 +118,7 @@ module Loxxy
       # 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
+      # @param aLogicalExpr [AST::LOXLogicalExpr] the logical expression node to visit
       def visit_logical_expr(aLogicalExpr)
         broadcast(:before_logical_expr, aLogicalExpr)
 
@@ -121,6 +145,14 @@ module Loxxy
         broadcast(:after_unary_expr, anUnaryExpr)
       end
 
+      # Visit event. The visitor is about to visit a call expression.
+      # @param aCallExpr [AST::LoxCallExpr] call expression to visit
+      def visit_call_expr(aCallExpr)
+        broadcast(:before_call_expr, aCallExpr)
+        traverse_subnodes(aCallExpr)
+        broadcast(:after_call_expr, aCallExpr, self)
+      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)
@@ -138,25 +170,35 @@ module Loxxy
       end
 
       # Visit event. The visitor is visiting a variable usage node
-      # @param aLiteralExpr [AST::LoxVariableExpr] the variable reference node to visit.
+      # @param aVariableExpr [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
+      # @param aValue [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 a function statement node.
+      # @param aFunStmt [AST::LoxFunStmt] function declaration to visit
+      def visit_fun_stmt(aFunStmt)
+        broadcast(:before_fun_stmt, aFunStmt)
+        traverse_subnodes(aFunStmt)
+        broadcast(:after_fun_stmt, aFunStmt, self)
+      end
+
       # Visit event. The visitor is about to visit the given non terminal node.
       # @param aNonTerminalNode [Rley::PTree::NonTerminalNode] the node to visit.
-      def visit_nonterminal(_non_terminal_node)
+      def visit_nonterminal(aNonTerminalNode)
         # Loxxy interpreter encountered a CST node (Concrete Syntax Tree)
         # that it cannot handle.
-        raise NotImplementedError, 'Loxxy cannot execute this code yet.'
+        symb = aNonTerminalNode.symbol.name
+        msg = "Loxxy cannot execute this code yet for non-terminal symbol '#{symb}'."
+        raise NotImplementedError, msg
       end
 
       private

data/lib/loxxy/ast/lox_block_stmt.rb

@@ -0,0 +1,27 @@
+# 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 decls [Loxxy::Ast::LoxSeqDecl]
+      def initialize(aPosition, decls)
+        super(aPosition, [decls])
+      end
+
+      def empty?
+        subnodes.size == 1 && subnodes[0].nil?
+      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_call_expr.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'lox_compound_expr'
+
+module Loxxy
+  module Ast
+    class LoxCallExpr < LoxCompoundExpr
+      attr_accessor :callee
+      attr_reader :arguments
+
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      # @param argList [Array<Loxxy::Ast::LoxNode>]
+      def initialize(aPosition, argList)
+        super(aPosition, [])
+        @arguments = argList
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [Ast::ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_call_expr(self)
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/ast/lox_for_stmt.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative 'lox_compound_expr'
+
+module Loxxy
+  module Ast
+    class LoxForStmt < LoxCompoundExpr
+      # @return [LoxNode] test expression
+      attr_reader :test_expr
+
+      # @return [LoxNode] update expression
+      attr_reader :update_expr
+
+      # @return [LoxNode] body statement
+      attr_accessor :body_stmt
+
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      # @param initialization [Loxxy::Ast::LoxNode]
+      # @param testExpr [Loxxy::Ast::LoxNode]
+      # @param updateExpr [Loxxy::Ast::LoxNode]
+      def initialize(aPosition, initialization, testExpr, updateExpr)
+        child = initialization ? [initialization] : []
+        super(aPosition, child)
+        @test_expr = testExpr
+        @update_expr = updateExpr
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [Ast::ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_for_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_fun_stmt.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'lox_compound_expr'
+
+module Loxxy
+  module Ast
+    class LoxFunStmt < LoxCompoundExpr
+      attr_reader :name
+      attr_reader :params
+      attr_reader :body
+
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      # @param aName [String]
+      # @param arguments [Array<String>]
+      # @param body [Ast::LoxBlockStmt]
+      def initialize(aPosition, aName, paramList, aBody)
+        super(aPosition, [])
+        @name = aName
+        @params = paramList
+        @body = aBody
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [Ast::ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_fun_stmt(self)
+      end
+
+      alias operands subnodes
+    end # class
+  end # module
+end # module

data/lib/loxxy/ast/lox_if_stmt.rb

@@ -12,7 +12,9 @@ module Loxxy
       attr_reader :else_stmt
 
       # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
-      # @param subExpr [Loxxy::Ast::LoxNode]
+      # @param condExpr [Loxxy::Ast::LoxNode]
+      # @param thenStmt [Loxxy::Ast::LoxNode]
+      # @param elseStmt [Loxxy::Ast::LoxNode]
       def initialize(aPosition, condExpr, thenStmt, elseStmt)
         super(aPosition, [condExpr])
         @then_stmt = thenStmt

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

@@ -2,6 +2,7 @@
 
 # Load all the classes implementing AST nodes
 require_relative '../ast/all_lox_nodes'
+require_relative 'function'
 require_relative 'symbol_table'
 
 module Loxxy
@@ -25,6 +26,8 @@ module Loxxy
         @ostream = config.include?(:ostream) ? config[:ostream] : $stdout
         @symbol_table = SymbolTable.new
         @stack = []
+
+        init_globals
       end
 
       # Given an abstract syntax parse tree visitor, launch the visit
@@ -51,6 +54,23 @@ module Loxxy
         symbol_table.insert(new_var)
       end
 
+      def before_for_stmt(aForStmt)
+        before_block_stmt(aForStmt)
+      end
+
+      def after_for_stmt(aForStmt, aVisitor)
+        loop do
+          aForStmt.test_expr.accept(aVisitor)
+          condition = stack.pop
+          break unless condition.truthy?
+
+          aForStmt.body_stmt.accept(aVisitor)
+          aForStmt.update_expr&.accept(aVisitor)
+          stack.pop
+        end
+        after_block_stmt(aForStmt)
+      end
+
       def after_if_stmt(anIfStmt, aVisitor)
         # Retrieve the result of the condition evaluation
         condition = stack.pop
@@ -66,10 +86,30 @@ 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
@@ -130,6 +170,27 @@ module Loxxy
         end
       end
 
+      def after_call_expr(aCallExpr, aVisitor)
+        # Evaluate callee part
+        aCallExpr.callee.accept(aVisitor)
+        callee = stack.pop
+        aCallExpr.arguments.reverse_each { |arg| arg.accept(aVisitor) }
+
+        if callee.kind_of?(NativeFunction)
+          stack.push callee.call # Pass arguments
+        else
+          new_env = Environment.new(symbol_table.current_env)
+          symbol_table.enter_environment(new_env)
+          callee.parameters&.each do |param_name|
+            local = Variable.new(param_name, stack.pop)
+            symbol_table.insert(local)
+          end
+          stack.push callee.call(aVisitor)
+
+          symbol_table.leave_environment
+        end
+      end
+
       def after_grouping_expr(_groupingExpr)
         # Do nothing: work was already done by visiting /evaluating the subexpression
       end
@@ -147,10 +208,50 @@ module Loxxy
         stack.push(literalExpr.literal)
       end
 
-      # @param aNonTerminalNode [Ast::BuiltinDattype] the built-in datatype value
+      # @param aValue [Ast::BuiltinDattype] the built-in datatype value
       def before_visit_builtin(aValue)
         stack.push(aValue)
       end
+
+      def after_fun_stmt(aFunStmt, aVisitor)
+        function = Function.new(aFunStmt.name, aFunStmt.params, aFunStmt.body, stack)
+        new_var = Variable.new(aFunStmt.name, function)
+        symbol_table.insert(new_var)
+      end
+
+      private
+
+      NativeFunction = Struct.new(:callable, :interp) do
+        def accept(_visitor)
+          interp.stack.push self
+        end
+
+        def call
+          callable.call
+        end
+
+        def to_str
+          '<native fn>'
+        end
+      end
+
+      def init_globals
+        add_native_fun('clock', native_clock)
+      end
+
+      def add_native_fun(aName, aProc)
+        native_fun = Variable.new(aName, NativeFunction.new(aProc, self))
+        symbol_table.insert(native_fun)
+      end
+
+      # Ruby-native function that returns (as float) the number of seconds since
+      # a given time reference.
+      def native_clock
+        proc do
+          now = Time.now.to_f
+          Datatype::Number.new(now)
+        end
+      end
     end # class
   end # module
 end # module