loxxy 0.0.8 → 0.0.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ed8bad2906a9ffd76c81a1fe14d89088f913f84996f0a6d98e7f104e0eccfdc9
-  data.tar.gz: 40ee48dc0f4d7e0ce1028820b9c5cf56d0c78d9853916f3bf9e5f32a7106887a
+  metadata.gz: e689f37b8b4893aff00f320707982cc1b09c17258abee50d0ae82f2d9d9d04db
+  data.tar.gz: 57aa5e505c245cabd8f4e583a6300dbd5071b9ba580228103c4f9972c7679174
 SHA512:
-  metadata.gz: 69c3c6e6b2a60c3f27284be820ac8f2687de0073c28719bd9414578ab37ac59de267dc1e69897966fef33d4ba725597587fe991b8e20ce6d40ec1587f3aa53c4
-  data.tar.gz: c296dcedcf97fe7426a59cfb2df2144685f2809c64becb18483e62a5aea536c2ca3ae2ab697b865c0945456e191a0a011f01123d34160acfa554761b8a2f917e
+  metadata.gz: 9336292545bd83f18d8f1be0a820717dcbe33cbb3b912697ea3e5245b726a5d79810ca6613c07017aef9d766670008bf49f59f6948922f18433db4a0df94f41e
+  data.tar.gz: 149d09683e80f1d36a1939cfa13faefb1fc2bdae3b096bbde34d8824f67a305627018229e453b7b9655c78ae45b815726535a307125d238f6399df2c3d0f1aec

data/CHANGELOG.md

@@ -1,8 +1,64 @@
+## [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.
+
+## Added
+- Class `AST::LoxNoopExpr`
+- Class `AST::LoxPrintStmt`
+- Class `BackEnd::Engine` implementation of the print statement logic
+- Class `Interpreter`
+
+## Changed
+- Class `Ast::ASTVisitor` Added visit method
+- File `README.md` added Hello world example.
+
+## [0.0.11] - 2021-01-08
+- AST node generation for logical expression (and, or).
+
+## Changed
+- Class `AST::ASTBuilder` added `reduce_` methods for logical operations.
+- File `grammar.rb`added name to logical expression rules
+- File `README.md` added gem version and license badges, expanded roadmap section.
+
+## Fixed
+- File `grammar.rb`: a rule had incomplete non-terminal name `conjunct_` in its lhs.
+
+
+## [0.0.10] - 2021-01-08
+- AST node generation for equality expression.
+
+## Changed
+- Class `AST::ASTBuilder` refactoring and added `reduce_` methods for equality operations.
+- File `grammar.rb`added name to equality rules
+- File `README.md` added gem version and license badges, expanded roadmap section.
+
+## Fixed
+- File `grammar.rb`: a rule had still the discarded non-terminal `equalityTest_star` in its lhs.
+
+## [0.0.9] - 2021-01-07
+- AST node generation for comparison expression.
+
+## Changed
+- Class `AST::ASTBuilder` added `reduce_` methods for comparison operations.
+- File `grammar.rb`added name to comparison rules
+
 ## [0.0.8] - 2021-01-07
 - AST node generation for arithmetic operations of number literals.
 
 ## Changed
 - Class `AST::ASTBuilder` added `reduce_` methods for arithmetic operations.
+- File `grammar.rb`added name to arithmetic rules
 
 ## Fixed
 - File `grammar.rb`: second rule for `factor` had a missing member in rhs.

data/README.md

@@ -1,31 +1,87 @@
-# Loxxy
+# loxxy
+[![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)
+
 
 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).
