loxxy 0.0.22 → 0.0.27

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: acd7b65477866aee4f022731a70f67cad63f482eae6ae5e3f5a35cd56c43f9b0
-  data.tar.gz: 4980c1dafbd83c1ed0a41cf5da09d0decba43e912722c5052fc3e4f63626d73a
+  metadata.gz: 47ae4c0af1698de7187c530ec5feec9390a664ff681aae6c47a36e351bda229d
+  data.tar.gz: ff309645b8e71608e6a3801d4a4be558b8e86d59d658af4ec2eb796989e88455
 SHA512:
-  metadata.gz: e8853388df750173e1a9e818e3aac92f33f98ff75cf5c575d0b583758c59938810a593823a73a6914a28413ba697d53147d7317b744484d43b4026c76a182bc4
-  data.tar.gz: 3426ce17792625f908f2a31c879b0a312cbefbe18c82848f769d78bcac550d3700349fc1408bbeddb7738b47735ed583fd89355636c8c377a7cde3baf2f5071f
+  metadata.gz: 73bea958f39a8cb97ed2e59c049ab58006845519a642d20e72cbdd554be60cb3b553f84dcdd64a36410796f83e87bb3239eee9933148b821b074916f4198a810
+  data.tar.gz: a3235fd86a5c99c0ecf581be106e53d59a0643b3ac6299fbd0eccd0f5eacc5a15b63df3a22fb4edef8b30314fa0360432b017d9a2417668e365e2b9dd3f8b2b8

data/CHANGELOG.md

@@ -1,7 +1,66 @@
+## [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.
+
+### Added
+- Method `Ast::ASTVisitor#visit_builtin` for visiting `Datatype::BuiltinDatatype` value.
+- Method `BackEnd::Engine#before_visit_builtin` push the data value onto the stack.
+
+### Fixed
+- Method `Ast::LoxVarStmt#initialize`: in case no explicit value provided then use `Datatype::Nil.instance`instead of Ruby `nil`
+
 ## [0.0.22] - 2021-01-17
 - The interpreter can retrieve the value of a variable.
 
-## Added
+### Added
 - Method `Ast::ASTBuilder#declaration_plus_more` and `Ast::ASTBuilder#declaration_plus_end` to allow multiple expressions/statements
 - Method `Ast::ASTBuilder#reduce_var_expression` creates an `Ast::LoxVariableExpr` node
 - Method `Ast::ASTVisitor#visit_var_expr` for visiting `Ast::LoxVariableExpr` nodes
@@ -9,14 +68,14 @@
 - Class `Ast::LoxVarExpr` a node that represents a variable occurrence in an expression
 - Method `Engine::after_variable_expr`: retrieve the value of variable with given name
 
-## Changed
+### Changed
 - Method `Ast::ASTBuilder#reduce_lox_program` to support multiple statements/declarations
 - File `README.md` updated.
 
 ## [0.0.21] - 2021-01-16
 - The interpreter supports the declaration global variables.
 
-## Added
+### Added
 - Class `BackEnd::Entry`, mixin module for objects put in the symbol table
 - Class `BackEnd::Environment` that keeps track of variables in a given context.
 - Class `BackEnd::SymbolTable` that keeps track of environments.
@@ -29,7 +88,7 @@
 ## [0.0.20] - 2021-01-15
 - The interpreter supports the `if` ... `else` statement.
 
-## Added
+### Added
 - Class `Ast::LoxItStmt`, AST node specific for `if` `else` statements
 - Method `Ast::ASTBuilder#reduce_if_stmt` as semantic action for if ... else
 - Method `Ast::ASTVisitor#visit_if_stmt` for visiting `LoxIfStmt` nodes
@@ -38,20 +97,20 @@
 ## [0.0.19] - 2021-01-14
 - The interpreter supports expressions between parentheses (grouping).
 
-## Added
+### Added
 - Class `Ast::LoxLogicalExpr`
 - Method `Ast::ASTBuilder#reduce_grouping_expr` as semantic action for grouping expression
 - Method `Ast::ASTVisitor#visit_grouping_expr` for visiting grouping expressions
 - Method `Engine::after_grouping_expr`for the evaluation of grouping expressions
 
