loxxy 0.3.02 → 0.4.02

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a0e398714d64763c288f06c315611c86bf3dae2e3403055ae3ca240a10bd292f
-  data.tar.gz: 8db95e837824181e1794277dc3e67e4005432006877124bbd62ffd07def57591
+  metadata.gz: e5a4313b7377778f23e130f599cb4d28d43fd4ff3d56ec2c93c9b9636ac04743
+  data.tar.gz: 17f543465f55d0e83e2145973522da4230d7162d72f81d54ea957ac1522be412
 SHA512:
-  metadata.gz: caf2aab9a8c03997fbde67467b7cb66a786c2fb8ef46fc24869c42ac7da76831f5e771a282c938ec83585666de801602ffc9818fc489454ec93dec9bd76bf5a7
-  data.tar.gz: 9d98db7d9bddec915929dc1cbaed057248ccb5e0cc63efc3d0d7e99536ea9b330925d91d6b1ffd6805194dc3805b0025228f66d11f11b5455cb8f52d7753e6eb
+  metadata.gz: 18ab688d47ee5d2b98ae1be44bba06740f9299d58b22cbe37b477d4a27624a0b7e3b0a761cde422993a8270d15df3c6113ee50876fb16b5d6a1b2d6e13ed4719
+  data.tar.gz: 5353f0cb4d853a15a3f5f156e19176d8c3e3a9e64bd186d53a9caec78edb4393e96b2be339634907bf2871a5a974f409d224b9de11a9940e24615fd2b55fb825

data/.rubocop.yml

@@ -50,6 +50,9 @@ Layout/IndentationConsistency:
 Layout/HeredocIndentation:
   Enabled: false
 
+Layout/LineEndStringConcatenationIndentation:
+  Enabled: true
+
 Layout/MultilineHashBraceLayout:
   Enabled: true
 
@@ -81,6 +84,9 @@ Layout/TrailingWhitespace:
 Lint/AmbiguousAssignment:
   Enabled: true
 
+Lint/AmbiguousRange:
+  Enabled: true
+
 Lint/DeprecatedConstants:
   Enabled: true
 
@@ -96,6 +102,9 @@ Lint/EmptyBlock:
 Lint/EmptyClass:
   Enabled: false
 
+Lint/EmptyInPattern:
+  Enabled: true
+
 Lint/LambdaWithoutLiteralBlock:
   Enabled: true
 
@@ -192,6 +201,9 @@ Naming/ClassAndModuleCamelCase:
 Naming/BlockParameterName:
   Enabled: true
 
+Naming/InclusiveLanguage:
+  Enabled: true
+
 Naming/MethodParameterName:
   Enabled: false
 
@@ -273,11 +285,17 @@ Style/HashTransformValues:
 Style/IfUnlessModifier:
   Enabled: false
 
+Style/InPatternThen:
+  Enabled: true
+
 Style/InverseMethods:
   Enabled: false
 
 Style/MissingRespondToMissing:
   Enabled: false
+  
+Style/MultilineInPatternThen:
+  Enabled: true  
 
 Style/NegatedIfElseCondition:
   Enabled: true
@@ -290,6 +308,9 @@ Style/NilLambda:
 
 Style/NumericLiterals:
   Enabled: false
+  
+Style/QuotedSymbols:
+  Enabled: true  
 
 Style/RaiseArgs:
   Enabled: true
@@ -302,6 +323,9 @@ Style/RedundantReturn:
 
 Style/RedundantSelf:
   Enabled: true
+  
+Style/RedundantSelfAssignmentBranch:
+  Enabled: true  
 
 Style/RegexpLiteral:
   Enabled: false

data/CHANGELOG.md

@@ -1,3 +1,45 @@
+## [0.4.02] - 2021-09-10
+- Fixes in`AST::AstBuilder` class to  cope with changes inRley 0.8.03
+
+### Changed
+- File `loxxy.gemspec` forced dependency to Rley 0.8.03
+
+### Fixed
+- Method `Ast::AstBuilder#reduce_class_naming` fixed access to `IDENTIFER` in (LESS IDENTIFER)?
+- Method `Ast::AstBuilder#reduce_var_declaration` fixed access to `expression` in (EQUAL expression)? 
+- Method `Ast::AstBuilder#reduce_assign_expr`fixed access to `call` in (call DOT)? 
+- Method `Ast::AstBuilder#reduce_parameters`fixed access to `IDENTIFIER` in (COMMA IDENTIFIER)* 
+- Method `Ast::AstBuilder#reduce_arguments`fixed access to `expression` in (COMMA expression)* 
+
+
+
+## [0.4.01] - 2021-08-22
+- Grammar and AST::AstBuilder adapted to take profit of extended grammar notiation in Rley 0.8.01
+
+### Changed
+- Class `Ast::ASTBuilder` removal of methods made redundant with new Rley version
+- File `.rubocop.yml` added config for new cops
+- File `grammar.rb` changed rules to use new extended rule syntax in Rley
+
+## [0.4.00] - 2021-05-24
+- Version bump. `Loxxy` is capable to run the LoxLox interpreter, an interpreter written in `Lox`.
+
+### New
+- Method `BackEnd::LoxInstance#falsey?` added
+- Method `BackEnd::LoxInstance#truthy?` added
+
+### Changed
+-  Method `BackEnd::Engine#after_variable_expr` the error message `Undefined variable` nows gives the location of the offending variable.
+- Class `Ast::LoxClassStmt`is now a subclass of `LoxNode`
+
+- File `README.md` added an explanation on how to run `LoxLox`interpreter.
+
+### Fixed
+- Method `Ast::LoxClassStmt#initialize` fixed inconsistencies in its Yard/RDoc documentation.
+- Method `Ast::LoxFunStmt#initialize` fixed inconsistencies in its Yard/RDoc documentation.
+- Method `BackEnd::Engine#native_getc` now returns -1 when its reaches EOF.
+- Method `BackEnd::Resolver#after_logical_expr` was missing and this caused the lack of resultation in the second operand.
+
 ## [0.3.02] - 2021-05-22
 - New built-in expressions `getc`, `chr`, `exit` and `print_eeror` , fixes with deeply nested returns, set expressions
 

