loxxy 0.0.23 → 0.0.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aeb2808649debaf9bdbca836e459b0f7991442c90aad6bb4b174374fb66234df
-  data.tar.gz: 78b1b43091b11b5bde2b2444dd785e3c464252af044167acade6f04b830f95fa
+  metadata.gz: 6b9202e7a755cffecb3226da5764a3cb6f75fd3179803eb25779ae42822bbf15
+  data.tar.gz: 49767873134c5c124aab3e6b20a49c60f968df180dfd6e945f3da2808eee59c7
 SHA512:
-  metadata.gz: 24113720fa7bcd7d711cf03668c86af5a10de3b06dcf9b02d6a5c3550d86e0a19d5374b0d0de6c641afd2a5a9de7c7baccee9da96f97fece6aaf37864d91a0d3
-  data.tar.gz: 0103b262f03272b23f297a57b7d0735c513f6ef0b82e9a2f13e20068845e0cb6ac1952c46a404247b23dde37e75c3fbc48b45f44c1b07470078e4554d5ed54c5
+  metadata.gz: 29c481015e414ea71eb55c0b4dcc4d793b011a8f16fa7f9218ec704b2baea820e47ba758ba9a2e30e5bdfe08bfd2ad8fa892e6d67e247938b8bcda7b005ff2a9
+  data.tar.gz: cbf671e54aa98e799b6d565cac52fb19fb3f5d7b3ae84841f27067ae427e5a7c25a7d40a07d39645150f73176709fbcc6e3bbf36e9cada14d8b329f335c621d5

data/CHANGELOG.md

@@ -1,3 +1,52 @@
+## [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
+- 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
+
+### Changed
+- File `README.md` updated.
+
+## [0.0.25] - 2021-01-21
+- The interpreter implements blocks of code.
+
+### Added
+- Class `Ast::LoxBlockStmt` a node that represents a block of code
+- Method `Ast::ASTBuilder#reduce_block_stmt` creates an `Ast::LoxBlockStmt` node
+- Method `Ast::ASTVisitor#visit_block_stmt` for visiting an `Ast::LoxBlockStmt` node
+- Method `BackEnd::Engine#before_block_stmt` creates an new enclosed Environment
+- Method `BackEnd::Engine#after_block_stmt` close enclosed Environment and make parent Environment the current one
+
+### Changed
+- File `README.md` updated.
+
+## [0.0.24] - 2021-01-20
+- The interpreter implements the assignment of variables.
+
+### Added
+- Class `Ast::LoxAssignExpr` a node that represents the assignment of a value to a variable
+- Method `Ast::ASTBuilder#reduce_assign_expr` creates an `Ast::LoxAssignExpr` node
+- Method `Ast::ASTVisitor#visit_assign_expr` for visiting an `Ast::LoxAssignExpr` node
+- Method `BackEnd::Engine#after_assign_expr` implementation of the assignment
+- Method `BackEnd::Variable#assign` to assign a value to a variable 
+
 ## [0.0.23] - 2021-01-20
 - Fix for variables without explicit initialization.
 

data/README.md

@@ -14,9 +14,13 @@ 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 statement except:
+- Functions and 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...  
@@ -131,7 +135,7 @@ program
 On one hand, the parser covers the complete Lox grammar and should therefore, in principle,
 parse any valid Lox program.
 
-On the other hand, the interpreter is under development and currently it can evaluate only a tiny subset of __Lox__.
+On the other hand, the interpreter is under development and currently it can evaluate only a subset of __Lox__.
 But the situation is changing almost daily, stay tuned...
 
 Here are the language features currently supported by the interpreter:
@@ -141,9 +145,12 @@ 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)
 
 ### Comments
 