-## Changed
+### Changed
 - File `grammar.rb` rules for if ... else were given names in order to activate semantic actions.
 - File `README.md` updated with little `if ... else` documentation.
 
 ## [0.0.18] - 2021-01-13
 - The interpreter can evaluate `and`, `or`expressions.
 
-## Added
+### Added
 - Class `Ast::LoxLogicalExpr`
 - Method `Ast::ASTBuilder#reduce_logical_expr` for the semantic action require for `and`, `or`
 - Method `Ast::ASTVisitor#visit_logical_expr` for visiting logical expressions
@@ -61,7 +120,7 @@
 - The interpreter can evaluate all arithmetic and comparison operations.
 - It implements `==`, `!=` and the unary operations `!`, `-`
 
-## Added
+### Added
 - Class `Ast::LoxUnaryExpr`
 - Method `Ast::ASTBuilder#reduce_unary_expr` to support the evaluation of `!` and ``-@`
 - Method `Ast::ASTVisitor#visit_unnary_expr` for visiting unary expressions
@@ -69,14 +128,14 @@
 - In class `Datatype::BuiltinDatatype` the methods `falsey?`, `truthy?`, `!`, `!=`
 - In class `Datatype::Number`the methods `<`, `<=`, ´>´, `>=` and `-@`
 
-## Changed
+### Changed
 - File `README.md` updated.
 
 ## [0.0.16] - 2021-01-11
 - The interpreter can evaluate product and division of two numbers.
 - It also implements equality `==` and inequality `!=` operators
 
-## Added
+### Added
 - Method `Datatype::False#==` for equality testing
 - Method `Datatype::False#!=` for inequality testing
 - Method `Datatype::LXString#==` for equality testing
@@ -90,17 +149,17 @@
 - Method `Datatype::True#==` for equality testing
 - Method `Datatype::True#!=` for inequality testing
 
-## Changed
+### Changed
 - Method `BackEnd::Engine#after_binary_expr` to allow `*`, `/`, `==`, `!=` operators
 - File `README.md` updated for the newly implemented operators
 
 ## [0.0.15] - 2021-01-11
 - The interpreter can evaluate substraction between two numbers.
 
-## Added
+### Added
 - Method `Datatype::Number#-` implmenting the subtraction operation
 
-## Changed
+### Changed
 - File `README.md` minor editorial changes.
 - File `lx_string_spec.rb` Added test for string concatentation
 - File `number_spec.rb` Added tests for addition and subtraction operations
@@ -109,7 +168,7 @@
 ## [0.0.14] - 2021-01-10
 - The interpreter can evaluate addition of numbers and string concatenation
 
-## Added
+### Added
 - Method `Ast::ASTVisitor#visit_binary_expr` for visiting binary expressions
 - Method `Ast::LoxBinaryExpr#accept` for visitor pattern
 - Method `BackEnd::Engine#after_binary_expr` to trigger execution of binary operator
@@ -117,79 +176,79 @@
 - Method `Datatype::LXString#+` implementation of the string concatenation
 - Method `Datatype::Number#+` implementation of the addition of numbers
 
-## Changed
+### Changed
 - File `interpreter_spec.rb` Added tests for addition operation and string concatenation
 
 
 ## [0.0.13] - 2021-01-10
 - The interpreter can evaluate directly simple literals.
 
-## Changed
+### Changed
 - Class `AST::ASTBuilder` added `reduce_exprStmt` to support the evaluation of literals.
 - File `README.md` added one more example.
 - File `parser_spec.rb` Updated the tests to reflect the change in the AST.
 - File `interpreter_spec.rb` Added a test for literal expression.
 
-## Fixed
+### Fixed
 - File `loxxy.rb`: shorthand method `lox_true` referenced the ... false object (oops).
 
 ## [0.0.12] - 2021-01-09
 - Initial interpreter capable of evaluating a tiny subset of Lox language.
 