data/README.md

@@ -19,7 +19,8 @@ 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  
+- Passes the `jox` (THE reference `Lox` implementation) test suite
+- Can run a Lox imterpreter implemented in ... `Lox` [LoxLox](https://github.com/benhoyt/loxlox),
 - 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`
@@ -53,6 +54,7 @@ And then execute:
 ### 2. Your first `Lox`  program
 Create a text file and enter the following lines:
 ```javascript
+// hello.lox
 // Your firs Lox program
 print "Hello, world.";
 ```
@@ -75,6 +77,7 @@ 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
+// oo_hello.lox
 // Object-oriented hello world
 class Greeter {
   // in Lox, initializers/constructors are named `init`
@@ -98,6 +101,7 @@ Our next assignment: compute the first 20 elements of the Fibbonacci sequence.
 Here's an answer using the `while` loop construct:
 
 ```javascript
+// fibbonacci.lox
 // Compute the first 20 elements from the Fibbonacci sequence
 
 var a = 0;  // Use the var keyword to declare a new variable
@@ -127,6 +131,7 @@ Fans of `for` loops will be pleased to find their favorite looping construct.
 Here again, the Fibbonacci sequence refactored with a `for` loop:
 
 ```javascript
+// fibbonacci_v2.lox
 // Fibbonacci sequence - version 2
 var a = 0;
 var b = 1;
@@ -169,13 +174,69 @@ for (var i = 0; i < count; i = i + 1) {
 }
 ```
 
+### Loxxy goes meta...
+The `Loxxy` is able to run the `LoxLox` interpreter.
+[LoxLox](https://github.com/benhoyt/loxlox) is a Lox interpreter written in Lox by Ben Hoyt.  
+This interpreter with over 1900 lines long is (one of) the longest Lox pragram.
+As such, it is a good testbed for any Lox interpreter.
+
+Executing a lox program with the LoxLox interpreter that is itself running on top of Loxxy.
+#### Step 1 Download `lox.lox´ file
+Download the [LoxLox](https://github.com/benhoyt/loxlox) source file in Github.
+
+#### Step 2 (alternative a): running from the command line
+
+```
+$ loxxy lox.lox
+```
+
+Once loxxy CLI starts its interpreter that, in turn, executes the LoxLox interpreter.
+This may take a couple of seconds.
+Don't be surprised, if the program seems unresponsive: it is waiting for you input.
+Enter a line like this:
+```
+  print "Hello, world!";
+```  
+Then terminate with an end of file (crtl-D on Linuxes, crtl-z on Windows) followed by an enter key.
+You should see the famous greeting.
+
+#### Step 2 (alternative b): launching the interpreter from Ruby snippet
+The following snippet executes the LoxLox interpreter and feeds to it the
+input text. That input text is made available through a StringIO that replaces
+the `$stdio` device.
+
+```ruby
+require 'stringio'
+require 'loxxy'
+
+# Place your Lox pragram within the heredoc
+program = <<-LOX_END
+  print "Hello, world!";
+LOX_END
+
+lox_filename = 'lox.lox'
+File.open(lox_filename, 'r') do |f|
+  source = f.read
+  cfg = { istream: StringIO.new(program, 'r')}
+  lox = Loxxy::Interpreter.new(cfg)
+  lox.evaluate(source)
+end
+```
+
+Save this snippet as a Ruby file, launch Ruby with this file in command line.
+After a couple of seconds, you'll see the Ruby interpreter that executes the 
+Loxxy interpreter that itself executes the LoxLox interpreter written in Lox.
+That last interpreter is the one that run the hello world line.
+
+That's definitively meta...
+
 This completes our quick tour of `Lox`, to learn more about the language,
 check the online book [Crafting Interpreters](https://craftinginterpreters.com/ )
 
 ## What's the fuss about Lox?
 ... Nothing...  
 Bob Nystrom designed a language __simple__ enough so that he could present
-two implementations (an interpreter, then a compiler) in one single book.
+two interpreter implementations (a tree-walking one, then a bytecode one) in one single book.
 
 In other words, __Lox__ contains interesting features found in most general-purpose
 languages. In addition to that, there are [numerous implementations](https://github.com/munificent/craftinginterpreters/wiki/Lox-implementations) in different languages 
@@ -202,14 +263,11 @@ There are already a number of programming languages derived from `Lox`...
 ### Purpose of this project:
 - To deliver an open source example of a programming language fully implemented in Ruby  
   (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.
   
 ### Roadmap
 - Extend the test suite
 - Improve the error handling  
 - Improve the documentation
-- Ability run the LoxLox interpreter
 
 ## Hello world example
 The next examples show how to use the interpreter directly from Ruby code.

data/lib/loxxy/ast/ast_builder.rb

@@ -143,63 +143,36 @@ module Loxxy
       #  SEMANTIC ACTIONS
       #####################################
 
-      # rule('program' => 'EOF').as 'null_program'
-      def reduce_null_program(_production, _range, _tokens, _theChildren)
-        Ast::LoxNoopExpr.new(tokens[0].position)
-      end
-
-      # rule('program' => 'declaration_plus EOF').as ''
+      # rule('program' => 'declaration+ EOF').as ''
       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]]
+        if theChildren[0].empty?
+          Ast::LoxNoopExpr.new(tokens[0].position)
+        else
+          LoxSeqDecl.new(tokens[0].position, theChildren[0])
+        end
       end
 
       # rule('classDecl' => 'CLASS classNaming class_body')
       def reduce_class_decl(_production, _range, _tokens, theChildren)
-        if theChildren[1].kind_of?(Array)
-          name = theChildren[1].first
-          parent = theChildren[1].last
-        else
-          name = theChildren[1]
-          parent = nil
-        end
+        name = theChildren[1].first
+        parent = theChildren[1].last
         Ast::LoxClassStmt.new(tokens[1].position, name, parent, theChildren[2])
       end
 
-      # rule('classNaming' => 'IDENTIFIER')
-      def reduce_class_name(_production, _range, _tokens, theChildren)
-        theChildren[0].token.lexeme
-      end
-
-      # rule('classNaming' => 'IDENTIFIER LESS IDENTIFIER')
-      def reduce_class_subclassing(_production, _range, _tokens, theChildren)
-        super_token = theChildren[2].token
-        super_var = LoxVariableExpr.new(super_token.position, super_token.lexeme)
+      # rule('classNaming' => 'IDENTIFIER (LESS IDENTIFIER)?')
+      def reduce_class_naming(_production, _range, _tokens, theChildren)
+        if theChildren[1].nil?
+          super_var = nil
+        else
+          super_token = theChildren[1].last.token
+          super_var = LoxVariableExpr.new(super_token.position, super_token.lexeme)
+        end
         [theChildren[0].token.lexeme, super_var]
       end
 
-      # rule('class_body' => 'LEFT_BRACE methods_opt RIGHT_BRACE')
+      # rule('class_body' => 'LEFT_BRACE function* RIGHT_BRACE')
       def reduce_class_body(_production, _range, _tokens, theChildren)
-        theChildren[1].nil? ? [] : theChildren[1]
-      end
-
-      # rule('method_plus' => 'method_plus function')
-      def reduce_method_plus_more(_production, _range, _tokens, theChildren)
-        theChildren[0] << theChildren[1]
-      end
-
-      # rule('method_plus' => 'function')
-      def reduce_method_plus_end(_production, _range, _tokens, theChildren)
-        theChildren
+        theChildren[1]
       end
 
       # rule('funDecl' => 'FUN function')
@@ -212,16 +185,11 @@ module Loxxy
       return_first_child(range, tokens, theChildren) # Discard the semicolon
       end
 
-      # rule('varDecl' => 'VAR IDENTIFIER SEMICOLON')
+      # rule('varDecl' => 'VAR IDENTIFIER (EQUAL expression)? 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])
+        init_val = theChildren[2] ? theChildren[2].last : nil
+        Ast::LoxVarStmt.new(tokens[1].position, var_name, init_val)
       end
 
       # rule('forStmt' => 'FOR LEFT_PAREN forControl RIGHT_PAREN statement')
@@ -248,7 +216,7 @@ module Loxxy
         for_stmt
       end
 
-      # rule('forControl' => 'forInitialization forTest forUpdate')
+      # rule('forControl' => 'forInitialization forTest expression?')
       def reduce_for_control(_production, _range, tokens, theChildren)
         (init, test, update) = theChildren
         if test.nil? && update
@@ -265,7 +233,7 @@ module Loxxy
         nil
       end
 
-      # rule('forTest' => 'expression_opt SEMICOLON')
+      # rule('forTest' => 'expression? SEMICOLON')
       def reduce_for_test(_production, range, tokens, theChildren)
         return_first_child(range, tokens, theChildren)
       end
@@ -292,7 +260,7 @@ module Loxxy
         Ast::LoxPrintStmt.new(tokens[1].position, theChildren[1])
       end
 
-      # rule('returnStmt' => 'RETURN expression_opt SEMICOLON')
+      # rule('returnStmt' => 'RETURN expression? SEMICOLON')
       def reduce_return_stmt(_production, _range, tokens, theChildren)
         Ast::LoxReturnStmt.new(tokens[1].position, theChildren[1])
       end
@@ -302,34 +270,31 @@ module Loxxy
         Ast::LoxWhileStmt.new(tokens[1].position, theChildren[2], theChildren[4])
       end
 
-      # rule('block' => 'LEFT_BRACE declaration_plus RIGHT_BRACE')
+      # rule('block' => 'LEFT_BRACE declaration* 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('block' => 'LEFT_BRACE RIGHT_BRACE').as 'block_empty'
-      def reduce_block_empty(_production, _range, tokens, _children)
-        Ast::LoxBlockStmt.new(tokens[0].position, nil)
+        decls = nil
+        if theChildren[1]
+          pos = tokens[1].position
+          decls = LoxSeqDecl.new(tokens[1].position, theChildren[1])
+        else
+          pos = tokens[0].position
+        end
+        Ast::LoxBlockStmt.new(pos, decls)
       end
 
-      # rule('assignment' => 'owner_opt IDENTIFIER EQUAL assignment')
+      # rule('assignment' => '(call DOT)? IDENTIFIER EQUAL assignment')
       def reduce_assign_expr(_production, _range, tokens, theChildren)
         name_assignee = theChildren[1].token.lexeme.dup
-        if theChildren[0].kind_of?(Ast::LoxSetExpr)
-          theChildren[0].property = name_assignee
-          theChildren[0].value = theChildren[3]
-          theChildren[0]
+        if theChildren[0]
+          set_expr = Ast::LoxSetExpr.new(tokens[1].position, theChildren[0].first)
+          set_expr.property = name_assignee
+          set_expr.value = theChildren[3]
+          set_expr
         else
           Ast::LoxAssignExpr.new(tokens[1].position, name_assignee, theChildren[3])
         end
       end
 
-      # rule('owner_opt' => 'call DOT')
-      def reduce_set_expr(_production, _range, tokens, theChildren)
-        Ast::LoxSetExpr.new(tokens[1].position, theChildren[0])
-      end
-
 
       # rule('comparisonTest_plus' => 'comparisonTest_plus comparisonTest term').as 'comparison_t_plus_more'
       # TODO: is it meaningful to implement this rule?
@@ -343,6 +308,7 @@ module Loxxy
 
       # rule('call' => 'primary refinement_plus').as 'call_expr'
       def reduce_call_expr(_production, _range, _tokens, theChildren)
+        # return theChildren[0] unless theChildren[1]
         members = theChildren.flatten
         call_expr = nil
         loop do
@@ -365,7 +331,7 @@ module Loxxy
         theChildren
       end
 
-      # rule('refinement' => 'LEFT_PAREN arguments_opt RIGHT_PAREN')
+      # rule('refinement' => 'LEFT_PAREN arguments? RIGHT_PAREN')
       def reduce_call_arglist(_production, _range, tokens, theChildren)
         args = theChildren[1] || []
         if args.size > 255
@@ -395,9 +361,10 @@ module Loxxy
       end
 
       # rule('primary' => 'IDENTIFIER')
-      def reduce_variable_expr(_production, _range, tokens, theChildren)
+      def reduce_variable_expr(_production, _range, _tokens, theChildren)
         var_name = theChildren[0].token.lexeme
-        LoxVariableExpr.new(tokens[0].position, var_name)
+        pos = theChildren[0].token.position
+        LoxVariableExpr.new(pos, var_name)
       end
 
       # rule('primary' => 'THIS')
@@ -421,24 +388,21 @@ module Loxxy
         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 (COMMA IDENTIFIER)*').as 'parameters'
+      def reduce_parameters(_production, _range, _tokens, theChildren)
+        first_lexeme = theChildren[0].token.lexeme
+        return [first_lexeme] unless theChildren[1]
 
-      # rule('parameters' => 'IDENTIFIER')
-      def reduce_parameters_plus_end(_production, _range, _tokens, theChildren)
-        [theChildren[0].token.lexeme]
+        successors = theChildren[1].map { |seq_node| seq_node.last.token.lexeme }
+        successors.unshift(first_lexeme)
       end
 
-      # rule('arguments' => 'arguments COMMA expression')
-      def reduce_arguments_plus_more(_production, _range, _tokens, theChildren)
-        theChildren[0] << theChildren[2]
-      end
+      # rule('arguments' => 'expression (COMMA expression)*')
+      def reduce_arguments(_production, _range, _tokens, theChildren)
+        return [theChildren[0]] unless theChildren[1]
 
-      # rule('arguments' => 'expression')
-      def reduce_arguments_plus_end(_production, _range, _tokens, theChildren)
-        theChildren
+        successors = theChildren[1].map { |seq_node| seq_node.last }
+        successors.unshift(theChildren[0])
       end
     end # class
   end # module

data/lib/loxxy/ast/ast_visitor.rb

@@ -71,7 +71,6 @@ module Loxxy
       # @param aClassStmt [AST::LOXClassStmt] the for statement node to visit
       def visit_class_stmt(aClassStmt)
         broadcast(:before_class_stmt, aClassStmt)
-        traverse_subnodes(aClassStmt) # The methods are visited here...
         broadcast(:after_class_stmt, aClassStmt, self)
       end
 

data/lib/loxxy/ast/lox_class_stmt.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
-require_relative 'lox_compound_expr'
+require_relative 'lox_node'
 
 module Loxxy
   module Ast
-    class LoxClassStmt < LoxCompoundExpr
+    # A parse tree node that represents a Lox class declaration.
+    class LoxClassStmt < LoxNode
       # @return [String] the class name
       attr_reader :name
 
@@ -14,11 +15,13 @@ module Loxxy
       # @return [Array<Ast::LoxFunStmt>] the methods
       attr_reader :body
 
+      # Constructor for a parse node that represents a Lox function declaration
       # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
-      # @param condExpr [Loxxy::Ast::LoxNode] iteration condition
-      # @param theBody [Array<Loxxy::Ast::LoxNode>]
+      # @param aName [String] the class name
+      # @param aSuperclassName [String] the super class name
+      # @param theMethods [Array<Loxxy::Ast::LoxFunStmt>] the methods
       def initialize(aPosition, aName, aSuperclassName, theMethods)
-        super(aPosition, [])
+        super(aPosition)
         @name = aName.dup
         @superclass = aSuperclassName
         @body = theMethods

data/lib/loxxy/ast/lox_fun_stmt.rb

@@ -4,17 +4,25 @@ require_relative 'lox_node'
 
 module Loxxy
   module Ast
-    # rubocop: disable Style/AccessorGrouping
+    # A parse tree node that represents a Lox function declaration.
     class LoxFunStmt < LoxNode
+      # @return [String] the function name
       attr_reader :name
+
+      # @return [Array<String>] the parameter names
       attr_reader :params
+
+      # @return [Ast::LoxBlockStmt] the parse tree representing the function's body
       attr_reader :body
+
+      # @return [Boolean] true if the function is a method
       attr_accessor :is_method
 
+      # Constructor for a parse node that represents a Lox function declaration
       # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
-      # @param aName [String]
-      # @param arguments [Array<String>]
-      # @param body [Ast::LoxBlockStmt]
+      # @param aName [String] the function name
+      # @param paramList [Array<String>] the parameter names
+      # @param aBody [Ast::LoxBlockStmt] the parse tree representing the function's body
       def initialize(aPosition, aName, paramList, aBody)
         super(aPosition)
         @name = aName.dup
@@ -25,6 +33,5 @@ module Loxxy
 
       define_accept # Add `accept` method as found in Visitor design pattern
     end # class
-    # rubocop: enable Style/AccessorGrouping
   end # module
 end # module

data/lib/loxxy/ast/lox_node.rb

@@ -11,7 +11,7 @@ module Loxxy
       # 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.
+      # @return [Rley::Lexical::Position] Position of the entry in the input stream.
       attr_reader :position
 
       # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.

data/lib/loxxy/back_end/engine.rb

@@ -326,7 +326,10 @@ module Loxxy
       def after_variable_expr(aVarExpr, aVisitor)
         var_name = aVarExpr.name
         var = variable_lookup(aVarExpr)
-        raise Loxxy::RuntimeError, "Undefined variable '#{var_name}'." unless var
+        unless var
+          pos = "line #{aVarExpr.position.line}:#{aVarExpr.position.column}"
+          raise Loxxy::RuntimeError, "[#{pos}] Undefined variable '#{var_name}'."
+        end
 
         var.value.accept(aVisitor) # Evaluate variable value then push on stack
       end
@@ -472,10 +475,12 @@ module Loxxy
       end
 
       # Read a single character and return the character code as an integer.
+      # LoxLox requires the end of input to be a negative number
       def native_getc
         proc do
           ch = @istream.getc
-          Datatype::Number.new(ch.codepoints[0])
+          val = ch ? ch.codepoints[0] : -1
+          Datatype::Number.new(val)
         end
       end
 

data/lib/loxxy/back_end/lox_instance.rb

@@ -22,8 +22,16 @@ module Loxxy
         @fields = {}
       end
 
-      def accept(_visitor)
-        engine.expr_stack.push self
+      # In Lox, only false and Nil have false value...
+      # @return [FalseClass]
+      def falsey?
+        false # Default implementation
+      end
+
+      # Any instance is truthy
+      # @return [TrueClass]
+      def truthy?
+        true # Default implementation
       end
 
       # Text representation of a Lox instance
@@ -31,6 +39,10 @@ module Loxxy
         "#{klass.to_str} instance"
       end
 
+      def accept(_visitor)
+        engine.expr_stack.push self
+      end
+
       # Look up the value of property with given name
       # aName [String] name of object property
       def get(aName)

data/lib/loxxy/back_end/resolver.rb

@@ -138,6 +138,11 @@ module Loxxy
         aSetExpr.object.accept(aVisitor)
       end
 
+      def after_logical_expr(aLogicalExpr, aVisitor)
+        # Force the visit of second operand (resolver should ignore shortcuts)
+        aLogicalExpr.operands.last.accept(aVisitor)
+      end
+
       # Variable expressions require their variables resolved
       def before_variable_expr(aVarExpr)
         var_name = aVarExpr.name

data/lib/loxxy/datatype/lx_string.rb

@@ -47,11 +47,10 @@ module Loxxy
 
       def validated_value(aValue)
         unless aValue.is_a?(String)
-          raise StandardError, "Invalid number value #{aValue}"
+          raise StandardError, "Invalid string value #{aValue}"
         end
 
-        # Remove double quotes delimiter
-        aValue.gsub(/(^")|("$)/, '')
+        aValue
       end
     end # class
   end # module

data/lib/loxxy/front_end/grammar.rb

@@ -7,9 +7,9 @@ module Loxxy
   module FrontEnd
     ########################################
     # Grammar for Lox language
-    # Authoritave grammar at:
+    # Authoritative grammar at:
     #   https://craftinginterpreters.com/appendix-i.html
-    builder = Rley::Syntax::GrammarBuilder.new do
+    builder = Rley::grammar_builder do
       # Punctuators, separators...
       add_terminals('LEFT_PAREN', 'RIGHT_PAREN', 'LEFT_BRACE', 'RIGHT_BRACE')
       add_terminals('COMMA', 'DOT', 'MINUS', 'PLUS')
@@ -26,30 +26,21 @@ module Loxxy
       add_terminals('EOF')
 
       # Top-level rule that matches an entire Lox program
-      rule('program' => 'EOF').as 'null_program'
-      rule('program' => 'declaration_plus EOF').as 'lox_program'
+      rule('program' => 'declaration* EOF').as 'lox_program'
 
       # Declarations: bind an identifier to something
-      rule('declaration_plus' => 'declaration_plus declaration').as 'declaration_plus_more'
-      rule('declaration_plus' => 'declaration').as 'declaration_plus_end'
       rule('declaration' => 'classDecl')
       rule('declaration' => 'funDecl')
       rule('declaration' => 'varDecl')
       rule('declaration' => 'stmt')
 
       rule('classDecl' => 'CLASS classNaming class_body').as 'class_decl'
-      rule('classNaming' => 'IDENTIFIER LESS IDENTIFIER').as 'class_subclassing'
-      rule('classNaming' => 'IDENTIFIER').as 'class_name'
-      rule('class_body' => 'LEFT_BRACE methods_opt RIGHT_BRACE').as 'class_body'
-      rule('methods_opt' => 'method_plus')
-      rule('methods_opt' => [])
-      rule('method_plus' => 'method_plus function').as 'method_plus_more'
-      rule('method_plus' => 'function').as 'method_plus_end'
+      rule('classNaming' => 'IDENTIFIER (LESS IDENTIFIER)?').as 'class_naming'
+      rule('class_body' => 'LEFT_BRACE function* RIGHT_BRACE').as 'class_body'
 
       rule('funDecl' => 'FUN function').as 'fun_decl'
 
-      rule('varDecl' => 'VAR IDENTIFIER SEMICOLON').as 'var_declaration'
-      rule('varDecl' => 'VAR IDENTIFIER EQUAL expression SEMICOLON').as 'var_initialization'
+      rule('varDecl' => 'VAR IDENTIFIER (EQUAL expression)? SEMICOLON').as 'var_declaration'
 
       # Statements: produce side effects, but don't introduce bindings
       rule('stmt' => 'statement')
@@ -65,12 +56,11 @@ module Loxxy
       rule('exprStmt' => 'expression SEMICOLON').as 'exprStmt'
 
       rule('forStmt' => 'FOR LEFT_PAREN forControl RIGHT_PAREN statement').as 'for_stmt'
-      rule('forControl' => 'forInitialization forTest forUpdate').as 'for_control'
+      rule('forControl' => 'forInitialization forTest expression?').as 'for_control'
       rule('forInitialization' => 'varDecl')
       rule('forInitialization' => 'exprStmt')
       rule('forInitialization' => 'SEMICOLON').as 'empty_for_initialization'
-      rule('forTest' => 'expression_opt SEMICOLON').as 'for_test'
-      rule('forUpdate' => 'expression_opt')
+      rule('forTest' => 'expression? SEMICOLON').as 'for_test'
 
       rule('ifStmt' => 'IF ifCondition statement ELSE statement').as 'if_else_stmt'
       rule('unbalancedStmt' => 'IF ifCondition stmt').as 'if_stmt'
@@ -78,19 +68,14 @@ module Loxxy
       rule('ifCondition' => 'LEFT_PAREN expression RIGHT_PAREN').as 'keep_symbol2'
 
       rule('printStmt' => 'PRINT expression SEMICOLON').as 'print_stmt'
-      rule('returnStmt' => 'RETURN expression_opt SEMICOLON').as 'return_stmt'
+      rule('returnStmt' => 'RETURN expression? SEMICOLON').as 'return_stmt'
       rule('whileStmt' => 'WHILE LEFT_PAREN expression RIGHT_PAREN statement').as 'while_stmt'
-      rule('block' => 'LEFT_BRACE declaration_plus RIGHT_BRACE').as 'block_stmt'
-      rule('block' => 'LEFT_BRACE RIGHT_BRACE').as 'block_empty'
+      rule('block' => 'LEFT_BRACE declaration* RIGHT_BRACE').as 'block_stmt'
 
       # Expressions: produce values
-      rule('expression_opt' => 'expression')
-      rule('expression_opt' => [])
       rule('expression' => 'assignment')
-      rule('assignment' => 'owner_opt IDENTIFIER EQUAL assignment').as 'assign_expr'
+      rule('assignment' => '(call DOT)? IDENTIFIER EQUAL assignment').as 'assign_expr'
       rule('assignment' => 'logic_or')
-      rule('owner_opt' => 'call DOT').as 'set_expr'
-      rule('owner_opt' => [])
       rule('logic_or' => 'logic_and')
       rule('logic_or' => 'logic_and disjunct_plus').as 'logical_expr'
       rule('disjunct_plus' => 'disjunct_plus OR logic_and').as 'binary_plus_more'
@@ -130,10 +115,8 @@ module Loxxy
       rule('unaryOp' => 'BANG')
       rule('unaryOp' => 'MINUS')
       rule('call' => 'primary')
-      rule('call' => 'primary refinement_plus').as 'call_expr'
-      rule('refinement_plus' => 'refinement_plus refinement').as 'refinement_plus_more'
-      rule('refinement_plus' => 'refinement').as 'refinement_plus_end'
-      rule('refinement' => 'LEFT_PAREN arguments_opt RIGHT_PAREN').as 'call_arglist'
+      rule('call' => 'primary refinement+').as 'call_expr'
+      rule('refinement' => 'LEFT_PAREN arguments? RIGHT_PAREN').as 'call_arglist'
       rule('refinement' => 'DOT IDENTIFIER').as 'get_expr'
       rule('primary' => 'TRUE').as 'literal_expr'
       rule('primary' => 'FALSE').as 'literal_expr'
@@ -146,15 +129,9 @@ module Loxxy
       rule('primary' => 'SUPER DOT IDENTIFIER').as 'super_expr'
 
       # Utility rules
-      rule('function' => 'IDENTIFIER LEFT_PAREN params_opt RIGHT_PAREN block').as 'function'
-      rule('params_opt' => 'parameters')
-      rule('params_opt' => [])
-      rule('parameters' => 'parameters COMMA IDENTIFIER').as 'parameters_plus_more'
-      rule('parameters' => 'IDENTIFIER').as 'parameters_plus_end'
-      rule('arguments_opt' => 'arguments')
-      rule('arguments_opt' => [])
-      rule('arguments' => 'arguments COMMA expression').as 'arguments_plus_more'
-      rule('arguments' => 'expression').as 'arguments_plus_end'
+      rule('function' => 'IDENTIFIER LEFT_PAREN parameters? RIGHT_PAREN block').as 'function'
+      rule('parameters' => 'IDENTIFIER (COMMA IDENTIFIER)*').as 'parameters'
+      rule('arguments' => 'expression (COMMA expression)*').as 'arguments'
     end
 
     unless defined?(Grammar)

data/lib/loxxy/front_end/scanner.rb

@@ -61,6 +61,20 @@ module Loxxy
         print return super this true var while
       ].map { |x| [x, x] }.to_h
 
+      # Single character that have a special meaning when escaped
+      # @return [{Char => String}]
+      @@escape_chars = {
+        ?a => "\a",
+        ?b => "\b",
+        ?e => "\e",
+        ?f => "\f",
+        ?n => "\n",
+        ?r => "\r",
+        ?s => "\s",
+        ?t => "\t",
+        ?v => "\v"
+      }.freeze
+
       # Constructor. Initialize a tokenizer for Lox input.
       # @param source [String] Lox text to tokenize.
       def initialize(source = nil)
@@ -104,18 +118,14 @@ module Loxxy
         elsif (lexeme = scanner.scan(/[!=><]=?/))
           # One or two special character tokens
           token = build_token(@@lexeme2name[lexeme], lexeme)
+        elsif scanner.scan(/"/) # Start of string detected...
+          token = build_string_token
         elsif (lexeme = scanner.scan(/\d+(?:\.\d+)?/))
           token = build_token('NUMBER', lexeme)
-        elsif (lexeme = scanner.scan(/"(?:\\"|[^"])*"/))
-          token = build_token('STRING', lexeme)
         elsif (lexeme = scanner.scan(/[a-zA-Z_][a-zA-Z_0-9]*/))
           keyw = @@keywords[lexeme]
           tok_type = keyw ? keyw.upcase : 'IDENTIFIER'
           token = build_token(tok_type, lexeme)
-        elsif scanner.scan(/"(?:\\"|[^"])*\z/)
-          # Error: unterminated string...
-          col = scanner.pos - @line_start + 1
-          raise ScanError, "Error: [line #{lineno}:#{col}]: Unterminated string."
         else # Unknown token
           col = scanner.pos - @line_start + 1
           _erroneous = curr_ch.nil? ? '' : scanner.scan(/./)
@@ -153,8 +163,6 @@ module Loxxy
             value = Datatype::Nil.instance
           when 'NUMBER'
             value = Datatype::Number.new(aLexeme)
-          when 'STRING'
-            value = Datatype::LXString.new(unescape_string(aLexeme))
           when 'TRUE'
             value = Datatype::True.instance
           else
@@ -164,27 +172,47 @@ module Loxxy
         return [value, symb]
       end
 
-      # Replace any sequence sequence by their "real" value.
-      def unescape_string(aText)
-        result = +''
-        previous = nil
-
-        aText.each_char do |ch|
-          if previous
-            if ch == ?n
-              result << "\n"
-            else
-              result << ch
-            end
-            previous = nil
-          elsif ch == '\\'
-            previous = ?\
+      # precondition: current position at leading quote
+      def build_string_token
+        scan_pos = scanner.pos
+        line = @lineno
+        column_start = scan_pos - @line_start
+        literal = +''
+        loop do
+          substr = scanner.scan(/[^"\\\r\n]*/)
+          if scanner.eos?
+            pos_start = "line #{line}:#{column_start}"
+            raise ScanError, "Error: [#{pos_start}]: Unterminated string."
           else
-            result << ch
+            literal << substr
+            special = scanner.scan(/["\\\r\n]/)
+            case special
+            when '"' # Terminating quote found
+              break
+            when "\r"
+              next_line
+              special << scanner.scan(/./) if scanner.match?(/\n/)
+              literal << special
+            when "\n"
+              next_line
+              literal << special
+            when '\\'
+              ch = scanner.scan(/./)
+              next unless ch
+
+              escaped = @@escape_chars[ch]
+              if escaped
+                literal << escaped
+              else
+                literal << ch
+              end
+            end
           end
         end
-
-        result
+        pos = Rley::Lexical::Position.new(line, column_start)
+        lox_string = Datatype::LXString.new(literal)
+        lexeme = scanner.string[scan_pos - 1..scanner.pos - 1]
+        Literal.new(lox_string, lexeme, 'STRING', pos)
       end
 
       # Skip non-significant whitespaces and comments.

data/lib/loxxy/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Loxxy
-  VERSION = '0.3.02'
+  VERSION = '0.4.02'
 end

data/loxxy.gemspec

@@ -48,7 +48,7 @@ Gem::Specification.new do |spec|
   DESCR_END
   spec.homepage      = 'https://github.com/famished-tiger/loxxy'
   spec.license       = 'MIT'
-  spec.required_ruby_version = '~> 2.4'
+  spec.required_ruby_version = '~> 2.5'
 
   spec.bindir        = 'bin'
   spec.executables   = ['loxxy']
@@ -58,7 +58,7 @@ Gem::Specification.new do |spec|
   PkgExtending.pkg_documentation(spec)
 
   # Runtime dependencies
-  spec.add_dependency 'rley', '~> 0.7.06'
+  spec.add_dependency 'rley', '~> 0.8.03'
 
   # Development dependencies
   spec.add_development_dependency 'bundler', '~> 2.0'

data/spec/front_end/raw_parser_spec.rb

@@ -26,7 +26,10 @@ module Loxxy
           #   program => declaration_star EOF
           #   where the declaration_star MUST be empty
           expect(aParseTree.root.symbol.name).to eq('program')
-          eof = aParseTree.root.subnodes.first
+          (decls, eof) = aParseTree.root.subnodes
+          expect(decls).to be_kind_of(Rley::PTree::NonTerminalNode)
+          expect(decls.symbol.name).to eq('declaration_star')
+          expect(decls.subnodes).to be_empty
           expect(eof).to be_kind_of(Rley::PTree::TerminalNode)
           expect(eof.symbol.name).to eq('EOF')
         end
@@ -73,8 +76,12 @@ LOX_END
           expect(root.symbol.name).to eq('program')
           (decls, eof) = root.subnodes
           expect(decls).to be_kind_of(Rley::PTree::NonTerminalNode)
-          expect(decls.symbol.name).to eq('declaration_plus')
-          stmt = decls.subnodes[0].subnodes[0]
+          expect(decls.symbol.name).to eq('declaration_star')
+          expect(decls.subnodes[0]).to be_kind_of(Rley::PTree::NonTerminalNode)
+          expect(decls.subnodes[0].symbol.name).to eq('declaration_star')
+          expect(decls.subnodes[1]).to be_kind_of(Rley::PTree::NonTerminalNode)
+          expect(decls.subnodes[1].symbol.name).to eq('declaration')
+          stmt = decls.subnodes[1].subnodes[0]
           expect(stmt).to be_kind_of(Rley::PTree::NonTerminalNode)
           expect(stmt.symbol.name).to eq('stmt')
           statement = stmt.subnodes[0]

data/spec/front_end/scanner_spec.rb

@@ -211,22 +211,25 @@ LOX_END
         end
 
         it 'should recognize escaped quotes' do
-          embedded_quotes = %q{she said: \"Hello\"}
-          result = subject.send(:unescape_string, embedded_quotes)
-          expect(result).to eq('she said: "Hello"')
+          embedded_quotes = %q{"she said: \"Hello\""}
+          subject.start_with(embedded_quotes)
+          result = subject.tokens[0]
+          expect(result.value).to eq('she said: "Hello"')
         end
 
         it 'should recognize escaped backslash' do
-          embedded_backslash = 'backslash>\\\\'
-          result = subject.send(:unescape_string, embedded_backslash)
-          expect(result).to eq('backslash>\\')
+          embedded_backslash = '"backslash>\\\\"'
+          subject.start_with(embedded_backslash)
+          result = subject.tokens[0]
+          expect(result.value).to eq('backslash>\\')
         end
 
         # rubocop: disable Style/StringConcatenation
         it 'should recognize newline escape sequence' do
-          embedded_newline = 'line1\\nline2'
-          result = subject.send(:unescape_string, embedded_newline)
-          expect(result).to eq('line1' + "\n" + 'line2')
+          embedded_newline = '"line1\\nline2"'
+          subject.start_with(embedded_newline)
+          result = subject.tokens[0]
+          expect(result.value).to eq('line1' + "\n" + 'line2')
         end
         # rubocop: enable Style/StringConcatenation
 
@@ -289,7 +292,7 @@ LOX_END
         it 'should complain if it finds an unterminated string' do
           subject.start_with('var a = "Unfinished;')
           err = Loxxy::ScanError
-          err_msg = 'Error: [line 1:21]: Unterminated string.'
+          err_msg = 'Error: [line 1:9]: Unterminated string.'
           expect { subject.tokens }.to raise_error(err, err_msg)
         end
 

data/spec/spec_helper.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'rspec' # Use the RSpec framework
-require 'loxxy'
+require_relative '../lib/loxxy'
 
 RSpec.configure do |config|
   # Enable flags like --only-failures and --next-failure

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: loxxy
 version: !ruby/object:Gem::Version
-  version: 0.3.02
+  version: 0.4.02
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-05-22 00:00:00.000000000 Z
+date: 2021-09-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.7.06
+        version: 0.8.03
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.7.06
+        version: 0.8.03
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -173,7 +173,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - "~>"
     - !ruby/object:Gem::Version
-      version: '2.4'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="