loxxy 0.2.01 → 0.2.06

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3137f0d16bb2c3dbbc4e2036abbf45888ba06b863fef69a8682898ffdb2a146b
-  data.tar.gz: 344ff5f99e7d64dd45074aaacde5622ecb676d8d3112773555b0fbcffbd5aa89
+  metadata.gz: cbb2f24e245891baabf20458e5b663784ba7f82ff902ab7892007d9b53d99347
+  data.tar.gz: eab4ede6f48470449f731e3074b2ac2fe72b53449c9471231ea64d0007a873ae
 SHA512:
-  metadata.gz: f3cd447081d53619afeb040d9eade7fab0c0d5db79b8407fba412df727fb72849e5671679d7fd13fded703b9009399febfac6506ef91ac0bdd3220ef26472408
-  data.tar.gz: 4a83b84a9853787369d51f48d7c2eacfe8a7e58b4ab8cb5d5322b02e0a5de68c4481effa61587db70f066902d21c7b2a310509de74d13f2cf1476a490e2728a7
+  metadata.gz: 8037d3c239e39d47554c4e7f7698e5908cdaa5e460c8972fe8dc5b58ee5fd59647c413db95250ff739c08f9ca891c8f576eb8d78aa63cf40039e8d1b3328e9a2
+  data.tar.gz: 795face50a76140ba2f6be2e6e6c44e671992baaea2ecade980acf1baed173dc59cbe7cd2ce419b509e8593068ffc3e637e0678dab2db72a96250d4e53ef0338

data/CHANGELOG.md

@@ -1,3 +1,66 @@
+## [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.
+
+### Changed
+- File `loxxy` executable doesn't show a stack trace for scanner errors
+- Class `ScannerError` is now a subclass of `Loxxy::Error`
+- Class `Scanner` now returns a specific error message for unterminated strings
+- Class `Scanner` error messages are closer to the ones from jlox
+- Class `Scanner` supports now escape sequences \" for double quotes, \n for newlines
+- File `README.md` Reshuffled some text
+
 ## [0.2.01] - 2021-04-18
 - Minor improvements in CLI, starting re-documenting `README.md`.
 

data/README.md

@@ -3,7 +3,7 @@
 [![Build status](https://ci.appveyor.com/api/projects/status/8e5p7dgjanm0qjkp?svg=true)](https://ci.appveyor.com/project/famished-tiger/loxxy)
 [![License](https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat)](https://github.com/famished-tiger/loxxy/blob/main/LICENSE.txt)
 
-### What is loxxy?
+## What is loxxy?
 A Ruby implementation of the [Lox programming language](https://craftinginterpreters.com/the-lox-language.html ),
 a simple language defined in Bob Nystrom's excellent online book [Crafting Interpreters](https://craftinginterpreters.com/ ).
 
@@ -16,15 +16,34 @@ Although __Lox__ is fairly simple, it is far from being a toy language:
 - Functions and closures
 - Object-orientation (classes, methods, inheritance).
 
+### 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)
+- 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...
+
 ## 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
@@ -42,10 +61,11 @@ Lo and behold! The output device displays the famous greeting:
     Hello, world.
  
 
-Congrats! You ran your first `Lox` program with __Loxxy__.
+Congrats! You ran your first `Lox` program thanks __Loxxy__ gem. 
+For a less superficial encounter with the language jump to the next section.
 
-### Something beefier?...
-Let's admit it, the hello world example was unimpressive. 
+## So you want something beefier?...
+Let's admit it, the hello world example was unimpressive.   
 To a get a taste of `Lox` object-oriented capabilities, let's try another `Hello world` variant:
 
 ```javascript
@@ -172,12 +192,6 @@ Indeed, an open-source language that misses some features is an invitation for t
 There are already a number of programming languages derived from `Lox`...
 
 ## Why `Loxxy`? What's in it for me?...
-Features:
-- Complete tree-walking interpreter including lexer, parser and resolver
-- 100% pure Ruby with clean design (not a port from some other language)
-- Ruby API for integrating a Lox interpreter with your code.
-- Minimal runtime dependency (Rley gem). Won't drag a bunch of gems...
-
 
 ### Purpose of this project:
 - To deliver an open source example of a programming language fully implemented in Ruby  

data/bin/loxxy

@@ -17,11 +17,15 @@ class LoxxyRunner
     return if file_names.nil? || file_names.empty?
 
     lox = Loxxy::Interpreter.new
-    file_names.each do |lox_file|
-      fname = validate_filename(lox_file)
-      next unless file_exist?(fname)
-
-      File.open(fname, 'r') { |f| lox.evaluate(f.read) }
+    begin
+      file_names.each do |lox_file|
+        fname = validate_filename(lox_file)
+        next unless file_exist?(fname)
+
+        File.open(fname, 'r') { |f| lox.evaluate(f.read) }
+      end
+    rescue Loxxy::ScanError => e
+      $stderr.puts e.message
     end
   end
 

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