-- The implementation should be mature enough to run (LoxLox)[https://github.com/benhoyt/loxlox],  
+  (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 __loxxy__ gem hosts two distinct parsers classes (`RawParser` and `Parser`).
-- A `RawParser` instance is able to recognize valid Lox input and to generate
-  a concrete parse tree from it.
-- A `Parser` instance can also parse Lox source code but will generate an AST
-  (Abstract Syntax Tree) that will be used by the future tree-walking interpreter.
-  Currently it generates AST for arithmetic expressions with literal numbers only.
-
-## Roadmap
-- [DONE] Scanner (tokenizer)
-- [DONE] Raw parser. It parses Lox programs and generates a parse tree.
-- [DONE] Tailored parser for generating AST (Abstract Syntax Tree)
-- [STARTED] Custom AST builder class  
-- [STARTED] Hierarchy classes for representing Lox expressions in AST  
-- [TODO] Interpreter or transpiler
+### Current status
+The project is still in inception and the interpreter is being implemented...  
+Currently it can execute a tiny subset of __Lox__ language.
+
+The __loxxy__ gem 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. 
+
+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
+require 'loxxy'
+
+lox_program = <<LOX_END
+  // Your first Lox program!
+  print "Hello, world!";
+LOX_END
+
+lox = Loxxy::Interpreter.new
+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 = '12.34; // A fractional number'
+result = lox.evaluate(lox_program) # => Loxxy::Datatype::Number
+
+puts result.value # Output: 12.34
+```
 
 ## Example using RawParser class
+
 ```ruby
 require 'loxxy'
 
@@ -70,6 +126,16 @@ program
 +-- EOF: ''
 ```
 
+## Suppported Lox language features
+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.
+
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -91,7 +157,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

@@ -1,10 +1,31 @@
 # frozen_string_literal: true
 
 require_relative 'loxxy/version'
+require_relative 'loxxy/interpreter'
 require_relative 'loxxy/front_end/raw_parser'
-require_relative 'loxxy/front_end/parser'
 
+# Namespace for all classes and constants of __loxxy__ gem.
 module Loxxy
   class Error < StandardError; end
-  # Your code goes here...
+
+  # Shorthand method. Returns the sole object that represents
+  # a Lox false literal.
+  # @return [Loxxy::Datatype::False]
+  def self.lox_false
+    Datatype::False.instance
+  end
+
+  # Shorthand method. Returns the sole object that represents
+  # a Lox nil literal.
+  # @return [Loxxy::Datatype::Nil]
+  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::True.instance
+  end
 end

data/lib/loxxy/ast/all_lox_nodes.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative 'lox_print_stmt'
+require_relative 'lox_literal_expr'
+require_relative 'lox_noop_expr'

data/lib/loxxy/ast/ast_builder.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../datatype/all_datatypes'
-require_relative 'lox_literal_expr'
+require_relative 'all_lox_nodes'
 require_relative 'lox_binary_expr'
 
 module Loxxy
@@ -10,13 +10,33 @@ module Loxxy
     # (Abstract Syntax Tree) from a sequence of input tokens and
     # visit events produced by walking over a GFGParsing object.
     class ASTBuilder < Rley::ParseRep::ASTBaseBuilder
-      # Terminal2NodeClass = {
-      #   'FALSE' => Datatype::False,
-      #   'NIL' => Datatype::Nil,
-      #   'NUMBER' => Datatype::Number,
-      #   'STRING' => Datatype::LXString,
-      #   'TRUE' => Datatype::True
-      # }.freeze
+      unless defined?(Name2special)
+        # Mapping Token name => operator | separator | delimiter characters
+        # @return [Hash{String => String}]
+        Name2special = {
+          'AND' => 'and',
+          'BANG' => '!',
+          'BANG_EQUAL' => '!=',
+          'COMMA' =>  ',',
+          'DOT' => '.',
+          'EQUAL' => '=',
+          'EQUAL_EQUAL' => '==',
+          'GREATER' => '>',
+          'GREATER_EQUAL' => '>=',
+          'LEFT_BRACE' =>  '{',
+          'LEFT_PAREN' => '(',
+          'LESS' => '<',
+          'LESS_EQUAL' => '<=',
+          'MINUS' => '-',
+          'OR' => 'or',
+          'PLUS' => '+',
+          'RIGHT_BRACE' => '}',
+          'RIGHT_PAREN' => ')',
+          'SEMICOLON' => ';',
+          'SLASH' =>  '/',
+          'STAR' => '*'
+        }.freeze
+      end # defined
 
       attr_reader :strict
 
@@ -72,11 +92,11 @@ module Loxxy
         node
       end
 
-      # rule('term' => 'factor additive_plus')
-      def reduce_term_additive(_production, _range, tokens, theChildren)
+      # rule('lhs' => 'nonterm_i nonterm_k_plus')
+      def reduce_binary_operator(_production, _range, tokens, theChildren)
         operand1 = theChildren[0]
 
-        # Second child is anray with couples [operator, operand2]
+        # Second child is array with couples [operator, operand2]
         theChildren[1].each do |(operator, operand2)|
           operand1 = LoxBinaryExpr.new(tokens[0].position, operator, operand1, operand2)
         end
@@ -84,46 +104,131 @@ module Loxxy
         operand1
       end
 
-      # rule('additive_star' => 'additive_star additionOp factor').as 'additionOp_expr'
-      def reduce_additive_plus_more(_production, _range, _tokens, theChildren)
+      # rule('something_plus' => 'something_plus operator symbol')
+      def reduce_binary_plus_more(_production, _range, _tokens, theChildren)
         result = theChildren[0]
-        operator = theChildren[1].symbol.name == 'MINUS' ? :- : :+
+        operator = Name2special[theChildren[1].symbol.name].to_sym
         operand2 = theChildren[2]
         result << [operator, operand2]
       end
 
-      # rule('additive_plus' => 'additionOp factor')
-      def reduce_additive_plus_end(_production, _range, _tokens, theChildren)
-        operator = theChildren[0].symbol.name == 'MINUS' ? :- : :+
+      # rule('something_plus' => 'something_plus symbol')
+      def reduce_binary_plus_end(_production, _range, _tokens, theChildren)
+        operator = Name2special[theChildren[0].symbol.name].to_sym
         operand2 = theChildren[1]
         [[operator, operand2]]
       end
 
-      # rule('factor' => 'multiplicative_plus')
-      def reduce_factor_multiplicative(_production, _range, tokens, theChildren)
-        operand1 = theChildren[0]
+      #####################################
+      #  SEMANTIC ACTIONS
+      #####################################
 
-        # Second child is anray with couples [operator, operand2]
-        theChildren[1].each do |(operator, operand2)|
-          operand1 = LoxBinaryExpr.new(tokens[0].position, operator, operand1, operand2)
-        end
+      # rule('program' => 'EOF').as 'null_program'
+      def reduce_null_program(_production, _range, _tokens, _theChildren)
+        Ast::LoxNoopExpr.new(tokens[0].position)
+      end
 
-        operand1
+      # rule('program' => 'declaration_plus EOF').as ''
+      def reduce_lox_program(_production, 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')
+      def reduce_print_stmt(_production, _range, tokens, theChildren)
+        Ast::LoxPrintStmt.new(tokens[1].position, theChildren[1])
+      end
+
+      # rule('logic_or' => 'logic_and disjunct_plus')
+      def reduce_logic_or_plus(production, range, tokens, theChildren)
+        reduce_binary_operator(production, range, tokens, theChildren)
+      end
+
+      # rule('disjunct_plus' => 'disjunct_plus OR logic_and')
+      def reduce_logic_or_plus_more(production, range, tokens, theChildren)
+        reduce_binary_plus_more(production, range, tokens, theChildren)
+      end
+
+      # rule('disjunct_plus' => 'OR logic_and')
+      def reduce_logic_or_plus_end(production, range, tokens, theChildren)
+        reduce_binary_plus_end(production, range, tokens, theChildren)
+      end
+
+      # rule('logic_and' => 'equality conjunct_plus')
+      def reduce_logic_and_plus(production, range, tokens, theChildren)
+        reduce_binary_operator(production, range, tokens, theChildren)
+      end
+
+      # rule('conjunct_plus' => 'conjunct_plus AND equality')
+      def reduce_logic_and_plus_more(production, range, tokens, theChildren)
+        reduce_binary_plus_more(production, range, tokens, theChildren)
+      end
+
+      # rule('conjunct_plus' => 'AND equality')
+      def reduce_logic_and_plus_end(production, range, tokens, theChildren)
+        reduce_binary_plus_end(production, range, tokens, theChildren)
+      end
+
+      # rule('equality' => 'comparison equalityTest_plus')
+      def reduce_equality_plus(production, range, tokens, theChildren)
+        reduce_binary_operator(production, range, tokens, theChildren)
+      end
+
+      # rule('equalityTest_plus' => 'equalityTest_plus equalityTest comparison')
+      def reduce_equality_t_plus_more(production, range, tokens, theChildren)
+        reduce_binary_plus_more(production, range, tokens, theChildren)
+      end
+
+      # rule('equalityTest_star' => 'equalityTest comparison')
+      def reduce_equality_t_plus_end(production, range, tokens, theChildren)
+        reduce_binary_plus_end(production, range, tokens, theChildren)
+      end
+
+      # rule('comparison' => 'term comparisonTest_plus')
+      def reduce_comparison_plus(production, range, tokens, theChildren)
+        reduce_binary_operator(production, range, tokens, theChildren)
+      end
+
+      # rule('comparisonTest_plus' => 'comparisonTest_plus comparisonTest term').as 'comparison_t_plus_more'
+      # TODO: is it meaningful to implement this rule?
+
+      # rule('comparisonTest_plus' => 'comparisonTest term')
+      def reduce_comparison_t_plus_end(production, range, tokens, theChildren)
+        reduce_binary_plus_end(production, range, tokens, theChildren)
+      end
+
+      # rule('term' => 'factor additive_plus')
+      def reduce_term_additive(production, range, tokens, theChildren)
+        reduce_binary_operator(production, range, tokens, theChildren)
+      end
+
+      # rule('additive_star' => 'additive_star additionOp factor').as 'additionOp_expr'
+      def reduce_additive_plus_more(production, range, tokens, theChildren)
+        reduce_binary_plus_more(production, range, tokens, theChildren)
+      end
+
+      # rule('additive_plus' => 'additionOp factor')
+      def reduce_additive_plus_end(production, range, tokens, theChildren)
+        reduce_binary_plus_end(production, range, tokens, theChildren)
+      end
+
+      # rule('factor' => 'multiplicative_plus')
+      def reduce_factor_multiplicative(production, range, tokens, theChildren)
+        reduce_binary_operator(production, range, tokens, theChildren)
       end
 
       # rule('multiplicative_plus' => 'multiplicative_plus multOp unary')
-      def reduce_multiplicative_plus_more(_production, _range, _tokens, theChildren)
-        result = theChildren[0]
-        operator = theChildren[1].symbol.name == 'SLASH' ? :/ : :*
-        operand2 = theChildren[2]
-        result << [operator, operand2]
+      def reduce_multiplicative_plus_more(production, range, tokens, theChildren)
+        reduce_binary_plus_more(production, range, tokens, theChildren)
       end
 
       # rule('multiplicative_plus' => 'multOp unary')
-      def reduce_multiplicative_plus_end(_production, _range, _tokens, theChildren)
-        operator = theChildren[0].symbol.name == 'SLASH' ? :/ : :*
-        operand2 = theChildren[1]
-        [[operator, operand2]]
+      def reduce_multiplicative_plus_end(production, range, tokens, theChildren)
+        reduce_binary_plus_end(production, range, tokens, theChildren)
       end
 
       # rule('primary' => 'FALSE' | TRUE').as 'literal_expr'