loxxy 0.0.21 → 0.0.26

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd4cbf32f4ee44a60c45630a76318425850dc35b4d9f6129274cefcbf4e91fcc
-  data.tar.gz: 711e0ae07d2a0b3a080c2fe408d9adf4f7b96bb070af686d66dd3f9dbae8391d
+  metadata.gz: 1258e225c3c22ba2c8a1df645f2ee39fc6fc2330a62b288a15f59e1ca40596b2
+  data.tar.gz: 102ac797634d4abf2e72902f568c5b0cc5ec161433e5e4c4e0888e7142508d65
 SHA512:
-  metadata.gz: 131f6fe3b23dc0a84b063efe70744b02ecc9edb68742540799964311298f35494a0d48db75bb18a240ddeed039286ab08ba2ef99e2ae4857d2b4d5dc4403d5ba
-  data.tar.gz: b46c18f54147fd01f9819e3ad06564ee78fe72de5c91d6ef8a5bef5945d9f1ad622cad848c4d521ae66f00c91b7825d01e57c831b2a097da830bec0d99f2cf06
+  metadata.gz: a1715b6c93b1861fadafac38327ea2fdee592f2b0b46320b04acd7e64db166911dc614d59412dae9d0bbccea9ca95f9299aac276eba9ee2a87a58963a2ec7d13
+  data.tar.gz: 62915b07a3066c8068f41fd622d9d9be4d8baf29b6c3ef0849b3e410be5d52343fa8c00b8bbff1665deefc838cd29a423852f9666af3e410aee77b538f4030f0

data/CHANGELOG.md

@@ -1,7 +1,67 @@
-## [0.0.21] - 2021-01-1x
+## [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
+- 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
+- Class `Ast::LoxSeqDecl` a node that represents a sequence of declarations/statements
+- 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
+- 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.
@@ -14,7 +74,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
@@ -23,20 +83,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
@@ -46,7 +106,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
@@ -54,14 +114,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
@@ -75,17 +135,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
@@ -94,7 +154,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
@@ -102,79 +162,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.
@@ -182,7 +242,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.
@@ -190,31 +250,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

@@ -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:
@@ -144,6 +144,8 @@ Here are the language features currently supported by the interpreter:
 - [Variable declarations](#var-statement)  
 - [If Statement](#if-statement)   
 - [Print Statement](#print-statement)
+- [While Statement](#while-statement)  
+- [Block Statement](#block-statement)
 
 ### Comments
 
@@ -176,10 +178,13 @@ Loxxy supports the following statements:
   -[Comparison expressions](#comparison-expressions)  
   -[Logical expressions](#logical-expressions)  
   -[Grouping expressions](#grouping-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
 
@@ -258,16 +263,22 @@ print 3 + 4 * 5;  // => 23
 print (3 + 4) * 5; // => 35
 ```
 
+####  Variable expressions and assignments
+In __Lox__, a variable expression is nothing than retrieving the value of a variable.
+``` javascript
+var foo = "bar;" // Variable declaration
+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 retrieve the value of a variable.
-Expect this capability to be implemented in the coming days.
-
-
 #### If statement
 
 Based on a given condition, an if statement executes one of two statements:
@@ -288,20 +299,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
@@ -313,6 +325,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:
@@ -335,7 +370,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

@@ -1,11 +1,16 @@
 # frozen_string_literal: true
 
+require_relative 'lox_variable_expr'
 require_relative 'lox_literal_expr'
 require_relative 'lox_noop_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_var_stmt'
+require_relative 'lox_seq_decl'

data/lib/loxxy/ast/ast_builder.rb

@@ -149,8 +149,18 @@ module Loxxy
       end
 
       # rule('program' => 'declaration_plus EOF').as ''
-      def reduce_lox_program(_production, range, tokens, theChildren)
-        return_first_child(range, tokens, theChildren) # Discard the semicolon
+      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)
+        theChildren[0] << theChildren[1]
+      end
+
+      # rule('declaration_plus' => 'declaration')
+      def reduce_declaration_plus_end(_production, _range, _tokens, theChildren)
+        [theChildren[0]]
       end
 
       # rule('exprStmt' => 'expression SEMICOLON')
@@ -170,7 +180,6 @@ module Loxxy
         Ast::LoxVarStmt.new(tokens[1].position, var_name, theChildren[3])
       end
 
-
       # rule('ifStmt' => 'IF ifCondition statement elsePart_opt')
       def reduce_if_stmt(_production, _range, tokens, theChildren)
         condition = theChildren[1]
@@ -184,6 +193,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)
@@ -292,6 +318,12 @@ module Loxxy
         literal = first_child.token.value
         LoxLiteralExpr.new(pos, literal)
       end
+
+      # rule('primary' => 'IDENTIFIER')
+      def reduce_variable_expr(_production, _range, tokens, theChildren)
+        var_name = theChildren[0].token.lexeme
+        LoxVariableExpr.new(tokens[0].position, var_name)
+      end
     end # class
   end # module
 end # module