loxxy 0.3.03 → 0.4.00

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 734fc040d2487c17abd8d89d4f3422e4d55db226ef79b354e52402fc24cd61fc
-  data.tar.gz: e799c5d1044159e9bfdc1b337c370e95878c85752dcaaf60578e71c4763a7da1
+  metadata.gz: 47c5d65fa1f3c2d0025013577f46edf741572df743d8986e238f49a08ea32702
+  data.tar.gz: 72a3beb6828362e6dc7c73072555ed6f87ed5bf57b4052ac55e06503b9582e29
 SHA512:
-  metadata.gz: d6d393729d977e6493979f4e89c664a1bba685b08c67a5e9e9b0d12354ac552deadae4e15a213560b752bdb9b44c7a05a5652fc8b4ed6500409fa04fe3cf29c1
-  data.tar.gz: f3b121e4a5ca07b4297aca8c43a3325b00dd30fb131f412a17a5e82d7887e8fc8749a2e1a422c75fe0c1045652970a121a78883b06c6bbc6baa6d896b0fea03f
+  metadata.gz: e83ee511c1ead4592153bb1e8ed8167439894bfefa2bb54060100eb9d221d77c453b4bad3d3e4a36209f3761812a5b9b0aa98b02a53556314c022d1f0b605bca
+  data.tar.gz: 8d939d7ff60687dd64c4dc6e4beccffa512e3483f5b38042a83fffbc0a5cc83d218999f855b8765a47e24b8c0df7808ecd649e70cec11832a0591b5c141a659c

data/CHANGELOG.md

@@ -1,12 +1,21 @@
-## [0.3.03] - 2021-05-23
-- Fixes in the location of an undefined variable. Rewrite of the scanning of lox string.
+## [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 `FrontEnd#Scanner` complete refactoring of String recognition.
+- Class `Ast::LoxClassStmt`is now a subclass of `LoxNode`
+
+- File `README.md` added an explanation on how to run `LoxLox`interpreter.
 
 ### Fixed
-- Method `Ast::AstBuilder#reduce_variable_expr` now associates the correct location of the variable.
+- 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_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/back_end/engine.rb

@@ -475,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/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: loxxy
 version: !ruby/object:Gem::Version
-  version: 0.3.03
+  version: 0.4.00
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-05-23 00:00:00.000000000 Z
+date: 2021-05-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley