loxxy 0.2.02 → 0.3.00

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: afc822710c5023cdffd8eeb9e9316736f2b2d9ddb2d05e4c4e835dee9b9b4d8b
-  data.tar.gz: 5debd7264833555cc34c64586de96d4e811eef4ebebe25f6c42a0832dee8e433
+  metadata.gz: 231fc227cc66ebd0b4f47a00f9fe7260146d70e64cea3581df6cfc5c71937bef
+  data.tar.gz: cd8117dc8ae9b631ad0d7bef34ee972bdcaa8c758045637bae2f3ea0ed25bb79
 SHA512:
-  metadata.gz: d988772978387faa28692101e6b2dab580a93b6f5738ad9094faf22d8aed78aca68123982ff0a25d9b9029d4d27ef4f82788009b10942a14ce5dd9bd9f1e37a7
-  data.tar.gz: 711b3188b0dd14a9821eee5227ee0d574c60144b7be88a3f722d10b4506556fa864685659c7493acfd6d63c2cf82f8c0c6c36cc0431a57a2d476efe3b4bf7efd
+  metadata.gz: ca714bbd5fa4fcbae67548cdae0d8c43236b02f30adc45e939c0e1dcd3e6694471ea429f902d5e1a7335d4a4cf9779d167a9387b0f4f0732325bd31237630e8d
+  data.tar.gz: '008526b6d9a2e9f5cf27a68f796e53aa5312d67523a53d8c8682cf944ee6cd990adf3928a3af7fb66e056bca4fc6e45fc11119ffcab1dda4d41fb2ca1c1207be'

data/CHANGELOG.md

@@ -1,3 +1,62 @@
+## [0.3.00] - 2021-05-07
+- Milestone: `Loxxy` passes all reference test suite.
+
+### Fixed
+- Method `BackEdn::Resolver#before_variable_expr`: Standard `Lox` allows re-declaration of a variable at top-level scope 
+
+ 
+## [0.2.06] - 2021-05-04
+- Nearly passing the 'official' test suite, fixing non-compliant behavior, specialized exceptions for errors
+
+### New
+- Module `LoxFileTester` module that hosts methods that simplify the tests of `Lox` source file. 
+
+### Changed
+- Folder `test_suite` vastly reorganized. Sub-folder `baseline` contains spec files testing the `Lox` files from official implementation
+- Class `BackEnd::Engine` replaced most `StandardError` by `Loxxy::RuntimeError` exception.
+- Class `BackEnd::Resolver` replaced most `StandardError` by `Loxxy::RuntimeError` exception.
+- Method `Datatype::Number#/` now handles correctly expression like `0/0` (integer divide)
+
+### Fixed
+- `0/0` expression results in a ZeroDivisionError exception, in Lox this result to a NaN (Not a Number). Now, `Loxxy` is aligned to standard `Lox`
+- `FrontEnd::Scanner` now always treats expression like `-123` as the unary or binary minus operator applied to a positive number. 
+
+## [0.2.05] - 2021-04-26
+- `Loxxy` now transforms for loops into while loops (desugaring), fix in Scanner class
+
+### Changed
+- Method `Ast::ASTBuilder#reduce_for_stmt` converts 'for' loops into 'while' loops
+- Method `Ast::ASTBuilder#reduce_for_control takes care of case for(expr1;;expr2) now test expression is set to true
+
+### Fixed
+- Method `FrontEnd::Scanner#next_token` keyword recognition was case insensitive
+
+### Removed
+- Method `Ast::Visitor#visitor_for_stmt`
+- Method `BackEnd::Engine#after_for_stmt`
+- Method `BackEnd::Resolver#before_for_stmt`
+- Method `BackEnd::Resolver#after_for_stmt`
+
+
+## [0.2.04] - 2021-04-25
+- `Loxxy` passes the test suite for `for` statements
+
+### Fixed
+- Method `BackEnd::Engine#after_for_stmt` now a for(;;) executes the body once; a for without test will execute forever
+- Method `BackEnd::Resolver#after_for_stmt now accepts nil test expression
+
+## [0.2.03] - 2021-04-24
+- Fixes for the set (field) expressions, `accept` methods for AST nodes are meta-programmed 
+
+### New
+- Module `Ast::Visitee` provides the `define_accept` method that generate `accept` method with meta-programming
+
+### Fixed
+- Method `BackEnd::Engine#before_set_expr` methos method that ensure that the receiver is evaluated first, then the assigned value
+- Method `BackEnd::Engine#after_set_expr` now pushes the value assigned to the field also onto the stack
+- Class `BackEnd::Engine` a number of StnadardError exceptions are replaced by Loxxy::RuntimeError
+
+
 ## [0.2.02] - 2021-04-21
 - Improvements in the scanner class (escape sequence for quotes and newlines), error messages closer to jlox.
 

