loxxy 0.0.12 → 0.0.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7274fd2d139354b984962f9317cae890344e528540f2f157772e7395cdfd7d33
-  data.tar.gz: c1b38a4dfcb441c00604926cbaf397ab555624270ca647448d9cc4d4f463f500
+  metadata.gz: 6eed6a7de54b89c276b0f098cd7d824f26c0ce9ba957d4fb9e3a4d12e6dfbc4f
+  data.tar.gz: ba7c00f11c5b69322aec0d447c2fef9cf6d6d74b2ea7bb16096581508a786427
 SHA512:
-  metadata.gz: 27d5de6532213d1a995f86da84ccbd41a11b5f85c305e57a62f64637ad17852e622685e4261b1c62deb31c924bb8f8c29c4edd97e9776fabf7e0d06e5c302534
-  data.tar.gz: dab4a9e391c120c159a63e316f90065faf1415b54c9aa4c6f349f6be8e95de1289a2478f395e6b9e19b2e6f09482ae4db49a70e0d5d857eb5475cecad0590c69
+  metadata.gz: 1b2c3826f085ce3f723cdbc70c3bdc3563817270985a321db05f97ca1ff81971bf872db49631d3fa20580932f7a0e2910bf3c6c84daf7873cdcd1f04c3392a99
+  data.tar.gz: 4e3d075facaf9c370d78f3f3ac89b7226e375eb32064535e3401c5ef52b8ca43c9d4c6cfb8f027b4037c7baa7c5945b0fd0dbe1e8b1e580fc732c4a38f7c57c6

data/.rubocop.yml

@@ -250,7 +250,7 @@ Style/IfUnlessModifier:
   Enabled: false
 
 Style/InverseMethods:
-  Enabled: true
+  Enabled: false
 
 Style/MissingRespondToMissing:
   Enabled: false

data/CHANGELOG.md

@@ -1,3 +1,79 @@
+## [0.0.17] - 2021-01-12
+- The interpreter can evaluate all arithmetic and comparison operations.
+- It implements `==`, `!=` and the unary operations `!`, `-`
+
+## Added
+- Class `AST::LoxUnaryExpr`
+- Method `AST::ASTBuilder#reduce_unary_expr` to support the evaluation of `!` and ``-@`
+- Method `Ast::ASTVisitor#visit_unnary_expr` for visiting unary expressions
+- Method `Backend::Engine#after_unary_expr` evaluating an unary expression
+- In class `Datatype::BuiltinDatatype` the methods `falsey?`, `truthy?`, `!`, `!=`
+- In class `Datatype::Number`the methods `<`, `<=`, ´>´, `>=` and `-@`
+
+## Changed
+- File `README.md` updated.
+
+## [0.0.16] - 2021-01-11
+- The interpreter can evaluate product and division of two numbers.
+- It also implements equality `==` and inequality `!=` operators
+
+## Added
+- Method `Datatype::False#==` for equality testing
+- Method `Datatype::False#!=` for inequality testing
+- Method `Datatype::LXString#==` for equality testing
+- Method `Datatype::LXString#!=` for inequality testing
+- Method `Datatype::Nil#==` for equality testing
+- Method `Datatype::Nil#!=` for inequality testing
+- Method `Datatype::Number#==` for equality testing
+- Method `Datatype::Number#!=` for inequality testing
+- Method `Datatype::Number#*` for multiply operator
+- Method `Datatype::Number#/` for divide operator
+- Method `Datatype::True#==` for equality testing
+- Method `Datatype::True#!=` for inequality testing
+
+## Changed
+- Method `BackEnd::Engine#after_binary_expr` to allow `*`, `/`, `==`, `!=` operators
+- File `README.md` updated for the newly implemented operators
+
+## [0.0.15] - 2021-01-11
+- The interpreter can evaluate substraction between two numbers.
+
+## Added
+- Method `Datatype::Number#-` implmenting the subtraction operation
+
+## Changed
+- File `README.md` minor editorial changes.
+- File `lx_string_spec.rb` Added test for string concatentation
+- File `number_spec.rb` Added tests for addition and subtraction operations
+- File `interpreter_spec.rb` Added tests for subtraction operation
+
+## [0.0.14] - 2021-01-10
+- The interpreter can evaluate addition of numbers and string concatenation
+
+## Added
+- Method `Ast::ASTVisitor#visit_binary_expr` for visiting binary expressions
+- Method `Ast::LoxBinaryExpr#accept` for visitor pattern
+- Method `BackEnd::Engine#after_binary_expr` to trigger execution of binary operator
+- `Boolean` class hierarchy: added methos `true?` and `false?` to ease spec test writing
+- Method `Datatype::LXString#+` implementation of the string concatenation
+- Method `Datatype::Number#+` implementation of the addition of numbers
+
+## Changed
+- File `interpreter_spec.rb` Added tests for addition operation and string concatenation
+
+
+## [0.0.13] - 2021-01-10
+- The interpreter can evaluate directly simple literals.
+
+## Changed
+- Class `AST::ASTBuilder` added `reduce_exprStmt` to support the evaluation of literals.
+- File `README.md` added one more example.
+- File `parser_spec.rb` Updated the tests to reflect the change in the AST.
+- File `interpreter_spec.rb` Added a test for literal expression.
+
+## Fixed
+- File `loxxy.rb`: shorthand method `lox_true` referenced the ... false object (oops).
+
 ## [0.0.12] - 2021-01-09
 - Initial interpreter capable of evaluating a tiny subset of Lox language.
 