@@ -176,11 +183,13 @@ Loxxy supports the following statements:
   -[Comparison expressions](#comparison-expressions)  
   -[Logical expressions](#logical-expressions)  
   -[Grouping expressions](#grouping-expressions)  
-  -[Variable expressions](#variable-expressions)
+  -[Variable expressions and assignments](#variable-expressions)
   
 -[Variable declarations](#var-statement)  
 -[If Statement](#if-statement)  
--[Print Statement](#print-statement)
+-[Print Statement](#print-statement)  
+-[While Statement](#while-statement)
+-[Block Statement](#block-statement)
 
 #### Expressions
 
@@ -259,11 +268,13 @@ print 3 + 4 * 5;  // => 23
 print (3 + 4) * 5; // => 35
 ```
 
-####  Variable expressions
+####  Variable expressions and assignments
 In __Lox__, a variable expression is nothing than retrieving the value of a variable.
 ``` javascript
 var foo = "bar;" // Variable declaration
-foo;  // Varible expression (= retrieving its value)
+print foo;  // Variable expression (= use its value)
+foo = "baz"; // Variable assignment
+print foo; // Output: baz
 ```
 
 #### Variable declarations
@@ -273,9 +284,14 @@ var iAmNil; // __Lox__ initializes variables to nil by default;
 print iAmNil; // output: nil
 ```
 
-Warning: current version cannot assign a value to an existing variable.  
-Expect this capability to be implemented in the coming days.
+#### 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
 
@@ -297,20 +313,21 @@ The problem in a nutshell: in a nested if ... else ... statement like this:
 ``` javascript
 'if (true) if (false) print "bad"; else print "good";
 ```
-... there is an ambiguity. Indeed, according to the __Lox__ grammar, the `else` could be bound 
+... there is an ambiguity.  
+Indeed, according to the __Lox__ grammar, the `else` could be bound 
 either to the first `if` or to the second one.
 This ambiguity is usually lifted by applying an ad-hoc rule: an `else` is aways bound to the most 
 recent (rightmost) `if`.  
-Being a generic parsing library, `Rley` doesn't apply any of these supplemental rules.
+Being a generic parsing library, `Rley` doesn't apply any of these supplemental rules.  
 As a consequence,it complains about the found ambiguity and stops the parsing...
 Although `Rley` can cope with ambiguities, this requires the use of an advanced data structure
 called `Shared Packed Parse Forest (SPPF)`.
-SPPF are much more complex to handle than the `common` parse trees present in most compiler or interpreter books.
+SPPF are much more complex to handle than the "common" parse trees present in most compiler or interpreter books.
 Therefore, a future version of `Rley` will incorporate the capability to define disambuiguation rules.  
 
 In the meantime, the `Loxxy` will progress on other __Lox__ features like:
-- Variables,
 - Block structures...
+- Iteration structures (`for` and `while` loops)
 
 
 ####  Print Statement
@@ -322,6 +339,29 @@ print "Hello, world!";  // Output: Hello, world!
 
 ```
 
+####  While Statement
+
+``` javascript
+  var a = 1;
+  while (a < 10) {
+    print a;
+    a = a + 1;
+  } // Output: 123456789
+```
+
+#### Block Statement
+__Lox__ has code blocks.
+``` javascript
+var a = "outer";
+
+{
+  var a = "inner";
+  print a; // output: inner
+}
+
+print a; // output: outer
+```
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -344,7 +384,7 @@ TODO: Write usage instructions here
 
 ## Other Lox implementations in Ruby
 
-For Ruby, there is the [lox](https://github.com/rdodson41/ruby-lox) gem.
+For Ruby, there is the [lox](https://github.com/rdodson41/ruby-lox) gem.  
 There are other Ruby-based projects as well:  
 - [SlowLox](https://github.com/ArminKleinert/SlowLox), described as a "1-to-1 conversion of JLox to Ruby"
 - [rulox](https://github.com/LevitatingBusinessMan/rulox)

data/lib/loxxy/ast/all_lox_nodes.rb

@@ -3,11 +3,16 @@
 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'
 require_relative 'lox_logical_expr'
+require_relative 'lox_assign_expr'
+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

@@ -180,6 +180,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]
@@ -193,99 +216,52 @@ module Loxxy
         Ast::LoxPrintStmt.new(tokens[1].position, theChildren[1])
       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)
+      # rule('whileStmt' => 'WHILE LEFT_PAREN expression RIGHT_PAREN statement').as ''
+      def reduce_while_stmt(_production, _range, tokens, theChildren)
+        Ast::LoxWhileStmt.new(tokens[1].position, theChildren[2], theChildren[4])
       end
 
-      # rule('logic_and' => 'equality conjunct_plus')
-      def reduce_logic_and_plus(production, range, tokens, theChildren)
-        reduce_logical_expr(production, range, tokens, theChildren)
+      # rule('block' => 'LEFT_BRACE declaration_plus RIGHT_BRACE')
+      def reduce_block_stmt(_production, _range, tokens, theChildren)
+        decls = LoxSeqDecl.new(tokens[1].position, theChildren[1])
+        Ast::LoxBlockStmt.new(tokens[1].position, decls)
       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)
+      # 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('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')
@@ -307,6 +283,16 @@ module Loxxy
         var_name = theChildren[0].token.lexeme
         LoxVariableExpr.new(tokens[0].position, var_name)
       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

@@ -67,6 +67,14 @@ module Loxxy
         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,6 +91,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.
@@ -113,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)
@@ -129,7 +169,7 @@ module Loxxy
         broadcast(:after_literal_expr, aLiteralExpr)
       end
 
-      # Visit event. The visitor is visiting a variable reference node
+      # 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)
@@ -145,10 +185,12 @@ module Loxxy
 
       # 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(non_terminal_node)
         # Loxxy interpreter encountered a CST node (Concrete Syntax Tree)
         # that it cannot handle.
-        raise NotImplementedError, 'Loxxy cannot execute this code yet.'
+        symb = non_terminal_node.symbol.name
+        msg = "Loxxy cannot execute this code yet for non-terminal symbol '#{symb}'."
+        raise NotImplementedError, msg
       end
 
       private

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_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,42 @@
+# 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]
+      # @param body [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_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

@@ -25,6 +25,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 +53,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,6 +85,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
@@ -121,6 +169,17 @@ module Loxxy
         end
       end
 
+      def after_call_expr(aCallExpr, aVisitor)
+        # Evaluate callee part
+        aCallExpr.callee.accept(aVisitor)
+        callee = stack.pop
+        # TODO: reverse order?
+        aCallExpr.arguments.each do |arg|
+          arg.evaluate(aVisitor)
+        end
+        stack.push callee.call # Pass arguments
+      end
+
       def after_grouping_expr(_groupingExpr)
         # Do nothing: work was already done by visiting /evaluating the subexpression
       end
@@ -142,6 +201,32 @@ module Loxxy
       def before_visit_builtin(aValue)
         stack.push(aValue)
       end
+
+      private
+
+      NativeFunction = Struct.new(:callable, :interp) do
+        def accept(_visitor)
+          interp.stack.push callable
+        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/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

@@ -11,13 +11,18 @@ module Loxxy
       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/front_end/grammar.rb

@@ -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'
@@ -75,50 +75,50 @@ 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' => [])
       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'
@@ -149,8 +149,8 @@ module Loxxy
       rule('parameters' => 'IDENTIFIER')
       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/version.rb

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

data/spec/back_end/environment_spec.rb

@@ -32,7 +32,7 @@ module Loxxy
         end
 
         it 'should know its parent (if any)' do
-          expect(subject.parent).to eq(mother)
+          expect(subject.enclosing).to eq(mother)
         end
       end # context
 

data/spec/back_end/symbol_table_spec.rb

@@ -60,7 +60,7 @@ module Loxxy
           new_env = BackEnd::Environment.new
           expect { subject.enter_environment(new_env) }.not_to raise_error
           expect(subject.current_env).to eq(new_env)
-          expect(subject.current_env.parent).to eq(subject.root)
+          expect(subject.current_env.enclosing).to eq(subject.root)
           expect(subject.name2envs['q']).to eq([subject.root])
         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

@@ -277,13 +277,123 @@ LOX_END
 
       it 'should set uninitialized variables to nil' do
         program = <<-LOX_END
-        var foo;
-        print foo; // => nil
+        var a;
+        print a; // => nil
 LOX_END
         expect { subject.evaluate(program) }.not_to raise_error
         expect(sample_cfg[:ostream].string).to eq('nil')
       end
 
+      it 'should accept assignments to a global variable' do
+        program = <<-LOX_END
+          var a = "before";
+          print a; // output: before
+
+          a = "after";
+          print a; // output: after
+
+          print a = "arg"; // output: arg
+          print a; // output: arg
+        LOX_END
+        expect { subject.evaluate(program) }.not_to raise_error
+        expect(sample_cfg[:ostream].string).to eq('beforeafterargarg')
+      end
+
+      it 'should support variables local to a block' do
+        program = <<-LOX_END
+        {
+          var a = "first";
+          print a;
+        }
+        {
+          var a = "second";
+          print a;
+        }
+        LOX_END
+        expect { subject.evaluate(program) }.not_to raise_error
+        expect(sample_cfg[:ostream].string).to eq('firstsecond')
+      end
+
+      it 'should support the shadowing of variables in a block' do
+        program = <<-LOX_END
+        var a = "outer";
+
+        {
+          var a = "inner";
+          print a; // output: inner
+        }
+
+        print a; // output: outer
+        LOX_END
+        expect { subject.evaluate(program) }.not_to raise_error
+        expect(sample_cfg[:ostream].string).to eq('innerouter')
+      end
+
+      it 'should implement single statement while loops' do
+        program = <<-LOX_END
+          // Single-expression body.
+          var c = 0;
+          while (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 block body while loops' do
+        program = <<-LOX_END
+          // Block body.
+          var a = 0;
+          while (a < 3) {
+            print a;
+            a = a + 1;
+          }
+          // 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 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 expect 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 print the hello world message' do
         expect { subject.evaluate(hello_world) }.not_to raise_error
         expect(sample_cfg[:ostream].string).to eq('Hello, world!')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: loxxy
 version: !ruby/object:Gem::Version
-  version: 0.0.23
+  version: 0.0.28
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-20 00:00:00.000000000 Z
+date: 2021-02-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -87,8 +87,12 @@ files:
 - lib/loxxy/ast/all_lox_nodes.rb
 - lib/loxxy/ast/ast_builder.rb
 - lib/loxxy/ast/ast_visitor.rb
+- 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_grouping_expr.rb
 - lib/loxxy/ast/lox_if_stmt.rb
 - lib/loxxy/ast/lox_literal_expr.rb
@@ -100,6 +104,7 @@ files:
 - lib/loxxy/ast/lox_unary_expr.rb
 - lib/loxxy/ast/lox_var_stmt.rb
 - lib/loxxy/ast/lox_variable_expr.rb
+- lib/loxxy/ast/lox_while_stmt.rb
 - lib/loxxy/back_end/engine.rb
 - lib/loxxy/back_end/entry.rb
 - lib/loxxy/back_end/environment.rb