loxxy 0.0.7 → 0.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d1b591e9ed6ae88b4b4232c01c4f08fd4453fb499a665c368cd64ce2135a6718
-  data.tar.gz: 6bc1f01f9f0a963a2781271c46391e2c2801b61cc1b076e0b79be30450bee2af
+  metadata.gz: 7274fd2d139354b984962f9317cae890344e528540f2f157772e7395cdfd7d33
+  data.tar.gz: c1b38a4dfcb441c00604926cbaf397ab555624270ca647448d9cc4d4f463f500
 SHA512:
-  metadata.gz: 5dd208921fc139eb5f48b182abbe64b919c514904dfab073b09c4a9656989db5c95a5e1bd6f72733a46af8351dc6f95ab94612d8016c22e13dbcedd4637db90b
-  data.tar.gz: 63ac04a1cd79335daf5dbb38de2615e89044c49ec74fd174200149ef24d829861c3af0e7bf62862cbffc03940b955a6c9336344696d432e4efaa83d2dc1e9d35
+  metadata.gz: 27d5de6532213d1a995f86da84ccbd41a11b5f85c305e57a62f64637ad17852e622685e4261b1c62deb31c924bb8f8c29c4edd97e9776fabf7e0d06e5c302534
+  data.tar.gz: dab4a9e391c120c159a63e316f90065faf1415b54c9aa4c6f349f6be8e95de1289a2478f395e6b9e19b2e6f09482ae4db49a70e0d5d857eb5475cecad0590c69

data/CHANGELOG.md

@@ -1,3 +1,56 @@
+## [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.
+
 ## [0.0.7] - 2021-01-06
 - Lox grammar reworked, initial AST classes created.
 

data/README.md

@@ -1,4 +1,7 @@
-# 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/ ).
@@ -6,25 +9,30 @@ a simple language used in Bob Nystrom's online book [Crafting Interpreters](http
 ## 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],  
+- The implementation should be mature enough to run [LoxLox](https://github.com/benhoyt/loxlox),  
   a Lox interpreter written in Lox.
 
-## 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
-
-## Example
-The __loxxy__ hosts two distinct parsers classes (`RawParser` and `Parser`).  
-- A `RawParser` instance is able to recognize 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.
-
-### Example using RawParser class
+## 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.
+
+The __loxxy__ gem also a parser class `RawPaser` that can, in principle, any valid Lox input.
+
+## 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) # => Hello, world!
+```
+
+## Example using RawParser class
+
 ```ruby
 require 'loxxy'
 
@@ -69,6 +77,15 @@ 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
 
@@ -91,9 +108,9 @@ 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
+An impressive list of Lox implementations can be found [here](https://github.com/munificent/craftinginterpreters/wiki/Lox-implementations)
 
-For Ruby, ther is the [lox](https://github.com/rdodson41/ruby-lox) gem.
+For Ruby, there is the [lox](https://github.com/rdodson41/ruby-lox) gem.
 There are other Ruby-based projects as well:  
 - [SlowLox](https://github.com/ArminKleinert/SlowLox), described as a "1-to-1 conversion of JLox to Ruby"
 - [rulox](https://github.com/LevitatingBusinessMan/rulox)

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::False.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,18 +92,139 @@ module Loxxy
         node
       end
 
+      # rule('lhs' => 'nonterm_i nonterm_k_plus')
+      def reduce_binary_operator(_production, _range, tokens, theChildren)
+        operand1 = theChildren[0]
+
+        # Second child is array with couples [operator, operand2]
+        theChildren[1].each do |(operator, operand2)|
+          operand1 = LoxBinaryExpr.new(tokens[0].position, operator, operand1, operand2)
+        end
+
+        operand1
+      end
+
+      # rule('something_plus' => 'something_plus operator symbol')
+      def reduce_binary_plus_more(_production, _range, _tokens, theChildren)
+        result = theChildren[0]
+        operator = Name2special[theChildren[1].symbol.name].to_sym
+        operand2 = theChildren[2]
+        result << [operator, operand2]
+      end
+
+      # 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
+
+      #####################################
+      #  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 ''
+      def reduce_lox_program(_production, range, tokens, theChildren)
+        return_first_child(range, tokens, theChildren)
+      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_additionOp_expr(_production, _range, _tokens, theChildren)
-        (operand1, operator_node, operand2) = theChildren
-        operator = operator_node.symbol.name == 'MINUS' ? :- : :+
-        LoxBinaryExpr.new(operator_node.token.position, operator, operand1, operand2)
+      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_star' => 'multiplicative_star multOp unary').as 'multOp_expr'
-      # def reduce_multOp_expr(_production, _range, _tokens, theChildren)
-      #   (operand1, operator, operand2) = theChildren
-      #   LoxBinaryExpr.new(operator.token.position, operator, operand1, operand2)
-      # end
+      # rule('multiplicative_plus' => 'multiplicative_plus multOp unary')
+      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)
+        reduce_binary_plus_end(production, range, tokens, theChildren)
+      end
 
       # rule('primary' => 'FALSE' | TRUE').as 'literal_expr'
       def reduce_literal_expr(_production, _range, _tokens, theChildren)

data/lib/loxxy/ast/ast_visitor.rb

@@ -39,75 +39,55 @@ module Loxxy
         top.accept(self)
       end
 
-      # Visit event. The visitor is visiting the
-      # given terminal node containing a datatype object.
-      # @param aLiteralExpr [AST::LoxLiteralExpr] the leaf node to visit.
-      def visit_literal_expr(aLiteralExpr)
-        broadcast(:before_literal_expr, aLiteralExpr)
-        broadcast(:after_literal_expr, aLiteralExpr)
+      # Visit event. The visitor is about to visit the ptree.
+      # @param aParseTree [Rley::PTre::ParseTree] the ptree to visit.
+      def start_visit_ptree(aParseTree)
+        broadcast(:before_ptree, aParseTree)
       end
 
-=begin
-
+      # Visit event. The visitor has completed the visit of the ptree.
+      # @param aParseTree [Rley::PTre::ParseTree] the visited ptree.
+      def end_visit_ptree(aParseTree)
+        broadcast(:after_ptree, aParseTree)
+      end
 
-      def visit_compound_datum(aCompoundDatum)
-        broadcast(:before_compound_datum, aCompoundDatum)
-        traverse_children(aCompoundDatum)
-        broadcast(:after_compound_datum, aCompoundDatum)
+      # Visit event. The visitor is about to visit a print statement expression.
+      # @param aPrintStmt [AST::LOXPrintStmt] the print statement node to visit
+      def visit_print_stmt(aPrintStmt)
+        broadcast(:before_print_stmt, aPrintStmt)
+        traverse_subnodes(aPrintStmt)
+        broadcast(:after_print_stmt, aPrintStmt)
       end
 
       # Visit event. The visitor is visiting the
-      # given empty list object.
-      # @param anEmptyList [SkmEmptyList] the empty list object to visit.
-      def visit_empty_list(anEmptyList)
-        broadcast(:before_empty_list, anEmptyList)
-        broadcast(:after_empty_list, anEmptyList)
+      # given terminal node containing a datatype object.
+      # @param aLiteralExpr [AST::LoxLiteralExpr] the leaf node to visit.
+      def visit_literal_expr(aLiteralExpr)
+        broadcast(:before_literal_expr, aLiteralExpr)
+        broadcast(:after_literal_expr, aLiteralExpr)
       end
 
-      def visit_pair(aPair)
-        broadcast(:before_pair, aPair)
-        traverse_car_cdr(aPair)
-        broadcast(:after_pair, aPair)
-      end
-=end
-=begin
-   # Visit event. The visitor is about to visit the given non terminal node.
-    # @param aNonTerminalNode [NonTerminalNode] the node to visit.
-    def visit_nonterminal(aNonTerminalNode)
-      if @traversal == :post_order
-        broadcast(:before_non_terminal, aNonTerminalNode)
-        traverse_subnodes(aNonTerminalNode)
-      else
-        traverse_subnodes(aNonTerminalNode)
-        broadcast(:before_non_terminal, aNonTerminalNode)
+      # Visit event. The visitor is about to visit the given non terminal node.
+      # @param aNonTerminalNode [Rley::PTre::NonTerminalNode] the node to visit.
+      def visit_nonterminal(_non_terminal_node)
+        # Loxxy interpreter encountered a CST node (Concrete Syntax Tree)
+        # that it cannot handle.
+        raise NotImplementedError, 'Loxxy cannot execute this code yet.'
       end
-      broadcast(:after_non_terminal, aNonTerminalNode)
-    end
-=end
 
       private
 
-      def traverse_children(aParent)
-        children = aParent.children
-        broadcast(:before_children, aParent, children)
+      # Visit event. The visitor is about to visit the subnodes of a non
+      # terminal node.
+      # @param aParentNode [Ast::LocCompoundExpr] the parent node.
+      def traverse_subnodes(aParentNode)
+        subnodes = aParentNode.subnodes
+        broadcast(:before_subnodes, aParentNode, subnodes)
 
-        # Let's proceed with the visit of children
-        children.each { |a_child| a_child.accept(self) }
+        # Let's proceed with the visit of subnodes
+        subnodes.each { |a_node| a_node.accept(self) }
 
-        broadcast(:after_children, aParent, children)
-      end
-
-      def traverse_car_cdr(aPair)
-        if aPair.car
-          broadcast(:before_car, aPair, aPair.car)
-          aPair.car.accept(self)
-          broadcast(:after_car, aPair, aPair.car)
-        end
-        if aPair.cdr
-          broadcast(:before_cdr, aPair, aPair.cdr)
-          aPair.cdr.accept(self)
-          broadcast(:after_cdr, aPair, aPair.cdr)
-        end
+        broadcast(:after_subnodes, aParentNode, subnodes)
       end
 
       # Send a notification to all subscribers.
@@ -117,7 +97,7 @@ module Loxxy
         subscribers.each do |subscr|
           next unless subscr.respond_to?(msg) || subscr.respond_to?(:accept_all)
 
-          subscr.send(msg, runtime, *args)
+          subscr.send(msg, *args)
         end
       end
     end # class