loxxy 0.0.26 → 0.1.02

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1258e225c3c22ba2c8a1df645f2ee39fc6fc2330a62b288a15f59e1ca40596b2
-  data.tar.gz: 102ac797634d4abf2e72902f568c5b0cc5ec161433e5e4c4e0888e7142508d65
+  metadata.gz: ddfc01e822c7e68c87d515649f6ef6e2c800c926ca289dfe9f65edeff24e7015
+  data.tar.gz: db5a6a8052c0c15f00920c6d76fcd8c6f9cfe380905c20b53f8e74cc7c6d4f84
 SHA512:
-  metadata.gz: a1715b6c93b1861fadafac38327ea2fdee592f2b0b46320b04acd7e64db166911dc614d59412dae9d0bbccea9ca95f9299aac276eba9ee2a87a58963a2ec7d13
-  data.tar.gz: 62915b07a3066c8068f41fd622d9d9be4d8baf29b6c3ef0849b3e410be5d52343fa8c00b8bbff1665deefc838cd29a423852f9666af3e410aee77b538f4030f0
+  metadata.gz: f5a85f8a0a4a762f43a9dd51ab972f924a95ed15ed9e864cef0c60f4815902cbfb905fef624cc100bae9283985f8f6c7f960fbd72bd8d87e9ee3ab211eb7dc24
+  data.tar.gz: 10522ab655b99e31007dccaa479b4ec59a9340160f6768c084c3b96825f4e89f9f1c46c1655117763d66f28004f5d8e2c193315c80a65dd49b733587bd25823a

data/CHANGELOG.md

@@ -1,8 +1,72 @@
+## [0.1.02] - 2021-02-21
+- Function definition and call documented in `README.md`
+
+### Changed
+- File `README.md` updated todescribe function definition and function call.
+
+### Fixed
+- Method `BackEnd::Engine#after_print_stmt` now handles of empty stack or nil data.
+- Method `BackEnd::Engine#after_call_expr` was pushing one spurious item onto data stack.
+
+## [0.1.01] - 2021-02-20
+### Fixed
+- Fixed most offences for Rubocop.
+
+
+## [0.1.00] - 2021-02-20
+- Version number bumped, `Loxxy` supports function definitions
+
+### Added
+- Class `Ast::LoxFunStmt` a node that represents a function declaration
+- Method `Ast::ASTBuilder#reduce_fun_decl`
+- Method `Ast::ASTBuilder#reduce_function` creates a `LoxFunStmt` instance
+- Method `Ast::ASTBuilder#reduce_parameters_plus_more` for dealing with function parameters
+- Method `Ast::ASTBuilder#reduce_parameters_plus_end`
+- Method `Ast::ASTVisitor#visit_fun_stmt` for visiting an `Ast::LoxFunStmt` node
+- Method `Ast::LoxBlockStmt#empty?` returns true if the code block is empty
+- Method `BackEnd::Engine#after_fun_stmt`
+- Method `Backend::NativeFunction#call` 
+- Method `Backend::NativeFunction#to_str` 
+- Method `Backend::Function` implementation of a function object.
+
+### Changed
+- Method `BackEnd::Engine#after_call_expr`
+
+### Fixed
+- Fixed inconsistencies in documentation comments.
+
+## [0.0.28] - 2021-02-15
+- The interpreter implements function calls (to a native function).
+
+### Added
+- Class `Ast::LoxCallExpr` a node that represents a function call expression
+- Method `Ast::ASTBuilder#reduce_call_expr`
+- Method `Ast::ASTBuilder#reduce_refinement_plus_end`
+- Method `Ast::ASTBuilder#reduce_call_arglist` creates a `LoxCallExpr` node
+- Method `Ast::ASTBuilder#reduce_arguments_plus_more` builds the function argument array
+- Method `Ast::ASTVisitor#visit_call_expr` for visiting an `Ast::LoxCallExpr` node
+- Method `BackEnd::Engine#after_call_expr`implements the evaluation of a function call.
+- Method `BackEnd::Engine#after_for_stmt` implements most of the `for` control flow
+
+## [0.0.27] - 2021-01-24
+- The interpreter implements `while` loops.
+
+### Added
+- Class `Ast::LoxForStmt` a node that represents a `for` statement
+- Method `Ast::ASTBuilder#reduce_for_stmt`
+- Method `Ast::ASTBuilder#reduce_for_control` creates an `Ast::LoxForStmt` node
+- Method `Ast::ASTVisitor#visit_for_stmt` for visiting an `Ast::LoxWhileStmt` node
+- Method `BackEnd::Engine#before_for_stmt` builds a new environment for the loop variable
+- Method `BackEnd::Engine#after_for_stmt` implements most of the `for` control flow
+
+### Changed
+- File `README.md` updated.
+
 ## [0.0.26] - 2021-01-22
 - The interpreter implements `while` loops.
 
 ### Added
-- Class `Ast::LoxWhileStmt` a node that represents a while statement
+- Class `Ast::LoxWhileStmt` a node that represents a `while` statement
 - Method `Ast::ASTBuilder#reduce_while_stmt` creates an `Ast::LoxWhileStmt` node
 - Method `Ast::ASTVisitor#visit_while_stmt` for visiting an `Ast::LoxWhileStmt` node
 - Method `BackEnd::Engine#after_while_stmt` implements the while looping structure

data/README.md

@@ -14,9 +14,12 @@ a simple language used in Bob Nystrom's online book [Crafting Interpreters](http
 
 ### Current status
 The project is still in inception and the interpreter is being implemented...  
-Currently it can execute a tiny subset of __Lox__ language.
+Currently it can execute all allowed __Lox__ expressions and statements except:
+- Closures,  
+- Classes and objects.
+
+These will be implemented soon.
 
-But the __loxxy__ gem hosts also a parser class `RawPaser` that can parse, in principle, any valid Lox input.
 
 ## What's the fuss about Lox?
 ... Nothing...  
@@ -32,11 +35,11 @@ Although __Lox__ is fairly simple, it is far from a toy language:
 - Functions and closures
 - Object-orientation (classes, methods, inheritance).
 
-In other words, __Lox__ contains interesting features expected from most general-purpose 
+In other words, __Lox__ contains interesting features found in most general-purpose 
 languages.
 
 ### What's missing in Lox?
-__Lox__ was constrained by design and therefore was not aimed to be a language used in real-world applications.
+__Lox__ was constrained by design and was therefore not aimed to be a language used in real-world applications.
 Here are some missing parts to make it a _practical_ language:
 - Collections (arrays, maps, ...)
 - Modules (importing stuff from other packages/files)
@@ -66,6 +69,23 @@ lox = Loxxy::Interpreter.new
 lox.evaluate(lox_program) # Output: Hello, world!
 ```
 
+## A function definition example
+```ruby
+require 'loxxy'
+
+lox_program = <<LOX_END
+  fun add4(n) {
+    n + 4;
+  }
+
+  print add4(6); // Output: 10
+LOX_END
+
+lox = Loxxy::Interpreter.new
+lox.evaluate(lox_program) # Output 10
+```
+
+
 ## Retrieving the result from a Lox program
 The __Loxxy__ interpreter returns the value of the last evaluated expression. 
 
@@ -141,11 +161,13 @@ Here are the language features currently supported by the interpreter:
 - [Datatypes](#datatypes)
 - [Statements](#statements)  
   -[Expressions](#expressions)  
-- [Variable declarations](#var-statement)  
+- [Variable declarations](#var-statement) 
+- [For statement](#for-statement)  
 - [If Statement](#if-statement)   
 - [Print Statement](#print-statement)
 - [While Statement](#while-statement)  
 - [Block Statement](#block-statement)
+- [Function declaration](#func-statement)
 
 ### Comments
 
@@ -172,19 +194,21 @@ loxxy supports  all the standard __Lox__ datatypes:
 ### Statements
 
 Loxxy supports the following statements:  
-- [Expressions](#expressions)  
+- [Expressions](#expressions)
   -[Arithmetic expressions](#arithmetic-expressions)  
   -[String concatenation](#string-concatenation)  
   -[Comparison expressions](#comparison-expressions)  
   -[Logical expressions](#logical-expressions)  
   -[Grouping expressions](#grouping-expressions)  
-  -[Variable expressions and assignments](#variable-expressions)
-  
+  -[Variable expressions and assignments](#variable-expressions)  
+  -[Function call](#function-call)
+
 -[Variable declarations](#var-statement)  
 -[If Statement](#if-statement)  
 -[Print Statement](#print-statement)  
--[While Statement](#while-statement)
--[Block Statement](#block-statement)
+-[While Statement](#while-statement)  
+-[Block Statement](#block-statement)  
+-[Function Declaration](#function-declaration)
 
 #### Expressions
 
@@ -279,6 +303,24 @@ var iAmNil; // __Lox__ initializes variables to nil by default;
 print iAmNil; // output: nil
 ```
 
+#### Function call
+``` javascript
+// Calling a function without argument
+print clock();
+
+// Assumption: there exists a function `add` that takes two arguments
+print add(2, 3);
+```
+
+#### For statement
+
+Similar to the `for` statement in `C` language
+``` javascript
+for (var a = 1; a < 10; a = a + 1) {
+  print a; // Output: 123456789
+}
+```
+
 #### If statement
 
 Based on a given condition, an if statement executes one of two statements:
