loxxy 0.0.19 → 0.0.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eced55bddfd7918cbc7aea8eff5f7ecd37aa88baa6e5a6f7350f5bd7606e99af
-  data.tar.gz: f9b8104a0f3a273466ff568a014e345437f4c568621828de8da44961fb52f0e5
+  metadata.gz: 6085bf18afb919e5ef4d327162470c9d5ca95dde67e00dce78bb26abd6563dec
+  data.tar.gz: f1c7732a34b6df2721c20d82404c6ce83bdc8a75b695e4bbe13c51f62d9ac371
 SHA512:
-  metadata.gz: d5b23defe380228bda4e32d9cb94909767fdc42242111f00be214bfbead6323a5e6acda0d78dcaf4e1c2e1fa7d13cd0363661af959a62b093bfcc50c34c290a0
-  data.tar.gz: 96a6a77824cd97b248ad6a78d66d4757c81549fa199021f446883d690f2702dbf4d9879950505d9aa54f45376bd7e6204be8b054e27b43a5576aca744be40047
+  metadata.gz: 7546a14b935700e5050411a7805c2b2d00ccfc99160e3241b512289a6cc1762df2f39b7c9845c6ffe7fb95f1412865ef373f5308c9cf333fd72e2025a4a17ed8
+  data.tar.gz: 3675956929831e52963759862e8f9d40e5ebd3df471dee87d82784c2d1230ce6057882368042c907741be1038d300b7c83c27ed4bb8d979f5efa2ac79eaa3b1a

data/CHANGELOG.md

@@ -1,16 +1,77 @@
-## [0.0.18] - 2021-01-14
+## [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
+- 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
+- Method `Engine::after_if_stmt` implementation of the control flow
+
+## [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
+- 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
@@ -20,7 +81,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
@@ -28,14 +89,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
@@ -49,17 +110,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
@@ -68,7 +129,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
@@ -76,79 +137,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.
@@ -156,7 +217,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.
@@ -164,31 +225,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,9 @@ 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)
 
 ### Comments
 
@@ -168,12 +170,16 @@ loxxy supports  all the standard __Lox__ datatypes:
 ### Statements
 
 Loxxy supports the following statements:  
--[Expressions](#expressions)  
+- [Expressions](#expressions)  
   -[Arithmetic expressions](#arithmetic-expressions)  
   -[String concatenation](#string-concatenation)  
   -[Comparison expressions](#comparison-expressions)  
   -[Logical expressions](#logical-expressions)  
   -[Grouping expressions](#grouping-expressions)  
+  -[Variable expressions and assignments](#variable-expressions)
+  
+-[Variable declarations](#var-statement)  
+-[If Statement](#if-statement)  
 -[Print Statement](#print-statement)
 
 #### Expressions
@@ -245,7 +251,7 @@ REMINDER: In __Lox__, `false` and `nil` are considered falsey, everything else i
   `!!true; // => true`  
   `!0; // => false`
 
-#####  Grouping expressions
+####  Grouping expressions
 Use parentheses `(` `)` for a better control in expression/operator precedence.
 
 ``` javascript
@@ -253,8 +259,61 @@ 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
+```
 
-#####  Print Statement
+#### If statement
+
+Based on a given condition, an if statement executes one of two statements:
+``` javascript
+if (condition) {
+print "then-branch";
+} else {
+print "else-branch";
+}
+```
+
+As for other languages, the `else` part is optional.
+##### Warning: nested `if`...`else`
+Call it a bug ... Nested `if` `else` control flow structure aren't yet supported by __Loxxy__.  
+The culprit has a name: [the dangling else](https://en.wikipedia.org/wiki/Dangling_else). 
+
+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 
+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.
+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.
+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...
+
+
+####  Print Statement
 
 The statement print + expression + ; prints the result of the expression to stdout.
 

data/lib/loxxy/ast/all_lox_nodes.rb

@@ -1,9 +1,14 @@
 # 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_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,11 +168,37 @@ 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]
+        then_stmt = theChildren[2]
+        else_stmt = theChildren[3]
+        LoxIfStmt.new(tokens[0].position, condition, then_stmt, else_stmt)
+      end
+
       # rule('printStmt' => 'PRINT expression SEMICOLON')
       def reduce_print_stmt(_production, _range, tokens, theChildren)
         Ast::LoxPrintStmt.new(tokens[1].position, theChildren[1])
       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)
@@ -271,6 +307,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