loxxy 0.0.20 → 0.0.25

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e6628d902c258d0aa2d589fd0960ab812addbfe8f0fbf162cfb627a90fbc1a40
-  data.tar.gz: c1fe1f5ce4b3dc7109c70783b78953fd72ffbbd837d58f8350d2a03615f80222
+  metadata.gz: 15da87c78ce0d90162679c2b76478cfaff17d9f88f78d4109190b83952146956
+  data.tar.gz: 0c9b1834f17cc51da96ec568d0804131b65dd6b82125ace0e4c56d6062250d09
 SHA512:
-  metadata.gz: 301160cc1a00e819cc13cfb3273985b6af1ddadd94b236e4e7be0b346744355327be69d3b2d338ece3b6148a905d10a91dc3f6ef828912b7750efcdb0f4e5238
-  data.tar.gz: cc5bb436b6e487d7752180d42d046d5a09a6817878428d757b65b26f2955133985598b55e7d63c13d249ebef110914a3a2b8292777a2857b15dcba885c74c106
+  metadata.gz: 6c31994ac27f67cc461fc10453468a42a17691f1b5c3171e23d26dcf9ecd6b5f5de8ad97184037990de6268039e57f8b0d5e80e4411f9c0a1a02b5edba766e91
+  data.tar.gz: 15ceead67dc859d2e4d3ca3e97aaa67372b581317fdbac8a66241ffb3322acec3115a5dab619a11d0a740676734fe5e517b9b1ca3aff218800ac07d693927263

data/CHANGELOG.md

@@ -1,7 +1,68 @@
+## [0.0.25] - 2021-01-21
+- The interpreter implements block 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
+- 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.
+- Class `BackEnd::Variable` internal representation of a `Lox` variable
+- Method `Ast::ASTBuilder#reduce_var_declaration` and `Ast::ASTBuilder#reduce_var_declaration`
+- Method `Ast::ASTVisitor#visit_var_stmt` for visiting `LoxVarStmt` nodes
+- Attribute `Engine::symbol_table`for keeping track of variables
+- Method `Engine::after_var_stmt` for the implementation of variable declarations
+
 ## [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
@@ -10,20 +71,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
@@ -33,7 +94,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
@@ -41,14 +102,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
@@ -62,17 +123,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
@@ -81,7 +142,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
@@ -89,79 +150,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.
@@ -169,7 +230,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.
@@ -177,31 +238,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

@@ -8,7 +8,7 @@ a simple language used in Bob Nystrom's online book [Crafting Interpreters](http
 
 ### Purpose of this project:
 - To deliver an open source example of a programming language fully implemented in Ruby  
-  (from the scanner, parser, an interpreter).
+  (from the scanner and parser to an interpreter).
 - The implementation should be mature enough to run [LoxLox](https://github.com/benhoyt/loxlox),  
   a Lox interpreter written in Lox.
 
@@ -141,7 +141,10 @@ Here are the language features currently supported by the interpreter:
 - [Datatypes](#datatypes)
 - [Statements](#statements)  
   -[Expressions](#expressions)  
-  -[Print Statement](#print-statement)
+- [Variable declarations](#var-statement)  
+- [If Statement](#if-statement)   
+- [Print Statement](#print-statement)
+- [Block Statement](#block-statement)
 
 ### Comments
 
@@ -168,14 +171,18 @@ loxxy supports  all the standard __Lox__ datatypes:
 ### Statements
 
 Loxxy supports the following statements:  
--[Expressions](#expressions)  
+- [Expressions](#expressions)  
   -[Arithmetic expressions](#arithmetic-expressions)  
   -[String concatenation](#string-concatenation)  
   -[Comparison expressions](#comparison-expressions)  
   -[Logical expressions](#logical-expressions)  
   -[Grouping expressions](#grouping-expressions)  
--[If Statement](#if-statement)
--[Print Statement](#print-statement)
+  -[Variable expressions and assignments](#variable-expressions)
+  
+-[Variable declarations](#var-statement)  
+-[If Statement](#if-statement)  
+-[Print Statement](#print-statement)  
+-[Block Statement](#block-statement)
 
 #### Expressions
 
@@ -254,6 +261,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
+```
+
 #### If statement
 
 Based on a given condition, an if statement executes one of two statements:
@@ -274,20 +297,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
@@ -299,6 +323,19 @@ print "Hello, world!";  // Output: Hello, world!
 
 ```
 
+#### 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:
@@ -321,7 +358,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,10 +1,15 @@
 # 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_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')
@@ -158,6 +168,18 @@ module Loxxy
       return_first_child(range, tokens, theChildren) # Discard the semicolon
       end
 
+      # rule('varDecl' => 'VAR IDENTIFIER SEMICOLON')
+      def reduce_var_declaration(_production, _range, tokens, theChildren)
+        var_name = theChildren[1].token.lexeme.dup
+        Ast::LoxVarStmt.new(tokens[1].position, var_name, nil)
+      end
+
+      # rule('varDecl' => 'VAR IDENTIFIER EQUAL expression SEMICOLON')
+      def reduce_var_initialization(_production, _range, tokens, theChildren)
+        var_name = theChildren[1].token.lexeme.dup
+        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]
@@ -171,6 +193,18 @@ module Loxxy
         Ast::LoxPrintStmt.new(tokens[1].position, theChildren[1])
       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)
@@ -279,6 +313,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