@@ -348,6 +390,19 @@ var a = "outer";
 print a; // output: outer
 ```
 
+#### Function Declaration
+The keyword `fun` is used to begin a function declaration.
+In __Lox__ a function has a name and a body (which may be empty).
+
+``` javascript
+fun add4(n) // `add4` will be the name of the function
+{
+  n + 4;
+}
+
+print add4(6); // output: 10
+```
+
 ## Installation
 
 Add this line to your application's Gemfile:

data/lib/loxxy/ast/all_lox_nodes.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
+require_relative 'lox_fun_stmt'
 require_relative 'lox_variable_expr'
 require_relative 'lox_literal_expr'
 require_relative 'lox_noop_expr'
+require_relative 'lox_call_expr'
 require_relative 'lox_grouping_expr'
 require_relative 'lox_unary_expr'
 require_relative 'lox_binary_expr'
@@ -12,5 +14,6 @@ require_relative 'lox_block_stmt'
 require_relative 'lox_while_stmt'
 require_relative 'lox_print_stmt'
 require_relative 'lox_if_stmt'
+require_relative 'lox_for_stmt'
 require_relative 'lox_var_stmt'
 require_relative 'lox_seq_decl'

data/lib/loxxy/ast/ast_builder.rb

@@ -163,6 +163,11 @@ module Loxxy
         [theChildren[0]]
       end
 
+      # rule('funDecl' => 'FUN function')
+      def reduce_fun_decl(_production, _range, _tokens, theChildren)
+        theChildren[1]
+      end
+
       # rule('exprStmt' => 'expression SEMICOLON')
       def reduce_exprStmt(_production, range, tokens, theChildren)
       return_first_child(range, tokens, theChildren) # Discard the semicolon
@@ -180,6 +185,29 @@ module Loxxy
         Ast::LoxVarStmt.new(tokens[1].position, var_name, theChildren[3])
       end
 
+      # rule('forStmt' => 'FOR LEFT_PAREN forControl RIGHT_PAREN statement')
+      def reduce_for_stmt(_production, _range, _tokens, theChildren)
+        for_stmt = theChildren[2]
+        for_stmt.body_stmt = theChildren[4]
+        for_stmt
+      end
+
+      # rule('forControl' => 'forInitialization forTest forUpdate')
+      def reduce_for_control(_production, _range, tokens, theChildren)
+        (init, test, update) = theChildren
+        Ast::LoxForStmt.new(tokens[0].position, init, test, update)
+      end
+
+      # rule('forInitialization' => 'SEMICOLON')
+      def reduce_empty_for_initialization(_production, _range, _tokens, _theChildren)
+        nil
+      end
+
+      # rule('forTest' => 'expression_opt SEMICOLON')
+      def reduce_for_test(_production, range, tokens, theChildren)
+        return_first_child(range, tokens, theChildren)
+      end
+
       # rule('ifStmt' => 'IF ifCondition statement elsePart_opt')
       def reduce_if_stmt(_production, _range, tokens, theChildren)
         condition = theChildren[1]
@@ -204,105 +232,46 @@ module Loxxy
         Ast::LoxBlockStmt.new(tokens[1].position, decls)
       end
 
+      # rule('block' => 'LEFT_BRACE RIGHT_BRACE').as 'block_empty'
+      def reduce_block_empty(_production, _range, tokens, _children)
+        Ast::LoxBlockStmt.new(tokens[0].position, nil)
+      end
+
       # rule('assignment' => 'owner_opt IDENTIFIER EQUAL assignment')
       def reduce_assign_expr(_production, _range, tokens, theChildren)
         var_name = theChildren[1].token.lexeme.dup
         Ast::LoxAssignExpr.new(tokens[1].position, var_name, theChildren[3])
       end
 
-      # rule('logic_or' => 'logic_and disjunct_plus')
-      def reduce_logic_or_plus(production, range, tokens, theChildren)
-        reduce_logical_expr(production, range, tokens, theChildren)
-      end
-
-      # rule('disjunct_plus' => 'disjunct_plus OR logic_and')
-      def reduce_logic_or_plus_more(production, range, tokens, theChildren)
-        reduce_binary_plus_more(production, range, tokens, theChildren)
-      end
-
-      # rule('disjunct_plus' => 'OR logic_and')
-      def reduce_logic_or_plus_end(production, range, tokens, theChildren)
-        reduce_binary_plus_end(production, range, tokens, theChildren)
-      end
-
-      # rule('logic_and' => 'equality conjunct_plus')
-      def reduce_logic_and_plus(production, range, tokens, theChildren)
-        reduce_logical_expr(production, range, tokens, theChildren)
-      end
-
-      # rule('conjunct_plus' => 'conjunct_plus AND equality')
-      def reduce_logic_and_plus_more(production, range, tokens, theChildren)
-        reduce_binary_plus_more(production, range, tokens, theChildren)
-      end
-
-      # rule('conjunct_plus' => 'AND equality')
-      def reduce_logic_and_plus_end(production, range, tokens, theChildren)
-        reduce_binary_plus_end(production, range, tokens, theChildren)
-      end
-
-      # rule('equality' => 'comparison equalityTest_plus')
-      def reduce_equality_plus(production, range, tokens, theChildren)
-        reduce_binary_operator(production, range, tokens, theChildren)
-      end
-
-      # rule('equalityTest_plus' => 'equalityTest_plus equalityTest comparison')
-      def reduce_equality_t_plus_more(production, range, tokens, theChildren)
-        reduce_binary_plus_more(production, range, tokens, theChildren)
-      end
-
-      # rule('equalityTest_star' => 'equalityTest comparison')
-      def reduce_equality_t_plus_end(production, range, tokens, theChildren)
-        reduce_binary_plus_end(production, range, tokens, theChildren)
-      end
-
-      # rule('comparison' => 'term comparisonTest_plus')
-      def reduce_comparison_plus(production, range, tokens, theChildren)
-        reduce_binary_operator(production, range, tokens, theChildren)
-      end
-
       # rule('comparisonTest_plus' => 'comparisonTest_plus comparisonTest term').as 'comparison_t_plus_more'
       # TODO: is it meaningful to implement this rule?
 
-      # rule('comparisonTest_plus' => 'comparisonTest term')
-      def reduce_comparison_t_plus_end(production, range, tokens, theChildren)
-        reduce_binary_plus_end(production, range, tokens, theChildren)
-      end
-
-      # rule('term' => 'factor additive_plus')
-      def reduce_term_additive(production, range, tokens, theChildren)
-        reduce_binary_operator(production, range, tokens, theChildren)
-      end
-
-      # rule('additive_star' => 'additive_star additionOp factor').as 'additionOp_expr'
-      def reduce_additive_plus_more(production, range, tokens, theChildren)
-        reduce_binary_plus_more(production, range, tokens, theChildren)
-      end
-
-      # rule('additive_plus' => 'additionOp factor')
-      def reduce_additive_plus_end(production, range, tokens, theChildren)
-        reduce_binary_plus_end(production, range, tokens, theChildren)
+      # rule('unary' => 'unaryOp unary')
+      def reduce_unary_expr(_production, _range, tokens, theChildren)
+        operator = Name2unary[theChildren[0].symbol.name].to_sym
+        operand = theChildren[1]
+        LoxUnaryExpr.new(tokens[0].position, operator, operand)
       end
 
-      # rule('factor' => 'multiplicative_plus')
-      def reduce_factor_multiplicative(production, range, tokens, theChildren)
-        reduce_binary_operator(production, range, tokens, theChildren)
+      # rule('call' => 'primary refinement_plus').as 'call_expr'
+      def reduce_call_expr(_production, _range, _tokens, theChildren)
+        theChildren[1].callee = theChildren[0]
+        theChildren[1]
       end
 
-      # rule('multiplicative_plus' => 'multiplicative_plus multOp unary')
-      def reduce_multiplicative_plus_more(production, range, tokens, theChildren)
-        reduce_binary_plus_more(production, range, tokens, theChildren)
+      # rule('refinement_plus' => 'refinement').
+      def reduce_refinement_plus_end(_production, _range, _tokens, theChildren)
+        theChildren[0]
       end
 
-      # rule('multiplicative_plus' => 'multOp unary')
-      def reduce_multiplicative_plus_end(production, range, tokens, theChildren)
-        reduce_binary_plus_end(production, range, tokens, theChildren)
-      end
+      # rule('refinement' => 'LEFT_PAREN arguments_opt RIGHT_PAREN')
+      def reduce_call_arglist(_production, _range, tokens, theChildren)
+        args = theChildren[1] || []
+        if args.size > 255
+          raise StandardError, "Can't have more than 255 arguments."
+        end
 
-      # rule('unary' => 'unaryOp unary')
-      def reduce_unary_expr(_production, _range, tokens, theChildren)
-        operator = Name2unary[theChildren[0].symbol.name].to_sym
-        operand = theChildren[1]
-        LoxUnaryExpr.new(tokens[0].position, operator, operand)
+        LoxCallExpr.new(tokens[0].position, args)
       end
 
       # rule('primary' => 'LEFT_PAREN expression RIGHT_PAREN')
@@ -324,6 +293,33 @@ module Loxxy
         var_name = theChildren[0].token.lexeme
         LoxVariableExpr.new(tokens[0].position, var_name)
       end
+
+      # rule('function' => 'IDENTIFIER LEFT_PAREN params_opt RIGHT_PAREN block').as 'function'
+      def reduce_function(_production, _range, _tokens, theChildren)
+        first_child = theChildren.first
+        pos = first_child.token.position
+        LoxFunStmt.new(pos, first_child.token.lexeme, theChildren[2], theChildren[4])
+      end
+
+      # rule('parameters' => 'parameters COMMA IDENTIFIER')
+      def reduce_parameters_plus_more(_production, _range, _tokens, theChildren)
+        theChildren[0] << theChildren[2].token.lexeme
+      end
+
+      # rule('parameters' => 'IDENTIFIER')
+      def reduce_parameters_plus_end(_production, _range, _tokens, theChildren)
+        [theChildren[0].token.lexeme]
+      end
+
+      # rule('arguments' => 'arguments COMMA expression')
+      def reduce_arguments_plus_more(_production, _range, _tokens, theChildren)
+        theChildren[0] << theChildren[2]
+      end
+
+      # rule('arguments' => 'expression')
+      def reduce_arguments_plus_end(_production, _range, _tokens, theChildren)
+        theChildren
+      end
     end # class
   end # module
 end # module

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)
@@ -95,12 +103,12 @@ module Loxxy
       # @param aBlockStmt [AST::LOXBlockStmt] the print statement node to visit
       def visit_block_stmt(aBlockStmt)
         broadcast(:before_block_stmt, aBlockStmt)
-        traverse_subnodes(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)
@@ -110,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)
 
@@ -137,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)
@@ -154,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

@@ -6,11 +6,15 @@ 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]
+      # @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)

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,34 @@
+# frozen_string_literal: true
+
+require_relative 'lox_compound_expr'
+
+module Loxxy
+  module Ast
+    # rubocop: disable Style/AccessorGrouping
+    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
+    # rubocop: enable Style/AccessorGrouping
+  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/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
@@ -63,7 +83,7 @@ module Loxxy
 
       def after_print_stmt(_printStmt)
         tos = stack.pop
-        @ostream.print tos.to_str
+        @ostream.print tos ? tos.to_str : 'nil'
       end
 
       def after_while_stmt(aWhileStmt, aVisitor)
@@ -150,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
+          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
@@ -167,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, _visitor)
+        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

data/lib/loxxy/back_end/function.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative '../datatype/all_datatypes'
+
+module Loxxy
+  module BackEnd
+    # rubocop: disable Style/AccessorGrouping
+    # Representation of a Lox function.
+    # It is a named slot that can be associated with a value at the time.
+    class Function
+      # @return [String]
+      attr_reader :name
+
+      # @return [Array<>] the parameters
+      attr_reader :parameters
+      attr_reader :body
+      attr_reader :stack
+
+      # 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, parameterList, aBody, aStack)
+        @name = aName.dup
+        @parameters = parameterList
+        @body = aBody
+        @stack = aStack
+      end
+
+      def accept(_visitor)
+        stack.push self
+      end
+
+      def call(aVisitor)
+        body.empty? ? Datatype::Nil.instance : body.accept(aVisitor)
+      end
+
+      # Text representation of a Lox function
+      def to_str
+        "<fn #{name}>"
+      end
+    end # class
+    # rubocop: enable Style/AccessorGrouping
+  end # module
+end # module

data/lib/loxxy/front_end/grammar.rb

@@ -44,7 +44,7 @@ module Loxxy
       rule('function_star' => 'function_star function')
       rule('function_star' => [])
 
-      rule('funDecl' => 'FUN function')
+      rule('funDecl' => 'FUN function').as 'fun_decl'
 
       rule('varDecl' => 'VAR IDENTIFIER SEMICOLON').as 'var_declaration'
       rule('varDecl' => 'VAR IDENTIFIER EQUAL expression SEMICOLON').as 'var_initialization'
@@ -60,12 +60,12 @@ module Loxxy
 
       rule('exprStmt' => 'expression SEMICOLON').as 'exprStmt'
 
-      rule('forStmt' => 'FOR LEFT_PAREN forControl RIGHT_PAREN statement')
-      rule('forControl' => 'forInitialization forTest forUpdate')
+      rule('forStmt' => 'FOR LEFT_PAREN forControl RIGHT_PAREN statement').as 'for_stmt'
+      rule('forControl' => 'forInitialization forTest forUpdate').as 'for_control'
       rule('forInitialization' => 'varDecl')
       rule('forInitialization' => 'exprStmt')
-      rule('forInitialization' => 'SEMICOLON')
-      rule('forTest' => 'expression_opt SEMICOLON')
+      rule('forInitialization' => 'SEMICOLON').as 'empty_for_initialization'
+      rule('forTest' => 'expression_opt SEMICOLON').as 'for_test'
       rule('forUpdate' => 'expression_opt')
 
       rule('ifStmt' => 'IF ifCondition statement elsePart_opt').as 'if_stmt'
@@ -77,7 +77,7 @@ module Loxxy
       rule('returnStmt' => 'RETURN expression_opt SEMICOLON')
       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')
+      rule('block' => 'LEFT_BRACE RIGHT_BRACE').as 'block_empty'
 
       # Expressions: produce values
       rule('expression_opt' => 'expression')
@@ -88,37 +88,37 @@ module Loxxy
       rule('owner_opt' => 'call DOT')
       rule('owner_opt' => [])
       rule('logic_or' => 'logic_and')
-      rule('logic_or' => 'logic_and disjunct_plus').as 'logic_or_plus'
-      rule('disjunct_plus' => 'disjunct_plus OR logic_and').as 'logic_or_plus_more'
-      rule('disjunct_plus' => 'OR logic_and').as 'logic_or_plus_end'
+      rule('logic_or' => 'logic_and disjunct_plus').as 'logical_expr'
+      rule('disjunct_plus' => 'disjunct_plus OR logic_and').as 'binary_plus_more'
+      rule('disjunct_plus' => 'OR logic_and').as 'binary_plus_end'
       rule('logic_and' => 'equality')
-      rule('logic_and' => 'equality conjunct_plus').as 'logic_and_plus'
-      rule('conjunct_plus' => 'conjunct_plus AND equality').as 'logic_and_plus_more'
-      rule('conjunct_plus' => 'AND equality').as 'logic_and_plus_end'
+      rule('logic_and' => 'equality conjunct_plus').as 'logical_expr'
+      rule('conjunct_plus' => 'conjunct_plus AND equality').as 'binary_plus_more'
+      rule('conjunct_plus' => 'AND equality').as 'binary_plus_end'
       rule('equality' => 'comparison')
-      rule('equality' => 'comparison equalityTest_plus').as 'equality_plus'
-      rule('equalityTest_plus' => 'equalityTest_plus equalityTest comparison').as 'equality_t_plus_more'
-      rule('equalityTest_plus' => 'equalityTest comparison').as 'equality_t_plus_end'
+      rule('equality' => 'comparison equalityTest_plus').as 'binary_operator'
+      rule('equalityTest_plus' => 'equalityTest_plus equalityTest comparison').as 'binary_plus_more'
+      rule('equalityTest_plus' => 'equalityTest comparison').as 'binary_plus_end'
       rule('equalityTest' => 'BANG_EQUAL')
       rule('equalityTest' => 'EQUAL_EQUAL')
       rule('comparison' => 'term')
-      rule('comparison' => 'term comparisonTest_plus').as 'comparison_plus'
+      rule('comparison' => 'term comparisonTest_plus').as 'binary_operator'
       rule('comparisonTest_plus' => 'comparisonTest_plus comparisonTest term').as 'comparison_t_plus_more'
-      rule('comparisonTest_plus' => 'comparisonTest term').as 'comparison_t_plus_end'
+      rule('comparisonTest_plus' => 'comparisonTest term').as 'binary_plus_end'
       rule('comparisonTest' => 'GREATER')
       rule('comparisonTest' => 'GREATER_EQUAL')
       rule('comparisonTest' => 'LESS')
       rule('comparisonTest' => 'LESS_EQUAL')
       rule('term' => 'factor')
-      rule('term' => 'factor additive_plus').as 'term_additive'
-      rule('additive_plus' => 'additive_plus additionOp factor').as 'additive_plus_more'
-      rule('additive_plus' => 'additionOp factor').as 'additive_plus_end'
+      rule('term' => 'factor additive_plus').as 'binary_operator'
+      rule('additive_plus' => 'additive_plus additionOp factor').as 'binary_plus_more'
+      rule('additive_plus' => 'additionOp factor').as 'binary_plus_end'
       rule('additionOp' => 'MINUS')
       rule('additionOp' => 'PLUS')
       rule('factor' => 'unary')
-      rule('factor' => 'unary multiplicative_plus').as 'factor_multiplicative'
-      rule('multiplicative_plus' => 'multiplicative_plus multOp unary').as 'multiplicative_plus_more'
-      rule('multiplicative_plus' => 'multOp unary').as 'multiplicative_plus_end'
+      rule('factor' => 'unary multiplicative_plus').as 'binary_operator'
+      rule('multiplicative_plus' => 'multiplicative_plus multOp unary').as 'binary_plus_more'
+      rule('multiplicative_plus' => 'multOp unary').as 'binary_plus_end'
       rule('multOp' => 'SLASH')
       rule('multOp' => 'STAR')
       rule('unary' => 'unaryOp unary').as 'unary_expr'
@@ -126,10 +126,10 @@ module Loxxy
       rule('unaryOp' => 'BANG')
       rule('unaryOp' => 'MINUS')
       rule('call' => 'primary')
-      rule('call' => 'primary refinement_plus')
-      rule('refinement_plus' => 'refinement_plus refinement')
-      rule('refinement_plus' => 'refinement')
-      rule('refinement' => 'LEFT_PAREN arguments_opt RIGHT_PAREN')
+      rule('call' => 'primary refinement_plus').as 'call_expr'
+      rule('refinement_plus' => 'refinement_plus refinement') # .as 'refinement_plus_more'
+      rule('refinement_plus' => 'refinement').as 'refinement_plus_end'
+      rule('refinement' => 'LEFT_PAREN arguments_opt RIGHT_PAREN').as 'call_arglist'
       rule('refinement' => 'DOT IDENTIFIER')
       rule('primary' => 'TRUE').as 'literal_expr'
       rule('primary' => 'FALSE').as 'literal_expr'
@@ -142,15 +142,15 @@ module Loxxy
       rule('primary' => 'SUPER DOT IDENTIFIER')
 
       # Utility rules
-      rule('function' => 'IDENTIFIER LEFT_PAREN params_opt RIGHT_PAREN block')
+      rule('function' => 'IDENTIFIER LEFT_PAREN params_opt RIGHT_PAREN block').as 'function'
       rule('params_opt' => 'parameters')
       rule('params_opt' => [])
-      rule('parameters' => 'parameters COMMA IDENTIFIER')
-      rule('parameters' => 'IDENTIFIER')
+      rule('parameters' => 'parameters COMMA IDENTIFIER').as 'parameters_plus_more'
+      rule('parameters' => 'IDENTIFIER').as 'parameters_plus_end'
       rule('arguments_opt' => 'arguments')
       rule('arguments_opt' => [])
-      rule('arguments' => 'arguments COMMA expression')
-      rule('arguments' => 'expression')
+      rule('arguments' => 'arguments COMMA expression').as 'arguments_plus_more'
+      rule('arguments' => 'expression').as 'arguments_plus_end'
     end
 
     unless defined?(Grammar)

data/lib/loxxy/front_end/literal.rb

@@ -11,7 +11,7 @@ module Loxxy
 
       # Constructor.
       # @param aValue [Datatype::BuiltinDatatype] the Lox data value
-      # @param theLexeme [String] the lexeme (= piece of text from input)
+      # @param aLexeme [String] the lexeme (= piece of text from input)
       # @param aTerminal [Rley::Syntax::Terminal, String]
       #   The terminal symbol corresponding to the lexeme.
       # @param aPosition [Rley::Lexical::Position] The position of lexeme

data/lib/loxxy/version.rb

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

data/spec/datatype/lx_string_spec.rb

@@ -26,6 +26,7 @@ module Loxxy
           expect(subject.to_str).to eq(sample_text)
         end
 
+        # rubocop: disable Lint/BinaryOperatorWithIdenticalOperands
         it 'compares with another Lox string' do
           result = subject == LXString.new(sample_text.dup)
           expect(result).to be_true
@@ -40,6 +41,7 @@ module Loxxy
           result = LXString.new('') == LXString.new('')
           expect(result).to be_true
         end
+        # rubocop: enable Lint/BinaryOperatorWithIdenticalOperands
 
         it 'compares with a Ruby string' do
           result = subject == sample_text.dup

data/spec/datatype/number_spec.rb

@@ -21,6 +21,7 @@ module Loxxy
         end
       end
 
+      # rubocop: disable Lint/FloatComparison
       context 'Provided services:' do
         it 'should compare with other Lox numbers' do
           result = subject == Number.new(sample_value)
@@ -51,7 +52,8 @@ module Loxxy
           subtraction = subject - Number.new(10)
           expect(subtraction == -22.34).to be_true
         end
-      end
+      end # context
+      # rubocop: enable Lint/FloatComparison
     end # describe
   end # module
 end # module

data/spec/front_end/scanner_spec.rb

@@ -208,6 +208,7 @@ LOX_END
           expect(eof_token.terminal).to eq('EOF')
         end
 
+        # rubocop: disable Lint/PercentStringArray
         it 'should skip end of line comments' do
           input = <<-LOX_END
             // first comment
@@ -223,6 +224,7 @@ LOX_END
           ]
           match_expectations(subject, expectations)
         end
+        # rubocop: enable Lint/PercentStringArray
 
         it 'should cope with single slash (divide) expression' do
           subject.start_with('8 / 2')

data/spec/interpreter_spec.rb

@@ -9,6 +9,7 @@ require_relative '../lib/loxxy/interpreter'
 module Loxxy
   # This spec contains the bare bones test for the Interpreter class.
   # The execution of Lox code is tested elsewhere.
+  # rubocop: disable Metrics/BlockLength
   describe Interpreter do
     let(:sample_cfg) do
       { ostream: StringIO.new }
@@ -358,10 +359,76 @@ LOX_END
         expect(sample_cfg[:ostream].string).to eq('012')
       end
 
+      it 'should implement single statement for loops' do
+        program = <<-LOX_END
+          // Single-expression body.
+          for (var c = 0; c < 3;) print c = c + 1;
+          // output: 1
+          // output: 2
+          // output: 3
+        LOX_END
+        expect { subject.evaluate(program) }.not_to raise_error
+        expect(sample_cfg[:ostream].string).to eq('123')
+      end
+
+      it 'should implement for loops with block body' do
+        program = <<-LOX_END
+          // Block body.
+          for (var a = 0; a < 3; a = a + 1) {
+            print a;
+          }
+          // output: 0
+          // output: 1
+          // output: 2
+        LOX_END
+        expect { subject.evaluate(program) }.not_to raise_error
+        expect(sample_cfg[:ostream].string).to eq('012')
+      end
+
+      it 'should implement nullary function calls' do
+        program = <<-LOX_END
+          print clock(); // Lox expects the 'clock' predefined native function
+        LOX_END
+        expect { subject.evaluate(program) }.not_to raise_error
+        tick = sample_cfg[:ostream].string
+        expect(Time.now.to_f - tick.to_f).to be < 0.1
+      end
+
+      it 'should implement function definition' do
+        program = <<-LOX_END
+          fun printSum(a, b) {
+             print a + b;
+          }
+          printSum(1, 2);
+        LOX_END
+        expect { subject.evaluate(program) }.not_to raise_error
+        expect(sample_cfg[:ostream].string).to eq('3')
+      end
+
+      it 'should support functions with empty body' do
+        program = <<-LOX_END
+          fun f() {}
+          print f();
+        LOX_END
+        expect { subject.evaluate(program) }.not_to raise_error
+        expect(sample_cfg[:ostream].string).to eq('nil')
+      end
+
+      it 'should provide print representation of functions' do
+        program = <<-LOX_END
+          fun foo() {}
+          print foo; // output: <fn foo>
+          print clock; // output: <native fn>
+        LOX_END
+        expect { subject.evaluate(program) }.not_to raise_error
+        expect(sample_cfg[:ostream].string).to eq('<fn foo><native fn>')
+      end
+
       it 'should print the hello world message' do
         expect { subject.evaluate(hello_world) }.not_to raise_error
         expect(sample_cfg[:ostream].string).to eq('Hello, world!')
       end
     end # context
   end # describe
+  # rubocop: enable Metrics/BlockLength
 end # module

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: loxxy
 version: !ruby/object:Gem::Version
-  version: 0.0.26
+  version: 0.1.02
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-22 00:00:00.000000000 Z
+date: 2021-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -90,7 +90,10 @@ files:
 - lib/loxxy/ast/lox_assign_expr.rb
 - lib/loxxy/ast/lox_binary_expr.rb
 - lib/loxxy/ast/lox_block_stmt.rb
+- lib/loxxy/ast/lox_call_expr.rb
 - lib/loxxy/ast/lox_compound_expr.rb
+- lib/loxxy/ast/lox_for_stmt.rb
+- lib/loxxy/ast/lox_fun_stmt.rb
 - lib/loxxy/ast/lox_grouping_expr.rb
 - lib/loxxy/ast/lox_if_stmt.rb
 - lib/loxxy/ast/lox_literal_expr.rb
@@ -106,6 +109,7 @@ files:
 - lib/loxxy/back_end/engine.rb
 - lib/loxxy/back_end/entry.rb
 - lib/loxxy/back_end/environment.rb
+- lib/loxxy/back_end/function.rb
 - lib/loxxy/back_end/symbol_table.rb
 - lib/loxxy/back_end/variable.rb
 - lib/loxxy/datatype/all_datatypes.rb