-## Added
+### Added
 - Class `AST::LoxNoopExpr`
 - Class `AST::LoxPrintStmt`
 - Class `BackEnd::Engine` implementation of the print statement logic
 - Class `Interpreter`
 
-## Changed
+### Changed
 - Class `Ast::ASTVisitor` Added visit method
 - File `README.md` added Hello world example.
 
 ## [0.0.11] - 2021-01-08
 - AST node generation for logical expression (and, or).
 
-## Changed
+### Changed
 - Class `AST::ASTBuilder` added `reduce_` methods for logical operations.
 - File `grammar.rb`added name to logical expression rules
 - File `README.md` added gem version and license badges, expanded roadmap section.
 
-## Fixed
+### Fixed
 - File `grammar.rb`: a rule had incomplete non-terminal name `conjunct_` in its lhs.
 
 
 ## [0.0.10] - 2021-01-08
 - AST node generation for equality expression.
 
-## Changed
+### Changed
 - Class `AST::ASTBuilder` refactoring and added `reduce_` methods for equality operations.
 - File `grammar.rb`added name to equality rules
 - File `README.md` added gem version and license badges, expanded roadmap section.
 
-## Fixed
+### Fixed
 - File `grammar.rb`: a rule had still the discarded non-terminal `equalityTest_star` in its lhs.
 
 ## [0.0.9] - 2021-01-07
 - AST node generation for comparison expression.
 
-## Changed
+### Changed
 - Class `AST::ASTBuilder` added `reduce_` methods for comparison operations.
 - File `grammar.rb`added name to comparison rules
 
 ## [0.0.8] - 2021-01-07
 - AST node generation for arithmetic operations of number literals.
 
-## Changed
+### Changed
 - Class `AST::ASTBuilder` added `reduce_` methods for arithmetic operations.
 - File `grammar.rb`added name to arithmetic rules
 
-## Fixed
+### Fixed
 - File `grammar.rb`: second rule for `factor` had a missing member in rhs.
 
 ## [0.0.7] - 2021-01-06
 - Lox grammar reworked, initial AST classes created.
 
-## Added
+### Added
 - Class `Parser` this one generates AST's (Abstract Syntax Tree)
 - Class `AST::ASTVisitor` draft initial implementation.
 - Class `AST::BinaryExpr` draft initial implementation.
@@ -197,7 +256,7 @@
 - Class `AST::LiteralExpr` draft initial implementation.
 - Class `AST::LoxNode` draft initial implementation.
 
-## Changed
+### Changed
 - File `spec_helper.rb`: removed Bundler dependency
 - Class `AST::ASTBuilder` added initial `reduce_` methods.
 - File `README.md` Removed example with AST generation since this is in flux.
@@ -205,31 +264,31 @@
 ## [0.0.6] - 2021-01-03
 - First iteration of a parser with AST generation.
 
-## Added
+### Added
 - Class `Parser` this one generates AST's (Abstract Syntax Tree)
 - Class `AST::ASTBuilder` default code to generate an AST.
 
-## Changed
+### Changed
 - File `spec_helper.rb`: removed Bundler dependency
 - File `README.md` Added example with AST visualization.
 
-## Fixed
+### Fixed
 - File `grammar.rb` ensure that the constant `Grammar` is created once only.
 
 ## [0.0.5] - 2021-01-02
 - Improved example in `README.md`, code re-styling to please `Rubocop` 1.7
 
-## Changed
+### Changed
 - Code re-styling to please `Rubocop` 1.7
 - File `README.md` Improved example with better parse tree visualization.
 
 ## [0.0.4] - 2021-01-01
 - A first parser implementation able to parse Lox source code.
 
-## Added
+### Added
 - Method `LXString::==` equality operator.
 
-## Changed
+### Changed
 - class `Parser` renamed to `RawParser`
 - File `README.md` Added an example showing the use of `RawParser` class.
 

data/README.md

@@ -14,7 +14,7 @@ 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 a subset of __Lox__ language.
 
 But the __loxxy__ gem hosts also a parser class `RawPaser` that can parse, in principle, any valid Lox input.
 
