loxxy 0.3.01 → 0.4.01

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f6a77cf0f7f4cd0c445d597c534ecc1de82a31222d54a3d0da30330ccbcb216e
-  data.tar.gz: c10cab44247a3f7d75382c7a6bbfbc7938bce368ba14ea48878643ea7778aca5
+  metadata.gz: 03ef0a6b112537abbb890f56a5746a22be8aa9373451ce57a25d33ffd4cfe2be
+  data.tar.gz: 3abea4f9bfd799de85840c93a91aa37d0f9676b5e1d9af6a68bef7d189843470
 SHA512:
-  metadata.gz: 5f76a5a66ff5ecdc76207802e195c7becdaf214cb687f9a62be1b58dc56d3ea0a9b3320bb2b8a105a72e3ff79801e3065eb3c10cab6246de2a4a5e74f4ebb722
-  data.tar.gz: eafb0e81fa6c6b5c8c3c2a017907b14e3a4ebadd04ec51cb9d79030905562e86ecf37d9e68511ff52ab4ae45eb598f8c7de4fa6344f90034f21635b8f2c983ff
+  metadata.gz: 74a279e2033090d6f4df08f30e4e71cf3c34c29dff2d2400a066528b68e73b2019345a84cabfad59f0342f8ba0a0d2ebf47ce87ac2195223a9c68886febb6a72
+  data.tar.gz: 9e1c5ba2b8e88af10c198bcefdc8a791be2900df2ee71127df560f1bcbfa18f03bc4cf86d149cc475cf5392938e4d74bb769d4a80630c9a5c82e0da90c936135

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.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
+
+### New
+- Class `BackEnd::Engine` new built-in functions `getc`, `chr`, `exit`, and `print_error`
+
+### Changed
+- Class `Ast::LoxSetExpr` value to assign is now a distinct atrrbute instead of a subnode
+-  Class `BackEnd::Engine` two distinct stacks: one of expression evaluation, another for argument passing
+
+### Fixed
+- Class `BackEnd::LoxClass`: in some contexts the init method returned twice 'this'.
+- Method `LoxFunction#call` mismatch between deeply nested returns and environments
+
+
 ## [0.3.01] - 2021-05-08
 - Fix in `Scanner` class, added more tests in test suite.
 

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].subnodes[1].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].subnodes[1] : 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].subnodes << theChildren[3]
-          theChildren[0]
+        if theChildren[0]
+          set_expr = Ast::LoxSetExpr.new(tokens[1].position, theChildren[0].subnodes[0])
+          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.subnodes[1].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.subnodes[1] }
+        successors.unshift(theChildren[0])
       end
     end # class
   end # module