data/README.md

@@ -19,20 +19,37 @@ Although __Lox__ is fairly simple, it is far from being a toy language:
 ### Loxxy gem features
 - Complete tree-walking interpreter including lexer, parser and resolver
 - 100% pure Ruby with clean design (not a port from some other language)
+- Passes the `jox` (THE reference `Lox` implementation) test suite  
 - Minimal runtime dependency (Rley gem). Won't drag a bunch of gems...  
 - Ruby API for integrating a Lox interpreter with your code.
 - A command-line interpreter `loxxy`
-- Open for your language extensions
+- Open for your language extensions...
+
+### Why `Loxxy` ?
+- If programming languages are one of your subject interest...
+- ... and you wanted learn how to implement one in Ruby...
+- ... then `Loxxy` can help to understand and experiment in this rewarding craft.
 
 ## How to start in 1, 2, 3...?
 ... in less than 3 minutes...
 
 ### 1. Installing
-Install __Loxxy__ as a gem:
+__Loxxy__'s  installation is pretty standard:
 
 
     $ gem install loxxy
 
+Alternatively, you can install `loxxy` with Bundler.  
+Add this line to your application's Gemfile:
+
+    gem 'loxxy'
+
+And then execute:
+
+    $ bundle
+
+
+
 ### 2. Your first `Lox`  program
 Create a text file and enter the following lines:
 ```javascript

data/lib/loxxy/ast/all_lox_nodes.rb

@@ -19,7 +19,6 @@ require_relative 'lox_while_stmt'
 require_relative 'lox_return_stmt'
 require_relative 'lox_print_stmt'
 require_relative 'lox_if_stmt'
-require_relative 'lox_for_stmt'
 require_relative 'lox_var_stmt'
 require_relative 'lox_class_stmt'
 require_relative 'lox_seq_decl'

data/lib/loxxy/ast/ast_builder.rb

@@ -225,16 +225,39 @@ module Loxxy
       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]
+      def reduce_for_stmt(_production, _range, tokens, theChildren)
+        # Following 'Crafting Interpreters', we replace the for statement by a while loop
+        return theChildren[4] if theChildren[2].compact.empty? # for(;;) => execute body once
+
+        (init, test, update) = theChildren[2]
+        if update
+          new_body = LoxSeqDecl.new(tokens[0].position, [theChildren[4], update])
+          stmt = Ast::LoxBlockStmt.new(tokens[1].position, new_body)
+        else
+          stmt = theChildren[4]
+        end
+        while_stmt = Ast::LoxWhileStmt.new(tokens[0].position, test, stmt)
+
+        if init
+          block_body = LoxSeqDecl.new(tokens[0].position, [init, while_stmt])
+          for_stmt = Ast::LoxBlockStmt.new(tokens[1].position, block_body)
+        else
+          for_stmt = while_stmt
+        end
+
         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)
+        if test.nil? && update
+          # when test expr is nil but update expr is not, then force test to be true
+          test = LoxLiteralExpr.new(tokens[0].position, Datatype::True.instance)
+          [init, test, update]
+        else
+          theChildren
+        end
       end
 
       # rule('forInitialization' => 'SEMICOLON')

data/lib/loxxy/ast/ast_visitee.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Loxxy
+  module Ast
+    # Mix-in module that relies on meta-programming to add a method
+    # called `accept` to the host class (an AST node).
+    # That method fulfills the expected behavior of the `visitee` in
+    # the Visitor design pattern.
+    module ASTVisitee
+      # Convert the input string into a snake case string.
+      # Example: ClassExpr => class_expr
+      # @param aName [String] input name to convert
+      # @return [String] the name converted into snake case
+      def snake_case(aName)
+        converted = +''
+        down = false
+        aName.each_char do |ch|
+          lower = ch.downcase
+          if lower == ch
+            converted << ch
+            down = true
+          else
+            converted << '_' if down && converted[-1] != '_'
+            converted << lower
+            down = false
+          end
+        end
+
+        converted
+      end
+
+      # This method adds a method named `accept` that takes a visitor
+      # The visitor is expected to implement a method named:
+      # visit + class name (without the Lox prefix) in snake case
+      # Example: class name = LoxClassStmt => visit method = visit_class_stmt
+      def define_accept
+        return if instance_methods(false).include?(:accept)
+
+        base_name = name.split('::').last
+        name_suffix = snake_case(base_name).sub(/^lox/, '')
+        accept_body = <<-MTH_END
+          # Part of the 'visitee' role in Visitor design pattern.
+          # @param visitor [Ast::ASTVisitor] the visitor
+          def accept(aVisitor)
+            aVisitor.visit#{name_suffix}(self)
+          end
+        MTH_END
+
+        class_eval(accept_body)
+      end
+    end # module
+  end # module
+end # module

data/lib/loxxy/ast/ast_visitor.rb

@@ -75,14 +75,6 @@ module Loxxy
         broadcast(:after_class_stmt, aClassStmt, self)
       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)
@@ -111,7 +103,7 @@ module Loxxy
       # @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...
+        traverse_subnodes(aWhileStmt) if aWhileStmt.condition # The condition is visited/evaluated here...
         broadcast(:after_while_stmt, aWhileStmt, self)
       end
 
@@ -133,7 +125,7 @@ module Loxxy
 
       # @param aSetExpr [AST::LOXGetExpr] the get expression node to visit
       def visit_set_expr(aSetExpr)
-        broadcast(:before_set_expr, aSetExpr)
+        broadcast(:before_set_expr, aSetExpr, self)
         traverse_subnodes(aSetExpr)
         broadcast(:after_set_expr, aSetExpr, self)
       end

data/lib/loxxy/ast/lox_assign_expr.rb

@@ -17,11 +17,7 @@ module Loxxy
         @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
+      define_accept # Add `accept` method as found in Visitor design pattern
     end # class
   end # module
 end # module

data/lib/loxxy/ast/lox_binary_expr.rb

@@ -16,12 +16,7 @@ module Loxxy
         @operator = anOperator
       end
 
-      # Part of the 'visitee' role in Visitor design pattern.
-      # @param visitor [Ast::ASTVisitor] the visitor
-      def accept(visitor)
-        visitor.visit_binary_expr(self)
-      end
-
+      define_accept # Add `accept` method as found in Visitor design pattern
       alias operands subnodes
     end # class
   end # module

data/lib/loxxy/ast/lox_block_stmt.rb

@@ -15,11 +15,7 @@ module Loxxy
         subnodes.size == 1 && subnodes[0].nil?
       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
+      define_accept # Add `accept` method as found in Visitor design pattern
     end # class
   end # module
 end # module

data/lib/loxxy/ast/lox_call_expr.rb

@@ -15,11 +15,7 @@ module Loxxy
         @arguments = argList
       end
 
-      # Part of the 'visitee' role in Visitor design pattern.
-      # @param visitor [Ast::ASTVisitor] the visitor
-      def accept(visitor)
-        visitor.visit_call_expr(self)
-      end
+      define_accept # Add `accept` method as found in Visitor design pattern
     end # class
   end # module
 end # module

data/lib/loxxy/ast/lox_class_stmt.rb

@@ -24,11 +24,7 @@ module Loxxy
         @body = theMethods
       end
 
-      # Part of the 'visitee' role in Visitor design pattern.
-      # @param visitor [Ast::ASTVisitor] the visitor
-      def accept(visitor)
-        visitor.visit_class_stmt(self)
-      end
+      define_accept # Add `accept` method as found in Visitor design pattern
     end # class
   end # module
 end # module

data/lib/loxxy/ast/lox_fun_stmt.rb

@@ -23,11 +23,7 @@ module Loxxy
         @is_method = false
       end
 
-      # Part of the 'visitee' role in Visitor design pattern.
-      # @param visitor [Ast::ASTVisitor] the visitor
-      def accept(visitor)
-        visitor.visit_fun_stmt(self)
-      end
+      define_accept # Add `accept` method as found in Visitor design pattern
     end # class
     # rubocop: enable Style/AccessorGrouping
   end # module

data/lib/loxxy/ast/lox_get_expr.rb

@@ -18,12 +18,7 @@ module Loxxy
         @property = aPropertyName
       end
 
-      # Part of the 'visitee' role in Visitor design pattern.
-      # @param visitor [ASTVisitor] the visitor
-      def accept(visitor)
-        visitor.visit_get_expr(self)
-      end
-
+      define_accept # Add `accept` method as found in Visitor design pattern
       alias callee= object=
     end # class
   end # module

data/lib/loxxy/ast/lox_grouping_expr.rb

@@ -11,11 +11,7 @@ module Loxxy
         super(aPosition, [subExpr])
       end
 
-      # Part of the 'visitee' role in Visitor design pattern.
-      # @param visitor [Ast::ASTVisitor] the visitor
-      def accept(visitor)
-        visitor.visit_grouping_expr(self)
-      end
+      define_accept # Add `accept` method as found in Visitor design pattern
     end # class
   end # module
 end # module

data/lib/loxxy/ast/lox_if_stmt.rb

@@ -21,17 +21,13 @@ module Loxxy
         @else_stmt = elseStmt
       end
 
-      # Part of the 'visitee' role in Visitor design pattern.
-      # @param visitor [Ast::ASTVisitor] the visitor
-      def accept(visitor)
-        visitor.visit_if_stmt(self)
-      end
-
       # Accessor to the condition expression
       # @return [LoxNode]
       def condition
         subnodes[0]
       end
+
+      define_accept # Add `accept` method as found in Visitor design pattern
     end # class
   end # module
 end # module

data/lib/loxxy/ast/lox_literal_expr.rb

@@ -15,11 +15,7 @@ module Loxxy
         @literal = aLiteral
       end
 
-      # Part of the 'visitee' role in Visitor design pattern.
-      # @param visitor [ASTVisitor] the visitor
-      def accept(visitor)
-        visitor.visit_literal_expr(self)
-      end
+      define_accept # Add `accept` method as found in Visitor design pattern
     end # class
   end # module
 end # module

data/lib/loxxy/ast/lox_logical_expr.rb

@@ -16,12 +16,7 @@ module Loxxy
         @operator = anOperator
       end
 
-      # Part of the 'visitee' role in Visitor design pattern.
-      # @param visitor [Ast::ASTVisitor] the visitor
-      def accept(visitor)
-        visitor.visit_logical_expr(self)
-      end
-
+      define_accept # Add `accept` method as found in Visitor design pattern
       alias operands subnodes
     end # class
   end # module

data/lib/loxxy/ast/lox_node.rb

@@ -1,8 +1,16 @@
 # frozen_string_literal: true
 
+require_relative 'ast_visitee'
+
 module Loxxy
   module Ast
+    # Abstract class.
+    # Instances of its subclasses represent nodes of an abstract syntax tree
+    # that is the product of the parse of an input text.
     class LoxNode
+      # Let nodes take `visitee` role as defined in the Visitor design pattern
+      extend ASTVisitee
+
       # return [Rley::Lexical::Position] Position of the entry in the input stream.
       attr_reader :position
 
@@ -16,7 +24,7 @@ module Loxxy
         # Default: do nothing ...
       end
 
-      # Abstract method.
+      # Abstract method (must be overriden in subclasses).
       # Part of the 'visitee' role in Visitor design pattern.
       # @param _visitor [LoxxyTreeVisitor] the visitor
       def accept(_visitor)