@@ -131,7 +131,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 +141,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 +179,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,22 +264,30 @@ 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
 ``` javascript
 var iAmAVariable = "my-initial-value";
 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
 
@@ -296,20 +309,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
@@ -321,6 +335,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:
@@ -343,7 +380,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

@@ -7,7 +7,11 @@ 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

@@ -149,18 +149,18 @@ module Loxxy
       end
 
       # rule('program' => 'declaration_plus EOF').as ''
-      def reduce_lox_program(_production, range, tokens, theChildren)
+      def reduce_lox_program(_production, _range, tokens, theChildren)
         LoxSeqDecl.new(tokens[0].position, theChildren[0])
       end
 
       # rule('declaration_plus' => 'declaration_plus declaration').as ''
-      def reduce_declaration_plus_more(_production, range, tokens, theChildren)
+      def reduce_declaration_plus_more(_production, _range, _tokens, theChildren)
         theChildren[0] << theChildren[1]
       end
 
       # rule('declaration_plus' => 'declaration')
-      def reduce_declaration_plus_end(_production, range, tokens, theChildren)
-        [ theChildren[0] ]
+      def reduce_declaration_plus_end(_production, _range, _tokens, theChildren)
+        [theChildren[0]]
       end
 
       # rule('exprStmt' => 'expression SEMICOLON')
@@ -180,6 +180,28 @@ 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)
@@ -194,6 +216,23 @@ module Loxxy
         Ast::LoxPrintStmt.new(tokens[1].position, theChildren[1])
       end
 
+      # 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('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('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)
@@ -307,8 +346,7 @@ module Loxxy
       def reduce_variable_expr(_production, _range, tokens, theChildren)
         var_name = theChildren[0].token.lexeme
         LoxVariableExpr.new(tokens[0].position, var_name)
-      end#
-
+      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.
@@ -129,13 +161,20 @@ 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)
         broadcast(:after_variable_expr, aVariableExpr, self)
       end
 
+      # Visit event. The visitor is about to visit the given terminal datatype value.
+      # @param aNonTerminalNode [Ast::BuiltinDattype] the built-in datatype value
+      def visit_builtin(aValue)
+        broadcast(:before_visit_builtin, aValue)
+        broadcast(:after_visit_builtin, aValue)
+      end
+
       # Visit event. The visitor is about to visit the given non terminal node.
       # @param aNonTerminalNode [Rley::PTree::NonTerminalNode] the node to visit.
       def visit_nonterminal(_non_terminal_node)

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_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_if_stmt.rb

@@ -32,4 +32,4 @@ module Loxxy
       end
     end # class
   end # module
-end # module
+end # module

data/lib/loxxy/ast/lox_seq_decl.rb

@@ -5,12 +5,6 @@ require_relative 'lox_compound_expr'
 module Loxxy
   module Ast
     class LoxSeqDecl < LoxCompoundExpr
-      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
-      # @param declarations [Arrya<Loxxy::Ast::LoxNode>]
-      def initialize(aPosition, declarations)
-        super(aPosition, declarations)
-      end
-
       # Part of the 'visitee' role in Visitor design pattern.
       # @param visitor [Ast::ASTVisitor] the visitor
       def accept(visitor)

data/lib/loxxy/ast/lox_var_stmt.rb

@@ -13,7 +13,7 @@ module Loxxy
       # @param aName [String] name of the variable
       # @param aValue [Loxxy::Ast::LoxNode, NilClass] initial value for the variable
       def initialize(aPosition, aName, aValue)
-        initial_value = aValue ? [aValue] : []
+        initial_value = aValue ? [aValue] : [Datatype::Nil.instance]
         super(aPosition, initial_value)
         @name = aName
       end

data/lib/loxxy/ast/lox_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

@@ -51,11 +51,28 @@ 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
         if condition.truthy?
-          result = anIfStmt.then_stmt.accept(aVisitor)
+          anIfStmt.then_stmt.accept(aVisitor)
         elsif anIfStmt.else_stmt
           anIfStmt.else_stmt.accept(aVisitor)
         end
@@ -66,6 +83,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
@@ -129,6 +175,7 @@ module Loxxy
         var_name = aVarExpr.name
         var = symbol_table.lookup(var_name)
         raise StandardError, "Unknown variable #{var_name}" unless var
+
         var.value.accept(aVisitor) # Evaluate the variable value
       end
 
@@ -136,6 +183,11 @@ module Loxxy
       def before_literal_expr(literalExpr)
         stack.push(literalExpr.literal)
       end
+
+      # @param aNonTerminalNode [Ast::BuiltinDattype] the built-in datatype value
+      def before_visit_builtin(aValue)
+        stack.push(aValue)
+      end
     end # class
   end # module
 end # module

data/lib/loxxy/back_end/entry.rb

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

data/lib/loxxy/back_end/environment.rb

@@ -9,9 +9,9 @@ module Loxxy
     # of a relation or a relation definition.
     # It contains a map of names to the objects they name (e.g. logical var)
     class Environment
-      # The parent (enclosing) environment.
+      # The  enclosing (parent) environment.
       # @return [Environment, NilClass]
-      attr_accessor :parent
+      attr_accessor :enclosing
 
       # Mapping from user-defined name to related definition
       #  (say, a variable object)
@@ -21,7 +21,7 @@ module Loxxy
       # Construct a environment instance.
       # @param aParent [Environment, NilClass] Parent environment to this one.
       def initialize(aParent = nil)
-        @parent = aParent
+        @enclosing = aParent
         @defns = {}
       end
 

data/lib/loxxy/back_end/symbol_table.rb

@@ -44,7 +44,7 @@ module Loxxy
       # to be a child of current environment and to be itself the new current environment.
       # @param anEnv [BackEnd::Environment] the Environment that
       def enter_environment(anEnv)
-        anEnv.parent = current_env
+        anEnv.enclosing = current_env
         @current_env = anEnv
       end
 
@@ -60,7 +60,7 @@ module Loxxy
         end
         raise StandardError, 'Cannot remove root environment.' if current_env == root
 
-        @current_env = current_env.parent
+        @current_env = current_env.enclosing
       end
 
       # Add an entry with given name to current environment.
@@ -114,7 +114,7 @@ module Loxxy
         while skope
           vars_of_environment = skope.defns.select { |_, item| item.kind_of?(Variable) }
           vars = vars_of_environment.values.concat(vars)
-          skope = skope.parent
+          skope = skope.enclosing
         end
 
         vars

data/lib/loxxy/back_end/variable.rb

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

data/lib/loxxy/datatype/builtin_datatype.rb

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

data/lib/loxxy/front_end/grammar.rb

@@ -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,15 +75,15 @@ module Loxxy
 
       rule('printStmt' => 'PRINT expression SEMICOLON').as 'print_stmt'
       rule('returnStmt' => 'RETURN expression_opt SEMICOLON')
-      rule('whileStmt' => 'WHILE LEFT_PAREN expression RIGHT_PAREN statement')
-      rule('block' => 'LEFT_BRACE declaration_plus RIGHT_BRACE')
+      rule('whileStmt' => 'WHILE LEFT_PAREN expression RIGHT_PAREN statement').as 'while_stmt'
+      rule('block' => 'LEFT_BRACE declaration_plus RIGHT_BRACE').as 'block_stmt'
       rule('block' => 'LEFT_BRACE RIGHT_BRACE')
 
       # Expressions: produce values
       rule('expression_opt' => 'expression')
       rule('expression_opt' => [])
       rule('expression' => 'assignment')
-      rule('assignment' => 'owner_opt IDENTIFIER EQUAL assignment')
+      rule('assignment' => 'owner_opt IDENTIFIER EQUAL assignment').as 'assign_expr'
       rule('assignment' => 'logic_or')
       rule('owner_opt' => 'call DOT')
       rule('owner_opt' => [])

data/lib/loxxy/version.rb

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

data/spec/back_end/environment_spec.rb

@@ -9,7 +9,7 @@ module Loxxy
   module BackEnd
     describe Environment do
       let(:foo) { Datatype::LXString.new('foo') }
-      let(:bar) { Datatype::LXString.new('bar') }      
+      let(:bar) { Datatype::LXString.new('bar') }
       let(:mother) { Environment.new }
       subject { Environment.new(mother) }
 
@@ -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

@@ -46,8 +46,8 @@ module Loxxy
         end
 
         it 'should allow the addition of several labels for same env' do
-          i_name = subject.insert(var('q'))
-          #expect(i_name).to match(/^q_[0-9a-z]*$/)
+          subject.insert(var('q'))
+          # expect(i_name).to match(/^q_[0-9a-z]*$/)
 
           expect { subject.insert(var('x')) }.not_to raise_error
           expect(subject.name2envs['x']).to be_kind_of(Array)
@@ -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/back_end/variable_spec.rb

@@ -17,10 +17,10 @@ module Loxxy
         it 'should be initialized with a name and a value, or...' do
           expect { Variable.new(sample_name, sample_value) }.not_to raise_error
         end
-        
+
         it 'should be initialized with just a name' do
           expect { Variable.new(sample_name) }.not_to raise_error
-        end        
+        end
 
         it 'should know its name' do
           expect(subject.name).to eq(sample_name)
@@ -29,11 +29,11 @@ module Loxxy
         it 'should have a frozen name' do
           expect(subject.name).to be_frozen
         end
-        
+
         it 'should know its value (if provided)' do
           expect(subject.value).to eq(sample_value)
         end
-        
+
         it 'should have a nil value otherwise' do
           instance = Variable.new(sample_name)
           expect(instance.value).to eq(Datatype::Nil.instance)

data/spec/interpreter_spec.rb

@@ -53,10 +53,12 @@ module Loxxy
 
     context 'Evaluating Lox code:' do
       let(:hello_world) do
-        lox =<<-LOX_END
+        lox = <<-LOX_END
         var greeting = "Hello"; // Declaring a variable
         print greeting + ", " + "world!"; // ... Playing with concatenation
 LOX_END
+
+        lox
       end
 
       it 'should evaluate core data types' do
@@ -240,7 +242,7 @@ LOX_END
           ['if (true) print "then-branch"; else print "else-branch";', 'then-branch'],
           ['if (false) print "then-branch"; else print "else-branch";', 'else-branch'],
           ['if (0) print "then-branch"; else print "else-branch";', 'then-branch'],
-          ['if (nil) print "then-branch"; else print "else-branch";', 'else-branch'],
+          ['if (nil) print "then-branch"; else print "else-branch";', 'else-branch']
           # TODO: test with else block body
 
           # TODO: A dangling else binds to the right-most if.
@@ -250,7 +252,7 @@ LOX_END
           io = StringIO.new
           cfg = { ostream: io }
           lox = Loxxy::Interpreter.new(cfg)
-          result = lox.evaluate(source)
+          lox.evaluate(source)
           expect(io.string).to eq(predicted)
         end
       end
@@ -267,12 +269,133 @@ LOX_END
       it 'should accept variable mention' do
         program = <<-LOX_END
         var foo = "bar";
-        print foo;
+        print foo; // => bar
 LOX_END
         expect { subject.evaluate(program) }.not_to raise_error
         expect(sample_cfg[:ostream].string).to eq('bar')
       end
 
+      it 'should set uninitialized variables to nil' do
+        program = <<-LOX_END
+        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 for loops without initialization' do
+        program = <<-LOX_END
+          var i = 0;
+          // No variable in initialization.
+          for (; i < 2; i = i + 1) print i;
+          // output: 0
+          // output: 1
+        LOX_END
+        expect { subject.evaluate(program) }.not_to raise_error
+        expect(sample_cfg[:ostream].string).to eq('01')
+      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.22
+  version: 0.0.27
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-17 00:00:00.000000000 Z
+date: 2021-01-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -87,8 +87,11 @@ 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_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 +103,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