data/README.md

@@ -2,21 +2,56 @@
 [![Gem Version](https://badge.fury.io/rb/loxxy.svg)](https://badge.fury.io/rb/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?
 A Ruby implementation of the [Lox programming language](https://craftinginterpreters.com/the-lox-language.html ),
 a simple language used in Bob Nystrom's online book [Crafting Interpreters](https://craftinginterpreters.com/ ).
 
-## Purpose of this project:
+### Purpose of this project:
 - To deliver an open source example of a programming language fully implemented in Ruby  
-  (from the scanner, parser, code generation).
+  (from the scanner, parser, an interpreter).
 - The implementation should be mature enough to run [LoxLox](https://github.com/benhoyt/loxlox),  
   a Lox interpreter written in Lox.
 
-## Current status
-The project is still in inception and the interpreter is being implemented...
-Currently it can execute a very limited subset of __Lox__ language.
+### Current status
+The project is still in inception and the interpreter is being implemented...  
+Currently it can execute a tiny subset of __Lox__ language.
+
+But the __loxxy__ gem hosts also a parser class `RawPaser` that can parse, in principle, any valid Lox input.
+
+## 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.
+
+Although __Lox__ is fairly simple, it is far from a toy language:
+- Dynamically typed,
+- Provides datatypes such as booleans, number, strings,
+- Supports arithmetic operations (+, -, *, / ) and comparison ( >, >= , <, <=)
+- Implements equality operators (==, !=) and the logical connectors `and` and `or`.
+- Control flow statements `if`, `for` and `while`
+- Functions and closures
+- Object-orientation (classes, methods, inheritance).
+
+In other words, __Lox__ contains interesting features expected from most general-purpose 
+languages.
+
+### What's missing in Lox?
+__Lox__ was constrained by design and therefore was not aimed to be a language used in real-world applications.
+Here are some missing parts to make it a _practical_ language:
+- Collections (arrays, maps, ...)
+- Modules (importing stuff from other packages/files)
+- Error handling (e.g. exceptions)  
+- Support for concurrency (e.g. threads, coroutines)
+
+Also a decent standard library for IO, networking,... is lacking. 
 
-The __loxxy__ gem also a parser class `RawPaser` that can, in principle, any valid Lox input.
+For sure, the language has shortcomings but on the other hand, it exhibits the essential features 
+to cover in an introduction to language implementation.
+
+That's already fun... and if all this gives you the inspiration for creating your own
+language, that might be even funnier... 
+
+Last point: what's makes __Lox__ interesting is the fact that there are implementations in many [languages](https://github.com/munificent/craftinginterpreters/wiki/Lox-implementations)
 
 ## Hello world example
 ```ruby
@@ -28,7 +63,22 @@ lox_program = <<LOX_END
 LOX_END
 
 lox = Loxxy::Interpreter.new
-lox.evaluate(lox_program) # => Hello, world!
+lox.evaluate(lox_program) # Output: Hello, world!
+```
+
+## Retrieving the result from a Lox program
+The __Loxxy__ interpreter returns the value of the last evaluated expression. 
+
+```ruby
+require 'loxxy'
+
+lox = Loxxy::Interpreter.new
+
+lox_program = '47 - 5; // THE answer'
+result = lox.evaluate(lox_program) # => Loxxy::Datatype::Number
+
+# `result` is a Ruby object, so let's use it...
+puts result.value # Output: 42
 ```
 
 ## Example using RawParser class
@@ -81,11 +131,81 @@ program
 Although the interpreter should parse almost any valid Lox program,
 it currently can evaluate a tiny set of AST node (AST = Abstract Syntax Tree).
 
-Here are the language features supported by the interpreter:
-- Line comments,
-- All the Lox literals (booleans, numbers, strings and nil),
-- `print` statement.
+Here are the language features currently supported by the interpreter:
+
+- [Comments](#comments)
+- [Keywords](#keywords)
+- [Operators and Special Chars](#operators-and-special-chars)
+- [Datatypes](#datatypes)
+- [Statements](#statements)
+
+### Comments
 
+Loxxy supports single line C-style comments.
+
+```javascript
+// single line comment
+```
+
+### Keywords
+
+The parser knows all the __Lox__ reserved keywords:
+```lang-none
+and, class, else, false, fun, for, if, nil, or,
+print, return, super, this, true, var, while
+```
+Of these, the interpreter implements: `false`, `nil`, `print`, `true`
+
+### Operators and Special Chars
+#### Operators
+The __loxxy__ interpreter supports all the __Lox__ unary and binary operators:
+- Arithmetic operators: `+`, `-`, `*`, `/`
+- Comparison operators: `>`, `>=`, `<`, `<=`
+- Equality operators: `==`, `!=`
+- Unary negate (change sign): `-`
+- Unary not: `!`
+
+#### Delimiters
+The parser knows all the __Lox__ grouping delimiters:  
+(`, ), `{`, `}`
+
+These aren't yet implemented in the interpreter.
+
+The other characters that have a special meaning in __Lox__ are:
+- `,` Used in parameter list
+- `.` For the dot notation (i.e. calling a method)
+- `;` The semicolon is used to terminates expressions
+- `=` Assignment
+
+The parser recognizes them all but the interpreter accepts the semicolons only.
+
+### Datatypes
+
+loxxy supports  all the standard __Lox__ datatypes:
+- `Boolean`: Can be `true` or `false`
+- `Number`: Can be an integer or a floating-point numbers. For example: `123, 12.34, -45.67`
+- `String`: Sequence of characters surrounded by `"`. For example: `"Hello!"`
+- `Nil`: Used to define a null value, denoted by the `nil` keyword
+
+## Statements
+### Implemented expressions
+Loxxy implements expressions:
+- Plain literals only; or,
+- (In)equality testing between two values; or,   
+- Basic arithmetic operations (`+`, `-`, `*`, `/`, `unary -`); or,  
+- Comparison between two numbers; or,
+- Concatenation of two strings,
+- Negation `!`
+
+### Implemented statements
+Loxxy implements the following statements:
+- Expressions (see above sub-section)
+- Print statement
+
+```javascript
+// Print statement with nested string concatenation
+print "Hello" + ", " + "world!";
+```
 
 ## Installation
 
@@ -108,7 +228,6 @@ Or install it yourself as:
 TODO: Write usage instructions here
 
 ## Other Lox implementations in Ruby
-An impressive list of Lox implementations can be found [here](https://github.com/munificent/craftinginterpreters/wiki/Lox-implementations)
 
 For Ruby, there is the [lox](https://github.com/rdodson41/ruby-lox) gem.
 There are other Ruby-based projects as well:  

data/lib/loxxy.rb

@@ -7,13 +7,13 @@ require_relative 'loxxy/front_end/raw_parser'
 # Namespace for all classes and constants of __loxxy__ gem.
 module Loxxy
   class Error < StandardError; end
-  
+
   # Shorthand method. Returns the sole object that represents
   # a Lox false literal.
   # @return [Loxxy::Datatype::False]
   def self.lox_false
     Datatype::False.instance
-  end  
+  end
 
   # Shorthand method. Returns the sole object that represents
   # a Lox nil literal.
@@ -21,11 +21,11 @@ module Loxxy
   def self.lox_nil
     Datatype::Nil.instance
   end
-  
+
   # Shorthand method. Returns the sole object that represents
   # a Lox true literal.
   # @return [Loxxy::Datatype::True]
   def self.lox_true
-    Datatype::False.instance
-  end  
+    Datatype::True.instance
+  end
 end

data/lib/loxxy/ast/all_lox_nodes.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
-require_relative 'lox_print_stmt'
 require_relative 'lox_literal_expr'
 require_relative 'lox_noop_expr'
+require_relative 'lox_binary_expr'
+require_relative 'lox_unary_expr'
+require_relative 'lox_print_stmt'

data/lib/loxxy/ast/ast_builder.rb

@@ -15,7 +15,6 @@ module Loxxy
         # @return [Hash{String => String}]
         Name2special = {
           'AND' => 'and',
-          'BANG' => '!',
           'BANG_EQUAL' => '!=',
           'COMMA' =>  ',',
           'DOT' => '.',
@@ -36,6 +35,11 @@ module Loxxy
           'SLASH' =>  '/',
           'STAR' => '*'
         }.freeze
+
+        Name2unary = {
+          'BANG' => '!',
+          'MINUS' => '-@'
+        }.freeze
       end # defined
 
       attr_reader :strict
@@ -124,13 +128,18 @@ module Loxxy
       #####################################
 
       # rule('program' => 'EOF').as 'null_program'
-      def reduce_null_program(_production, range, _tokens, _theChildren)
+      def reduce_null_program(_production, _range, _tokens, _theChildren)
         Ast::LoxNoopExpr.new(tokens[0].position)
       end
 
       # rule('program' => 'declaration_plus EOF').as ''
       def reduce_lox_program(_production, range, tokens, theChildren)
-        return_first_child(range, tokens, theChildren)
+        return_first_child(range, tokens, theChildren) # Discard the semicolon
+      end
+
+      # rule('exprStmt' => 'expression SEMICOLON')
+      def reduce_exprStmt(_production, range, tokens, theChildren)
+      return_first_child(range, tokens, theChildren) # Discard the semicolon
       end
 
       # rule('printStmt' => 'PRINT expression SEMICOLON')
@@ -226,6 +235,13 @@ module Loxxy
         reduce_binary_plus_end(production, range, tokens, theChildren)
       end
 
+      # rule('unary' => 'unaryOp unary')
+      def reduce_unary_expr(_production, _range, tokens, theChildren)
+        operator = Name2unary[theChildren[0].symbol.name].to_sym
+        operand = theChildren[1]
+        LoxUnaryExpr.new(tokens[0].position, operator, operand)
+      end
+
       # rule('primary' => 'FALSE' | TRUE').as 'literal_expr'
       def reduce_literal_expr(_production, _range, _tokens, theChildren)
         first_child = theChildren.first

data/lib/loxxy/ast/ast_visitor.rb

@@ -51,7 +51,7 @@ module Loxxy
         broadcast(:after_ptree, aParseTree)
       end
 
-      # Visit event. The visitor is about to visit a print statement expression.
+      # Visit event. The visitor is about to visit a print statement.
       # @param aPrintStmt [AST::LOXPrintStmt] the print statement node to visit
       def visit_print_stmt(aPrintStmt)
         broadcast(:before_print_stmt, aPrintStmt)
@@ -59,6 +59,22 @@ module Loxxy
         broadcast(:after_print_stmt, aPrintStmt)
       end
 
+      # Visit event. The visitor is about to visit a binary expression.
+      # @param aBinaryExpr [AST::LOXBinaryExpr] the binary expression node to visit
+      def visit_binary_expr(aBinaryExpr)
+        broadcast(:before_binary_expr, aBinaryExpr)
+        traverse_subnodes(aBinaryExpr)
+        broadcast(:after_binary_expr, aBinaryExpr)
+      end
+
+      # Visit event. The visitor is about to visit an unary expression.
+      # @param anUnaryExpr [AST::anUnaryExpr] unary expression node to visit
+      def visit_unary_expr(anUnaryExpr)
+        broadcast(:before_unary_expr, anUnaryExpr)
+        traverse_subnodes(anUnaryExpr)
+        broadcast(:after_unary_expr, anUnaryExpr)
+      end
+
       # Visit event. The visitor is visiting the
       # given terminal node containing a datatype object.
       # @param aLiteralExpr [AST::LoxLiteralExpr] the leaf node to visit.

data/lib/loxxy/ast/lox_binary_expr.rb

@@ -5,7 +5,7 @@ require_relative 'lox_compound_expr'
 module Loxxy
   module Ast
     class LoxBinaryExpr < LoxCompoundExpr
-      # @return [Symbol]
+      # @return [Symbol] message name to be sent to receiver
       attr_reader :operator
 
       # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
@@ -16,6 +16,12 @@ 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
+
       alias operands subnodes
     end # class
   end # module

data/lib/loxxy/ast/lox_print_stmt.rb

@@ -11,7 +11,6 @@ module Loxxy
         super(aPosition, [anExpression])
       end
 
-      # Abstract method.
       # Part of the 'visitee' role in Visitor design pattern.
       # @param visitor [Ast::ASTVisitor] the visitor
       def accept(visitor)

data/lib/loxxy/ast/lox_unary_expr.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'lox_compound_expr'
+
+module Loxxy
+  module Ast
+    class LoxUnaryExpr < LoxCompoundExpr
+      # @return [Symbol] message name to be sent to receiver
+      attr_reader :operator
+
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      # @param operand [Loxxy::Ast::LoxNode]
+      def initialize(aPosition, anOperator, operand)
+        super(aPosition, [operand])
+        @operator = anOperator
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [Ast::ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_unary_expr(self)
+      end
+
+      alias operands subnodes
+    end # class
+  end # module
+end # module