loxxy 0.0.24 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6085bf18afb919e5ef4d327162470c9d5ca95dde67e00dce78bb26abd6563dec
-  data.tar.gz: f1c7732a34b6df2721c20d82404c6ce83bdc8a75b695e4bbe13c51f62d9ac371
+  metadata.gz: 42a88690625576399255ae7fadd3ac6aee022fc8d56a8e10c1206b55eca207ab
+  data.tar.gz: 4042d268f199763405a264480765bbd5fe7aeaa998eb5e0a4353ae702c3bef2a
 SHA512:
-  metadata.gz: 7546a14b935700e5050411a7805c2b2d00ccfc99160e3241b512289a6cc1762df2f39b7c9845c6ffe7fb95f1412865ef373f5308c9cf333fd72e2025a4a17ed8
-  data.tar.gz: 3675956929831e52963759862e8f9d40e5ebd3df471dee87d82784c2d1230ce6057882368042c907741be1038d300b7c83c27ed4bb8d979f5efa2ac79eaa3b1a
+  metadata.gz: 21a6a82509ead9c0d9f38c6798147dda38c436d87b8800a33ca7027553631866ce4215f2eb90c482f3c5a9b0bb42e99b7868fca888b78fcf7eca67afcd7db756
+  data.tar.gz: 71b53af0df630894c0d45639a84f427f34c7b92a5092e07cea16bc3786af666be13b0035a13c07b2910c374c76caa009c3acdbd675f430c8f6e4b7951c2b68a7

data/CHANGELOG.md

@@ -1,3 +1,77 @@
+## [0.1.00] - 2021-02-20
+- Version number bumped, `Loxxy` supports function definitions
+
+### Added
+- Class `Ast::LoxFunStmt` a node that represents a function declaration
+- Method `Ast::ASTBuilder#reduce_fun_decl`
+- Method `Ast::ASTBuilder#reduce_function` creates a `LoxFunStmt` instance
+- Method `Ast::ASTBuilder#reduce_parameters_plus_more` for dealing with function parameters
+- Method `Ast::ASTBuilder#reduce_parameters_plus_end`
+- Method `Ast::ASTVisitor#visit_fun_stmt` for visiting an `Ast::LoxFunStmt` node
+- Method `Ast::LoxBlockStmt#empty?` returns true if the code block is empty
+- Method `BackEnd::Engine#after_fun_stmt`
+- Method `Backend::NativeFunction#call` 
+- Method `Backend::NativeFunction#to_str` 
+- Method `Backend::Function` implementation of a function object.
+
+### Changed
+- Method `BackEnd::Engine#after_call_expr`
+
+### Fixed
+- Fixed inconsistencies in documentation comments.
+
+## [0.0.28] - 2021-02-15
+- The interpreter implements function calls (to a native function).
+
+### Added
+- Class `Ast::LoxCallExpr` a node that represents a function call expression
+- Method `Ast::ASTBuilder#reduce_call_expr`
+- Method `Ast::ASTBuilder#reduce_refinement_plus_end`
+- Method `Ast::ASTBuilder#reduce_call_arglist` creates a `LoxCallExpr` node
+- Method `Ast::ASTBuilder#reduce_arguments_plus_more` builds the function argument array
+- Method `Ast::ASTVisitor#visit_call_expr` for visiting an `Ast::LoxCallExpr` node
+- Method `BackEnd::Engine#after_call_expr`implements the evaluation of a function call.
+- Method `BackEnd::Engine#after_for_stmt` implements most of the `for` control flow
+
+## [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.
 

data/README.md

@@ -14,9 +14,13 @@ a simple language used in Bob Nystrom's online book [Crafting Interpreters](http
 
 ### Current status
 The project is still in inception and the interpreter is being implemented...  
-Currently it can execute a tiny subset of __Lox__ language.
+Currently it can execute all allowed __Lox__ expressions and statement except:
+- Functions and closures,  
+- Classes and objects.
+
+These will be implemented soon.
+
 
-But the __loxxy__ gem hosts also a parser class `RawPaser` that can parse, in principle, any valid Lox input.
 
 ## What's the fuss about Lox?
 ... Nothing...  
@@ -131,7 +135,7 @@ program
 On one hand, the parser covers the complete Lox grammar and should therefore, in principle,
 parse any valid Lox program.
 
-On the other hand, the interpreter is under development and currently it can evaluate only a tiny subset of __Lox__.
+On the other hand, the interpreter is under development and currently it can evaluate only a subset of __Lox__.
 But the situation is changing almost daily, stay tuned...
 
 Here are the language features currently supported by the interpreter:
@@ -141,9 +145,12 @@ Here are the language features currently supported by the interpreter:
 - [Datatypes](#datatypes)
 - [Statements](#statements)  
   -[Expressions](#expressions)  
-- [Variable declarations](#var-statement)  
+- [Variable declarations](#var-statement) 
+- [For statement](#for-statement)  
 - [If Statement](#if-statement)   
 - [Print Statement](#print-statement)
+- [While Statement](#while-statement)  
+- [Block Statement](#block-statement)
 
 ### Comments
 
@@ -180,7 +187,9 @@ Loxxy supports the following statements:
   
 -[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
 
@@ -268,8 +277,6 @@ foo = "baz"; // Variable assignment
 print foo; // Output: baz
 ```
 
-
-
 #### Variable declarations
 ``` javascript
 var iAmAVariable = "my-initial-value";
@@ -277,6 +284,15 @@ var iAmNil; // __Lox__ initializes variables to nil by default;
 print iAmNil; // output: nil
 ```
 
+#### 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
 
 Based on a given condition, an if statement executes one of two statements:
@@ -297,20 +313,21 @@ The problem in a nutshell: in a nested if ... else ... statement like this:
 ``` javascript
 'if (true) if (false) print "bad"; else print "good";
 ```
-... there is an ambiguity. Indeed, according to the __Lox__ grammar, the `else` could be bound 
+... there is an ambiguity.  
+Indeed, according to the __Lox__ grammar, the `else` could be bound 
 either to the first `if` or to the second one.
 This ambiguity is usually lifted by applying an ad-hoc rule: an `else` is aways bound to the most 
 recent (rightmost) `if`.  
-Being a generic parsing library, `Rley` doesn't apply any of these supplemental rules.
+Being a generic parsing library, `Rley` doesn't apply any of these supplemental rules.  
 As a consequence,it complains about the found ambiguity and stops the parsing...
 Although `Rley` can cope with ambiguities, this requires the use of an advanced data structure
 called `Shared Packed Parse Forest (SPPF)`.
-SPPF are much more complex to handle than the `common` parse trees present in most compiler or interpreter books.
+SPPF are much more complex to handle than the "common" parse trees present in most compiler or interpreter books.
 Therefore, a future version of `Rley` will incorporate the capability to define disambuiguation rules.  
 
 In the meantime, the `Loxxy` will progress on other __Lox__ features like:
-- Variables,
 - Block structures...
+- Iteration structures (`for` and `while` loops)
 
 
 ####  Print Statement
@@ -322,6 +339,29 @@ print "Hello, world!";  // Output: Hello, world!
 
 ```
 
+####  While Statement
+
+``` javascript
+  var a = 1;
+  while (a < 10) {
+    print a;
+    a = a + 1;
+  } // Output: 123456789
+```
+
+#### Block Statement
+__Lox__ has code blocks.
+``` javascript
+var a = "outer";
+
+{
+  var a = "inner";
+  print a; // output: inner
+}
+
+print a; // output: outer
+```
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -344,7 +384,7 @@ TODO: Write usage instructions here
 
 ## Other Lox implementations in Ruby
 
-For Ruby, there is the [lox](https://github.com/rdodson41/ruby-lox) gem.
+For Ruby, there is the [lox](https://github.com/rdodson41/ruby-lox) gem.  
 There are other Ruby-based projects as well:  
 - [SlowLox](https://github.com/ArminKleinert/SlowLox), described as a "1-to-1 conversion of JLox to Ruby"
 - [rulox](https://github.com/LevitatingBusinessMan/rulox)

data/lib/loxxy/ast/all_lox_nodes.rb

@@ -1,14 +1,19 @@
 # frozen_string_literal: true
 
+require_relative 'lox_fun_stmt'
 require_relative 'lox_variable_expr'
 require_relative 'lox_literal_expr'
 require_relative 'lox_noop_expr'
+require_relative 'lox_call_expr'
 require_relative 'lox_grouping_expr'
 require_relative 'lox_unary_expr'
 require_relative 'lox_binary_expr'
 require_relative 'lox_logical_expr'
 require_relative 'lox_assign_expr'
+require_relative 'lox_block_stmt'
+require_relative 'lox_while_stmt'
 require_relative 'lox_print_stmt'
 require_relative 'lox_if_stmt'
+require_relative 'lox_for_stmt'
 require_relative 'lox_var_stmt'
 require_relative 'lox_seq_decl'

data/lib/loxxy/ast/ast_builder.rb

@@ -163,6 +163,11 @@ module Loxxy
         [theChildren[0]]
       end
 
+      # rule('funDecl' => 'FUN function')
+      def reduce_fun_decl(_production, _range, _tokens, theChildren)
+        theChildren[1]
+      end
+
       # rule('exprStmt' => 'expression SEMICOLON')
       def reduce_exprStmt(_production, range, tokens, theChildren)
       return_first_child(range, tokens, theChildren) # Discard the semicolon
@@ -180,6 +185,29 @@ module Loxxy
         Ast::LoxVarStmt.new(tokens[1].position, var_name, theChildren[3])
       end
 
+      # rule('forStmt' => 'FOR LEFT_PAREN forControl RIGHT_PAREN statement')
+      def reduce_for_stmt(_production, _range, _tokens, theChildren)
+        for_stmt = theChildren[2]
+        for_stmt.body_stmt = theChildren[4]
+        for_stmt
+      end
+
+      # rule('forControl' => 'forInitialization forTest forUpdate')
+      def reduce_for_control(_production, _range, tokens, theChildren)
+        (init, test, update) = theChildren
+        Ast::LoxForStmt.new(tokens[0].position, init, test, update)
+      end
+
+      # rule('forInitialization' => 'SEMICOLON')
+      def reduce_empty_for_initialization(_production, _range, _tokens, _theChildren)
+        nil
+      end
+
+      # rule('forTest' => 'expression_opt SEMICOLON')
+      def reduce_for_test(_production, range, tokens, theChildren)
+        return_first_child(range, tokens, theChildren)
+      end
+
       # rule('ifStmt' => 'IF ifCondition statement elsePart_opt')
       def reduce_if_stmt(_production, _range, tokens, theChildren)
         condition = theChildren[1]
@@ -193,105 +221,57 @@ module Loxxy
         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)
-      end
-
-      # rule('disjunct_plus' => 'disjunct_plus OR logic_and')
-      def reduce_logic_or_plus_more(production, range, tokens, theChildren)
-        reduce_binary_plus_more(production, range, tokens, theChildren)
-      end
-
-      # rule('disjunct_plus' => 'OR logic_and')
-      def reduce_logic_or_plus_end(production, range, tokens, theChildren)
-        reduce_binary_plus_end(production, range, tokens, theChildren)
-      end
-
-      # rule('logic_and' => 'equality conjunct_plus')
-      def reduce_logic_and_plus(production, range, tokens, theChildren)
-        reduce_logical_expr(production, range, tokens, theChildren)
-      end
-
-      # rule('conjunct_plus' => 'conjunct_plus AND equality')
-      def reduce_logic_and_plus_more(production, range, tokens, theChildren)
-        reduce_binary_plus_more(production, range, tokens, theChildren)
-      end
-
-      # rule('conjunct_plus' => 'AND equality')
-      def reduce_logic_and_plus_end(production, range, tokens, theChildren)
-        reduce_binary_plus_end(production, range, tokens, theChildren)
-      end
-
-      # rule('equality' => 'comparison equalityTest_plus')
-      def reduce_equality_plus(production, range, tokens, theChildren)
-        reduce_binary_operator(production, range, tokens, theChildren)
+      # 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('equalityTest_plus' => 'equalityTest_plus equalityTest comparison')
-      def reduce_equality_t_plus_more(production, range, tokens, theChildren)
-        reduce_binary_plus_more(production, range, tokens, theChildren)
+      # rule('block' => 'LEFT_BRACE declaration_plus RIGHT_BRACE')
+      def reduce_block_stmt(_production, _range, tokens, theChildren)
+        decls = LoxSeqDecl.new(tokens[1].position, theChildren[1])
+        Ast::LoxBlockStmt.new(tokens[1].position, decls)
       end
 
-      # rule('equalityTest_star' => 'equalityTest comparison')
-      def reduce_equality_t_plus_end(production, range, tokens, theChildren)
-        reduce_binary_plus_end(production, range, tokens, theChildren)
+      # rule('block' => 'LEFT_BRACE RIGHT_BRACE').as 'block_empty'
+      def reduce_block_empty(_production, _range, tokens, theChildren)
+        Ast::LoxBlockStmt.new(tokens[0].position, nil)
       end
 
-      # rule('comparison' => 'term comparisonTest_plus')
-      def reduce_comparison_plus(production, range, tokens, theChildren)
-        reduce_binary_operator(production, range, tokens, theChildren)
+      # rule('assignment' => 'owner_opt IDENTIFIER EQUAL assignment')
+      def reduce_assign_expr(_production, _range, tokens, theChildren)
+        var_name = theChildren[1].token.lexeme.dup
+        Ast::LoxAssignExpr.new(tokens[1].position, var_name, theChildren[3])
       end
 
       # rule('comparisonTest_plus' => 'comparisonTest_plus comparisonTest term').as 'comparison_t_plus_more'
       # TODO: is it meaningful to implement this rule?
 
-      # rule('comparisonTest_plus' => 'comparisonTest term')
-      def reduce_comparison_t_plus_end(production, range, tokens, theChildren)
-        reduce_binary_plus_end(production, range, tokens, theChildren)
-      end
-
-      # rule('term' => 'factor additive_plus')
-      def reduce_term_additive(production, range, tokens, theChildren)
-        reduce_binary_operator(production, range, tokens, theChildren)
-      end
-
-      # rule('additive_star' => 'additive_star additionOp factor').as 'additionOp_expr'
-      def reduce_additive_plus_more(production, range, tokens, theChildren)
-        reduce_binary_plus_more(production, range, tokens, theChildren)
-      end
-
-      # rule('additive_plus' => 'additionOp factor')
-      def reduce_additive_plus_end(production, range, tokens, theChildren)
-        reduce_binary_plus_end(production, range, tokens, theChildren)
+      # rule('unary' => 'unaryOp unary')
+      def reduce_unary_expr(_production, _range, tokens, theChildren)
+        operator = Name2unary[theChildren[0].symbol.name].to_sym
+        operand = theChildren[1]
+        LoxUnaryExpr.new(tokens[0].position, operator, operand)
       end
 
-      # rule('factor' => 'multiplicative_plus')
-      def reduce_factor_multiplicative(production, range, tokens, theChildren)
-        reduce_binary_operator(production, range, tokens, theChildren)
+      # rule('call' => 'primary refinement_plus').as 'call_expr'
+      def reduce_call_expr(_production, _range, _tokens, theChildren)
+        theChildren[1].callee = theChildren[0]
+        theChildren[1]
       end
 
-      # rule('multiplicative_plus' => 'multiplicative_plus multOp unary')
-      def reduce_multiplicative_plus_more(production, range, tokens, theChildren)
-        reduce_binary_plus_more(production, range, tokens, theChildren)
+      # rule('refinement_plus' => 'refinement').
+      def reduce_refinement_plus_end(_production, _range, _tokens, theChildren)
+        theChildren[0]
       end
 
-      # rule('multiplicative_plus' => 'multOp unary')
-      def reduce_multiplicative_plus_end(production, range, tokens, theChildren)
-        reduce_binary_plus_end(production, range, tokens, theChildren)
-      end
+      # rule('refinement' => 'LEFT_PAREN arguments_opt RIGHT_PAREN')
+      def reduce_call_arglist(_production, _range, tokens, theChildren)
+        args = theChildren[1] || []
+        if args.size > 255
+          raise StandardError, "Can't have more than 255 arguments."
+        end
 
-      # rule('unary' => 'unaryOp unary')
-      def reduce_unary_expr(_production, _range, tokens, theChildren)
-        operator = Name2unary[theChildren[0].symbol.name].to_sym
-        operand = theChildren[1]
-        LoxUnaryExpr.new(tokens[0].position, operator, operand)
+        LoxCallExpr.new(tokens[0].position, args)
       end
 
       # rule('primary' => 'LEFT_PAREN expression RIGHT_PAREN')
@@ -313,6 +293,33 @@ module Loxxy
         var_name = theChildren[0].token.lexeme
         LoxVariableExpr.new(tokens[0].position, var_name)
       end
+
+      # rule('function' => 'IDENTIFIER LEFT_PAREN params_opt RIGHT_PAREN block').as 'function'
+      def reduce_function(_production, _range, _tokens, theChildren)
+        first_child = theChildren.first
+        pos = first_child.token.position
+        fun_stmt = LoxFunStmt.new(pos, first_child.token.lexeme, theChildren[2], theChildren[4])
+      end
+
+      # rule('parameters' => 'parameters COMMA IDENTIFIER')
+      def reduce_parameters_plus_more(_production, _range, _tokens, theChildren)
+        theChildren[0] << theChildren[2].token.lexeme
+      end
+
+      # rule('parameters' => 'IDENTIFIER')
+      def reduce_parameters_plus_end(_production, _range, _tokens, theChildren)
+        [theChildren[0].token.lexeme]
+      end
+
+      # rule('arguments' => 'arguments COMMA expression')
+      def reduce_arguments_plus_more(_production, _range, _tokens, theChildren)
+        theChildren[0] << theChildren[2]
+      end
+
+      # rule('arguments' => 'expression')
+      def reduce_arguments_plus_end(_production, _range, _tokens, theChildren)
+        theChildren
+      end
     end # class
   end # module
 end # module