loxxy 0.0.5 → 0.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5db00fee0e8e7ef89a48cacc4e9ad0baf7ae5ee2cb419ba76964199bd7552199
-  data.tar.gz: ddb8e9c7ac267f32bed3f77ada05a6af38a872b5f892452a496b17522b608977
+  metadata.gz: e4f33203580d2b83ee7139e449787b439c0fb56c5a8c3dcc8035d114ffd957d3
+  data.tar.gz: 46c9fb2f55849c6aa9b9e4d58588746ddb3ac3353f7ed09922d9394a9fc512c6
 SHA512:
-  metadata.gz: 44e0049b0bc01e5d35bed7b91c32a7a3b977e6ba4e806439958bad2dc8aae7ead017a310c8523bd4cb628c14951946981bee42f4001d68b701159fcdaff53419
-  data.tar.gz: c90236a82f0a4872b209b8462d5f13377815fd4fc41babf256ff4894ea6900e343c6f192194e1b713cb9f8a8d2bffc326e7ea4f00726193e0a792dc9e1457e41
+  metadata.gz: 30f554af6338b50297ce6befaa62c86c8406df681e25098cc95dc28da64bb6feabbb9e085846eb8032f51d8d3655332105eb1d7165903bbd0d6be24cb13c4d0b
+  data.tar.gz: d9d9a69a010d16807f6c4bf24b15e8135367bb62b6d2e052943e0d6030751f282c777f652dd3fced08093aee8abae228e63d365cae156fa6e87ac7f52fc7e2e6

data/.rubocop.yml

@@ -170,6 +170,9 @@ Naming/BlockParameterName:
 
 Naming/MethodParameterName:
   Enabled: false
+  
+Naming/MethodName:
+  Enabled: false
 
 Naming/VariableName:
   Enabled: false

data/CHANGELOG.md

@@ -1,3 +1,61 @@
+## [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.
+
+## Added
+- Class `Parser` this one generates AST's (Abstract Syntax Tree)
+- Class `AST::ASTVisitor` draft initial implementation.
+- Class `AST::BinaryExpr` draft initial implementation.
+- Class `AST::LoxCompoundExpr` draft initial implementation.
+- Class `AST::LiteralExpr` draft initial implementation.
+- Class `AST::LoxNode` draft initial implementation.
+
+## Changed
+- File `spec_helper.rb`: removed Bundler dependency
+- Class `AST::ASTBuilder` added initial `reduce_` methods.
+- File `README.md` Removed example with AST generation since this is in flux.
+
+## [0.0.6] - 2021-01-03
+- First iteration of a parser with AST generation.
+
+## Added
+- Class `Parser` this one generates AST's (Abstract Syntax Tree)
+- Class `AST::ASTBuilder` default code to generate an AST.
+
+## Changed
+- File `spec_helper.rb`: removed Bundler dependency
+- File `README.md` Added example with AST visualization.
+
+## Fixed
+- File `grammar.rb` ensure that the constant `Grammar` is created once only.
+
 ## [0.0.5] - 2021-01-02
 - Improved example in `README.md`, code re-styling to please `Rubocop` 1.7
 

data/README.md

@@ -1,27 +1,70 @@
-# 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/).
+
+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:
 - 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.
-- [TODO] Tailored parser for generating AST (Abstract Syntax Tree)
-- [TODO] Custom AST builder class  
-- [TODO] Hierarchy classes for representing Lox expressions in AST  
-- [TODO] Interpreter or transpiler
-
-
-## Example
-At this, stage, the raw parser is able to recognize Lox input and to generate
-a concrete parse tree from it.
+## 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)
+- Lox grammar (in format required by Rley gem)   
+- Raw parser. It parses Lox programs and generates a raw parse tree.
+- Tailored parser for generating AST (Abstract Syntax Tree)
+  
+### Started
+-  Custom AST builder class  
+-  Classes for representing Lox expressions in AST
+
+### TODO
+AST Node generation
+Goal: parser should generate AST for any input Lox program
+- [X] Equality operator
+- [] Logical operator (and, or)
+- [] Unary expressions (negate, not)
+- [] Grouping expressions
+- [] Print statement
+- [] Simple assignment expressions
+- [] Variable declaration
+- [] Dot notation
+- [] Block statement
+- [] If statement
+- [] For statement
+- [] While statement
+- [] Function declaration
+- [] Call expression
+- [] Return statement
+- [] Class declaration
+- [] AST generation covers complete grammar
+
+Tree-walking:
+- [] Tree visitor recognizes all AST node types
+
+Interpreter:
+- Keywords: symbol table, scope, activation record, class & object model, Lox test suite
+- [] Milestone: Interpreter handles expressions but function calls
+- [] Milestone: Interpreter handles `for`, `if`, `print`, `while` and block statements
+- [] Milestone: Interpreter handles variable declarations (global, block)
+- [] Milestone: Interpreter handles function declarations and calls
+- [] Milestone: Interpreter supports class and object definition
+- [] Milestone: Lox interpreter complete
+
+## Example using RawParser class
 ```ruby
 require 'loxxy'
 
@@ -45,8 +88,7 @@ tree_formatter.render(visitor)
 This is the output produced by the above example:
 ```
 program
-+-- declaration_star
-|   +-- declaration_star
++-- declaration_plus
 |   +-- declaration
 |       +-- statement
 |           +-- printStmt
@@ -55,29 +97,18 @@ program
 |               |   +-- assignment
 |               |       +-- logic_or
 |               |           +-- logic_and
-|               |           |   +-- equality
-|               |           |   |   +-- comparison
-|               |           |   |   |   +-- term
-|               |           |   |   |   |   +-- factor
-|               |           |   |   |   |   |   +-- unary
-|               |           |   |   |   |   |   |   +-- call
-|               |           |   |   |   |   |   |       +-- primary
-|               |           |   |   |   |   |   |       |   +-- STRING: '"Hello, world!"'
-|               |           |   |   |   |   |   |       +-- refinement_star
-|               |           |   |   |   |   |   +-- multiplicative_star
-|               |           |   |   |   |   +-- additive_star
-|               |           |   |   |   +-- comparisonTest_star
-|               |           |   |   +-- equalityTest_star
-|               |           |   +-- conjunct_star
-|               |           +-- disjunct_star
+|               |               +-- equality
+|               |                   +-- comparison
+|               |                       +-- term
+|               |                           +-- factor
+|               |                               +-- unary
+|               |                                   +-- call
+|               |                                       +-- primary
+|               |                                           +-- STRING: '"Hello, world!"'
 |               +-- SEMICOLON: ';'
 +-- EOF: ''
 ```
 
-Soon, the `loxxy` will host another, tailored parser, that will generate
-abstract syntax tree which much more convenient for further processing 
-(like implementing an interpreter).
-
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -99,9 +130,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

@@ -2,6 +2,7 @@
 
 require_relative 'loxxy/version'
 require_relative 'loxxy/front_end/raw_parser'
+require_relative 'loxxy/front_end/parser'
 
 module Loxxy
   class Error < StandardError; end

data/lib/loxxy/ast/ast_builder.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require_relative '../datatype/all_datatypes'
+require_relative 'lox_literal_expr'
+require_relative 'lox_binary_expr'
+
+module Loxxy
+  module Ast
+    # The purpose of ASTBuilder is to build piece by piece an AST
+    # (Abstract Syntax Tree) from a sequence of input tokens and
+    # visit events produced by walking over a GFGParsing object.
+    class ASTBuilder < Rley::ParseRep::ASTBaseBuilder
+      # 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
+
+      attr_reader :strict
+
+      # Create a new AST builder instance.
+      # @param theTokens [Array<Rley::Lexical::Token>] The sequence of input tokens.
+      def initialize(theTokens)
+        super(theTokens)
+        @strict = false
+      end
+
+      protected
+
+      def terminal2node
+        Terminal2NodeClass
+      end
+
+      # Method override
+      def new_leaf_node(_production, _terminal, aTokenPosition, aToken)
+        Rley::PTree::TerminalNode.new(aToken, aTokenPosition)
+      end
+
+      # Factory method for creating a parent node object.
+      # @param aProduction [Production] Production rule
+      # @param aRange [Range] Range of tokens matched by the rule
+      # @param theTokens [Array] The input tokens
+      # @param theChildren [Array] Children nodes (one per rhs symbol)
+      def new_parent_node(aProduction, aRange, theTokens, theChildren)
+        mth_name = method_name(aProduction.name)
+        if respond_to?(mth_name, true)
+          node = send(mth_name, aProduction, aRange, theTokens, theChildren)
+        else
+          # Default action...
+          node = case aProduction.rhs.size
+                 when 0
+                   return_epsilon(aRange, theTokens, theChildren)
+                 when 1
+                   return_first_child(aRange, theTokens, theChildren)
+                 else
+                   if strict
+                     msg = "Don't know production '#{aProduction.name}'"
+                     raise StandardError, msg
+                   else
+                     node = Rley::PTree::NonTerminalNode.new(aProduction.lhs, aRange)
+                     theChildren&.reverse_each do |child|
+                       node.add_subnode(child) if child
+                     end
+
+                     node
+                   end
+                 end
+        end
+
+        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
+
+      # 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)
+        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)
+        first_child = theChildren.first
+        pos = first_child.token.position
+        literal = first_child.token.value
+        LoxLiteralExpr.new(pos, literal)
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/ast/ast_visitor.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Loxxy
+  module Ast
+    class ASTVisitor
+      # Link to the top node to visit
+      attr_reader(:top)
+
+      # List of objects that subscribed to the visit event notification.
+      attr_reader(:subscribers)
+
+      # attr_reader(:runtime)
+
+      # Build a visitor for the given top.
+      # @param aRoot [AST::LoxNode] the parse tree to visit.
+      def initialize(aTop)
+        raise StandardError if aTop.nil?
+
+        @top = aTop
+        @subscribers = []
+      end
+
+      # Add a subscriber for the visit event notifications.
+      # @param aSubscriber [Object]
+      def subscribe(aSubscriber)
+        subscribers << aSubscriber
+      end
+
+      # Remove the given object from the subscription list.
+      # The object won't be notified of visit events.
+      # @param aSubscriber [Object]
+      def unsubscribe(aSubscriber)
+        subscribers.delete_if { |entry| entry == aSubscriber }
+      end
+
+      # The signal to begin the visit of the top.
+      def start # (aRuntime)
+        # @runtime = aRuntime
+        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)
+      end
+
+=begin
+
+
+      def visit_compound_datum(aCompoundDatum)
+        broadcast(:before_compound_datum, aCompoundDatum)
+        traverse_children(aCompoundDatum)
+        broadcast(:after_compound_datum, aCompoundDatum)
+      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)
+      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)
+      end
+      broadcast(:after_non_terminal, aNonTerminalNode)
+    end
+=end
+
+      private
+
+      def traverse_children(aParent)
+        children = aParent.children
+        broadcast(:before_children, aParent, children)
+
+        # Let's proceed with the visit of children
+        children.each { |a_child| a_child.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
+      end
+
+      # Send a notification to all subscribers.
+      # @param msg [Symbol] event to notify
+      # @param args [Array] arguments of the notification.
+      def broadcast(msg, *args)
+        subscribers.each do |subscr|
+          next unless subscr.respond_to?(msg) || subscr.respond_to?(:accept_all)
+
+          subscr.send(msg, runtime, *args)
+        end
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/ast/lox_binary_expr.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative 'lox_compound_expr'
+
+module Loxxy
+  module Ast
+    class LoxBinaryExpr < LoxCompoundExpr
+      # @return [Symbol]
+      attr_reader :operator
+
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      # @param operand1 [Loxxy::Ast::LoxNode]
+      # @param operand2 [Loxxy::Ast::LoxNode]
+      def initialize(aPosition, anOperator, operand1, operand2)
+        super(aPosition, [operand1, operand2])
+        @operator = anOperator
+      end
+
+      alias operands subnodes
+    end # class
+  end # module
+end # module

data/lib/loxxy/ast/lox_compound_expr.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'lox_node'
+
+module Loxxy
+  module Ast
+    class LoxCompoundExpr < LoxNode
+      # @return [Array<Ast::LoxNode>]
+      attr_reader :subnodes
+
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      # @param theSubnodes [Array<Ast::LoxNode>]
+      def initialize(aPosition, theSubnodes)
+        super(aPosition)
+        @subnodes = theSubnodes
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_compound_expr(self)
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/ast/lox_literal_expr.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'lox_node'
+
+module Loxxy
+  module Ast
+    class LoxLiteralExpr < LoxNode
+      # @return [Loxxy::Datatype::BuiltinDatatype]
+      attr_reader :literal
+
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      # @param aLiteral [Loxxy::Datatype::BuiltinDatatype]
+      def initialize(aPosition, aLiteral)
+        super(aPosition)
+        @literal = aLiteral
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_literal_expr(self)
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/ast/lox_node.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Loxxy
+  module Ast
+    class LoxNode
+      # return [Rley::Lexical::Position] Position of the entry in the input stream.
+      attr_reader :position
+
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      def initialize(aPosition)
+        @position = aPosition
+      end
+
+      # Abstract method.
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param _visitor [LoxxyTreeVisitor] the visitor
+      def accept(_visitor)
+        raise NotImplementedError
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/front_end/grammar.rb

@@ -26,11 +26,12 @@ module Loxxy
       add_terminals('EOF')
 
       # Top-level rule that matches an entire Lox program
-      rule('program' => 'declaration_star EOF')
+      rule('program' => 'EOF')
+      rule('program' => 'declaration_plus EOF')
 
       # Declarations: bind an identifier to something
-      rule('declaration_star' => 'declaration_star declaration')
-      rule('declaration_star' => [])
+      rule('declaration_plus' => 'declaration_plus declaration')
+      rule('declaration_plus' => 'declaration')
       rule('declaration' => 'classDecl')
       rule('declaration' => 'funDecl')
       rule('declaration' => 'varDecl')
@@ -75,7 +76,8 @@ module Loxxy
       rule('printStmt' => 'PRINT expression SEMICOLON')
       rule('returnStmt' => 'RETURN expression_opt SEMICOLON')
       rule('whileStmt' => 'WHILE LEFT_PAREN expression RIGHT_PAREN statement')
-      rule('block' => 'LEFT_BRACE declaration_star RIGHT_BRACE')
+      rule('block' => 'LEFT_BRACE declaration_plus RIGHT_BRACE')
+      rule('block' => 'LEFT_BRACE RIGHT_BRACE')
 
       # Expressions: produce values
       rule('expression_opt' => 'expression')
@@ -85,49 +87,56 @@ module Loxxy
       rule('assignment' => 'logic_or')
       rule('owner_opt' => 'call DOT')
       rule('owner_opt' => [])
-      rule('logic_or' => 'logic_and disjunct_star')
-      rule('disjunct_star' => 'disjunct_star OR logic_and')
-      rule('disjunct_star' => [])
-      rule('logic_and' => 'equality conjunct_star')
-      rule('conjunct_star' => 'conjunct_star AND equality')
-      rule('conjunct_star' => [])
-      rule('equality' => 'comparison equalityTest_star')
-      rule('equalityTest_star' => 'equalityTest_star equalityTest comparison')
-      rule('equalityTest_star' => [])
+      rule('logic_or' => 'logic_and')
+      rule('logic_or' => 'logic_and disjunct_plus')
+      rule('disjunct_plus' => 'disjunct_plus OR logic_and')
+      rule('disjunct_plus' => 'OR logic_and')
+      rule('logic_and' => 'equality')
+      rule('logic_and' => 'equality conjunct_plus')
+      rule('conjunct_plus' => 'conjunct_plus AND equality')
+      rule('conjunct_' => 'AND equality')
+      rule('equality' => 'comparison')
+      rule('equality' => 'comparison equalityTest_plus').as 'equality_plus'
+      rule('equalityTest_plus' => 'equalityTest_plus equalityTest comparison').as 'equality_t_plus_more'
+      rule('equalityTest_plus' => 'equalityTest comparison').as 'equality_t_plus_end'
       rule('equalityTest' => 'BANG_EQUAL')
       rule('equalityTest' => 'EQUAL_EQUAL')
-      rule('comparison' => 'term comparisonTest_star')
-      rule('comparisonTest_star' => 'comparisonTest_star comparisonTest term')
-      rule('comparisonTest_star' => [])
+      rule('comparison' => 'term')
+      rule('comparison' => 'term comparisonTest_plus').as 'comparison_plus'
+      rule('comparisonTest_plus' => 'comparisonTest_plus comparisonTest term').as 'comparison_t_plus_more'
+      rule('comparisonTest_plus' => 'comparisonTest term').as 'comparison_t_plus_end'
       rule('comparisonTest' => 'GREATER')
       rule('comparisonTest' => 'GREATER_EQUAL')
       rule('comparisonTest' => 'LESS')
       rule('comparisonTest' => 'LESS_EQUAL')
-      rule('term' => 'factor additive_star')
-      rule('additive_star' => 'additive_star additionOp factor')
-      rule('additive_star' => [])
+      rule('term' => 'factor')
+      rule('term' => 'factor additive_plus').as 'term_additive'
+      rule('additive_plus' => 'additive_plus additionOp factor').as 'additive_plus_more'
+      rule('additive_plus' => 'additionOp factor').as 'additive_plus_end'
       rule('additionOp' => 'MINUS')
       rule('additionOp' => 'PLUS')
-      rule('factor' => 'unary multiplicative_star')
-      rule('multiplicative_star' => 'multiplicative_star multOp unary')
-      rule('multiplicative_star' => [])
+      rule('factor' => 'unary')
+      rule('factor' => 'unary multiplicative_plus').as 'factor_multiplicative'
+      rule('multiplicative_plus' => 'multiplicative_plus multOp unary').as 'multiplicative_plus_more'
+      rule('multiplicative_plus' => 'multOp unary').as 'multiplicative_plus_end'
       rule('multOp' => 'SLASH')
       rule('multOp' => 'STAR')
       rule('unary' => 'unaryOp unary')
       rule('unary' => 'call')
       rule('unaryOp' => 'BANG')
       rule('unaryOp' => 'MINUS')
-      rule('call' => 'primary refinement_star')
-      rule('refinement_star' => 'refinement_star refinement')
-      rule('refinement_star' => [])
+      rule('call' => 'primary')
+      rule('call' => 'primary refinement_plus')
+      rule('refinement_plus' => 'refinement_plus refinement')
+      rule('refinement_plus' => 'refinement')
       rule('refinement' => 'LEFT_PAREN arguments_opt RIGHT_PAREN')
       rule('refinement' => 'DOT IDENTIFIER')
-      rule('primary' => 'TRUE')
-      rule('primary' => 'FALSE')
-      rule('primary' => 'NIL')
+      rule('primary' => 'TRUE').as 'literal_expr'
+      rule('primary' => 'FALSE').as 'literal_expr'
+      rule('primary' => 'NIL').as 'literal_expr'
       rule('primary' => 'THIS')
-      rule('primary' => 'NUMBER')
-      rule('primary' => 'STRING')
+      rule('primary' => 'NUMBER').as 'literal_expr'
+      rule('primary' => 'STRING').as 'literal_expr'
       rule('primary' => 'IDENTIFIER')
       rule('primary' => 'LEFT_PAREN expression RIGHT_PAREN')
       rule('primary' => 'SUPER DOT IDENTIFIER')
@@ -144,8 +153,10 @@ module Loxxy
       rule('arguments' => 'expression')
     end
 
-    # And now build the grammar and make it accessible via a constant
-    # @return [Rley::Syntax::Grammar]
-    Grammar = builder.grammar
+    unless defined?(Grammar)
+      # And now build the grammar and make it accessible via a constant
+      # @return [Rley::Syntax::Grammar]
+      Grammar = builder.grammar
+    end
   end # module
 end # module

data/lib/loxxy/front_end/parser.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative 'scanner'
+require_relative 'grammar'
+require_relative '../ast/ast_builder'
+
+module Loxxy
+  module FrontEnd
+    # A Lox parser that produce concrete parse trees.
+    # Concrete parse trees are the default kind of parse tree
+    # generated by the Rley library.
+    # They consist of two node types only:
+    # - NonTerminalNode
+    # - TerminalNode
+    # A NonTerminalNode has zero or more child nodes (called subnodes)
+    # A TerminalNode is leaf node, that is, it has no child node.
+    # While concrete parse tree nodes can be generated out of the box,
+    # they have the following drawbacks:
+    # - Generic node classes that aren't always suited for the needs of
+    #     the language being processing.
+    # - Concrete parse tree tend to be deeply nested, which may complicate
+    #   further processing.
+    class Parser
+      # @return [Rley::Engine] A facade object for the Rley parsing library
+      attr_reader(:engine)
+
+      def initialize
+        # Create a Rley facade object
+        @engine = Rley::Engine.new do |cfg|
+          cfg.diagnose = true
+          cfg.repr_builder = Ast::ASTBuilder
+        end
+
+        # Step 1. Load Lox grammar
+        @engine.use_grammar(Loxxy::FrontEnd::Grammar)
+      end
+
+      # Parse the given Lox program into a parse tree.
+      # @param source [String] Lox program to parse
+      # @return [Rley::ParseTree] A parse tree equivalent to the Lox input.
+      def parse(source)
+        lexer = Scanner.new(source)
+        result = engine.parse(lexer.tokens)
+
+        unless result.success?
+          # Stop if the parse failed...
+          line1 = "Parsing failed\n"
+          line2 = "Reason: #{result.failure_reason.message}"
+          raise StandardError, line1 + line2
+        end
+
+        return engine.convert(result) # engine.to_ptree(result)
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/version.rb

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

data/spec/front_end/parser_spec.rb

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+
+# Load the class under test
+require_relative '../../lib/loxxy/front_end/parser'
+
+module Loxxy
+  module FrontEnd
+    describe Parser do
+      subject { Parser.new }
+
+      # Utility method to walk towards deeply nested node
+      # @param aNTNode [Rley::PTree::NonTerminalNode]
+      # @param subnodePath[Array<Integer>] An Array of subnode indices
+      def walk_subnodes(aNTNode, subnodePath)
+        curr_node = aNTNode
+        subnodePath.each do |index|
+          curr_node = curr_node.subnodes[index]
+        end
+
+        curr_node
+      end
+
+      context 'Initialization:' do
+        it 'should be initialized without argument' do
+          expect { Parser.new }.not_to raise_error
+        end
+
+        it 'should have its parse engine initialized' do
+          expect(subject.engine).to be_kind_of(Rley::Engine)
+        end
+      end # context
+
+      context 'Parsing blank files:' do
+        def check_empty_input_result(aParseTree)
+          # Parse results MUST to comply to grammar rule:
+          #   program => declaration_star EOF
+          #   where the declaration_star MUST be empty
+          expect(aParseTree.root.symbol.name).to eq('EOF')
+        end
+
+        it 'should cope with an empty input' do
+          ptree = subject.parse('')
+          check_empty_input_result(ptree)
+        end
+
+        it 'should cope with whitespaces only input' do
+          ptree = subject.parse(' ' * 80 + "\n" * 20)
+          check_empty_input_result(ptree)
+        end
+
+        it 'should cope with comments only input' do
+          input = +''
+          %w[First Second Third].each do |ordinal|
+            input << "// #{ordinal} comment line\r\n"
+          end
+          ptree = subject.parse(input)
+          check_empty_input_result(ptree)
+        end
+      end # context
+
+      context 'Parsing literals:' do
+        it 'should parse a false literal' do
+          input = 'false;'
+          ptree = subject.parse(input)
+          leaf = walk_subnodes(ptree.root, [0, 0])
+          expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
+          expect(leaf.literal).to be_equal(Datatype::False.instance)
+        end
+
+        it 'should parse a true literal' do
+          input = 'true;'
+          ptree = subject.parse(input)
+          leaf = walk_subnodes(ptree.root, [0, 0])
+          expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
+          expect(leaf.literal).to be_equal(Datatype::True.instance)
+        end
+
+        it 'should parse number literals' do
+          inputs = %w[1234; 12.34;]
+          inputs.each do |source|
+            ptree = subject.parse(source)
+            leaf = walk_subnodes(ptree.root, [0, 0])
+            expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
+            expect(leaf.literal).to be_kind_of(Datatype::Number)
+            expect(leaf.literal.value).to eq(source.to_f)
+          end
+        end
+
+        it 'should parse string literals' do
+          inputs = [
+            '"I am a string";',
+            '"";',
+            '"123";'
+          ]
+          inputs.each do |source|
+            ptree = subject.parse(source)
+            leaf = walk_subnodes(ptree.root, [0, 0])
+            expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
+            expect(leaf.literal).to be_kind_of(Datatype::LXString)
+            expect(leaf.literal.value).to eq(source.gsub(/(^")|(";$)/, ''))
+          end
+        end
+
+        it 'should parse a nil literal' do
+          input = 'nil;'
+          ptree = subject.parse(input)
+          leaf = walk_subnodes(ptree.root, [0, 0])
+          expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
+          expect(leaf.literal).to be_equal(Datatype::Nil.instance)
+        end
+      end
+
+      context 'Parsing expressions:' do
+        it 'should parse a hello world program' do
+          program = <<-LOX_END
+            // Your first Lox program!
+            print "Hello, world!";
+LOX_END
+          ptree = subject.parse(program)
+          root = ptree.root
+          expect(root.symbol.name).to eq('program')
+          (prnt_stmt, eof) = root.subnodes
+          expect(prnt_stmt).to be_kind_of(Rley::PTree::NonTerminalNode)
+          expect(prnt_stmt.symbol.name).to eq('printStmt')
+          expect(prnt_stmt.subnodes.size).to eq(3)
+          expect(prnt_stmt.subnodes[0]).to be_kind_of(Rley::PTree::TerminalNode)
+          expect(prnt_stmt.subnodes[0].symbol.name).to eq('PRINT')
+          expect(prnt_stmt.subnodes[1]).to be_kind_of(Loxxy::Ast::LoxLiteralExpr)
+          expect(prnt_stmt.subnodes[1].literal).to be_kind_of(Loxxy::Datatype::LXString)
+          expect(prnt_stmt.subnodes[1].literal.value).to eq('Hello, world!')
+          expect(prnt_stmt.subnodes[2]).to be_kind_of(Rley::PTree::TerminalNode)
+          expect(prnt_stmt.subnodes[2].symbol.name).to eq('SEMICOLON')
+          expect(eof).to be_kind_of(Rley::PTree::TerminalNode)
+          expect(eof.symbol.name).to eq('EOF')
+        end
+      end # context
+
+      context 'Parsing arithmetic operations' do
+        it 'should parse the addition of two number literals' do
+          input = '123 + 456;'
+          ptree = subject.parse(input)
+          parent = ptree.root.subnodes[0]
+          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
+          expect(parent.symbol.name).to eq('exprStmt')
+          expr = parent.subnodes[0]
+          expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr.operator).to eq(:+)
+          expect(expr.operands[0].literal.value).to eq(123)
+          expect(expr.operands[1].literal.value).to eq(456)
+        end
+
+        it 'should parse the subtraction of two number literals' do
+          input = '4 - 3;'
+          ptree = subject.parse(input)
+          parent = ptree.root.subnodes[0]
+          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
+          expect(parent.symbol.name).to eq('exprStmt')
+          expr = parent.subnodes[0]
+          expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr.operator).to eq(:-)
+          expect(expr.operands[0].literal.value).to eq(4)
+          expect(expr.operands[1].literal.value).to eq(3)
+        end
+
+        it 'should parse multiple additive operations' do
+          input = '5 + 2 - 3;'
+          ptree = subject.parse(input)
+          parent = ptree.root.subnodes[0]
+          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
+          expect(parent.symbol.name).to eq('exprStmt')
+          expr = parent.subnodes[0]
+          expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr.operator).to eq(:-)
+          expect(expr.operands[0]).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr.operands[0].operator).to eq(:+)
+          expect(expr.operands[0].operands[0].literal.value).to eq(5)
+          expect(expr.operands[0].operands[1].literal.value).to eq(2)
+          expect(expr.operands[1].literal.value).to eq(3)
+        end
+
+        it 'should parse the division of two number literals' do
+          input = '8 / 2;'
+          ptree = subject.parse(input)
+          parent = ptree.root.subnodes[0]
+          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
+          expect(parent.symbol.name).to eq('exprStmt')
+          expr = parent.subnodes[0]
+          expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr.operator).to eq(:/)
+          expect(expr.operands[0].literal.value).to eq(8)
+          expect(expr.operands[1].literal.value).to eq(2)
+        end
+
+        it 'should parse the product of two number literals' do
+          input = '12.34 * 0.3;'
+          ptree = subject.parse(input)
+          parent = ptree.root.subnodes[0]
+          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
+          expect(parent.symbol.name).to eq('exprStmt')
+          expr = parent.subnodes[0]
+          expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr.operator).to eq(:*)
+          expect(expr.operands[0].literal.value).to eq(12.34)
+          expect(expr.operands[1].literal.value).to eq(0.3)
+        end
+
+        it 'should parse multiple multiplicative operations' do
+          input = '5 * 2 / 3;'
+          ptree = subject.parse(input)
+          parent = ptree.root.subnodes[0]
+          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
+          expect(parent.symbol.name).to eq('exprStmt')
+          expr = parent.subnodes[0]
+          expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr.operator).to eq(:/)
+          expect(expr.operands[0]).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr.operands[0].operator).to eq(:*)
+          expect(expr.operands[0].operands[0].literal.value).to eq(5)
+          expect(expr.operands[0].operands[1].literal.value).to eq(2)
+          expect(expr.operands[1].literal.value).to eq(3)
+        end
+
+        it 'should parse combination of terms and factors' do
+          input = '5 + 2 / 3;'
+          ptree = subject.parse(input)
+          parent = ptree.root.subnodes[0]
+          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
+          expect(parent.symbol.name).to eq('exprStmt')
+          expr = parent.subnodes[0]
+          expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr.operator).to eq(:+)
+          expect(expr.operands[0].literal.value).to eq(5)
+          expect(expr.operands[1]).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr.operands[1].operator).to eq(:/)
+          expect(expr.operands[1].operands[0].literal.value).to eq(2)
+          expect(expr.operands[1].operands[1].literal.value).to eq(3)
+        end
+      end # context
+
+      context 'Parsing string concatenation' do
+        it 'should parse the concatenation of two string literals' do
+          input = '"Lo" + "ve";'
+          ptree = subject.parse(input)
+          parent = ptree.root.subnodes[0]
+          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
+          expect(parent.symbol.name).to eq('exprStmt')
+          expr = parent.subnodes[0]
+          expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr.operator).to eq(:+)
+          expect(expr.operands[0].literal.value).to eq('Lo')
+          expect(expr.operands[1].literal.value).to eq('ve')
+        end
+      end # context
+
+      context 'Parsing comparison expressions' do
+      it 'should parse the comparison of two number literals' do
+        %w[> >= < <=].each do |predicate|
+          input = "3 #{predicate} 2;"
+          ptree = subject.parse(input)
+          parent = ptree.root.subnodes[0]
+          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
+          expect(parent.symbol.name).to eq('exprStmt')
+          expr = parent.subnodes[0]
+          expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr.operator).to eq(predicate.to_sym)
+          expect(expr.operands[0].literal.value).to eq(3)
+          expect(expr.operands[1].literal.value).to eq(2)
+        end
+      end
+      end # context
+
+      context 'Parsing equality expressions' do
+        it 'should parse the equality of two number literals' do
+          %w[!= ==].each do |predicate|
+            input = "3 #{predicate} 2;"
+            ptree = subject.parse(input)
+            parent = ptree.root.subnodes[0]
+            expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
+            expect(parent.symbol.name).to eq('exprStmt')
+            expr = parent.subnodes[0]
+            expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+            expect(expr.operator).to eq(predicate.to_sym)
+            expect(expr.operands[0].literal.value).to eq(3)
+            expect(expr.operands[1].literal.value).to eq(2)
+          end
+        end
+
+        it 'should parse combination of equality expressions' do
+          input = '5 != 2 == false; // A bit contrived example'
+          ptree = subject.parse(input)
+          parent = ptree.root.subnodes[0]
+          expect(parent).to be_kind_of(Rley::PTree::NonTerminalNode)
+          expect(parent.symbol.name).to eq('exprStmt')
+          expr = parent.subnodes[0]
+          expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr.operator).to eq(:==)
+          expect(expr.operands[0]).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr.operands[0].operator).to eq(:!=)
+          expect(expr.operands[0].operands[0].literal.value).to eq(5)
+          expect(expr.operands[0].operands[1].literal.value).to eq(2)
+          expect(expr.operands[1].literal.value).to be_falsey
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/front_end/raw_parser_spec.rb

@@ -26,10 +26,7 @@ module Loxxy
           #   program => declaration_star EOF
           #   where the declaration_star MUST be empty
           expect(aParseTree.root.symbol.name).to eq('program')
-          (decls, eof) = aParseTree.root.subnodes
-          expect(decls).to be_kind_of(Rley::PTree::NonTerminalNode)
-          expect(decls.symbol.name).to eq('declaration_star')
-          expect(decls.subnodes).to be_empty
+          eof = aParseTree.root.subnodes.first
           expect(eof).to be_kind_of(Rley::PTree::TerminalNode)
           expect(eof.symbol.name).to eq('EOF')
         end
@@ -76,8 +73,8 @@ LOX_END
           expect(root.symbol.name).to eq('program')
           (decls, eof) = root.subnodes
           expect(decls).to be_kind_of(Rley::PTree::NonTerminalNode)
-          expect(decls.symbol.name).to eq('declaration_star')
-          stmt = decls.subnodes[1].subnodes[0]
+          expect(decls.symbol.name).to eq('declaration_plus')
+          stmt = decls.subnodes[0].subnodes[0]
           expect(stmt).to be_kind_of(Rley::PTree::NonTerminalNode)
           expect(stmt.symbol.name).to eq('statement')
           prnt_stmt = stmt.subnodes[0]

data/spec/front_end/scanner_spec.rb

@@ -223,6 +223,18 @@ LOX_END
           ]
           match_expectations(subject, expectations)
         end
+
+        it 'should cope with single slash (divide) expression' do
+          subject.start_with('8 / 2')
+
+          expectations = [
+            # [token lexeme]
+            %w[NUMBER 8],
+            %w[SLASH /],
+            %w[NUMBER 2]
+          ]
+          match_expectations(subject, expectations)
+        end
       end # context
     end # describe
   end # module

data/spec/spec_helper.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'bundler/setup'
+require 'rspec' # Use the RSpec framework
 require 'loxxy'
 
 RSpec.configure do |config|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: loxxy
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.10
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-02 00:00:00.000000000 Z
+date: 2021-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -84,6 +84,12 @@ files:
 - README.md
 - Rakefile
 - lib/loxxy.rb
+- lib/loxxy/ast/ast_builder.rb
+- lib/loxxy/ast/ast_visitor.rb
+- lib/loxxy/ast/lox_binary_expr.rb
+- lib/loxxy/ast/lox_compound_expr.rb
+- lib/loxxy/ast/lox_literal_expr.rb
+- lib/loxxy/ast/lox_node.rb
 - lib/loxxy/datatype/all_datatypes.rb
 - lib/loxxy/datatype/boolean.rb
 - lib/loxxy/datatype/builtin_datatype.rb
@@ -94,11 +100,13 @@ files:
 - lib/loxxy/datatype/true.rb
 - lib/loxxy/front_end/grammar.rb
 - lib/loxxy/front_end/literal.rb
+- lib/loxxy/front_end/parser.rb
 - lib/loxxy/front_end/raw_parser.rb
 - lib/loxxy/front_end/scanner.rb
 - lib/loxxy/version.rb
 - loxxy.gemspec
 - spec/datatype/lx_string_spec.rb
+- spec/front_end/parser_spec.rb
 - spec/front_end/raw_parser_spec.rb
 - spec/front_end/scanner_spec.rb
 - spec/loxxy_spec.rb
@@ -129,6 +137,7 @@ specification_version: 4
 summary: An implementation of the Lox programming language. WIP
 test_files:
 - spec/datatype/lx_string_spec.rb
+- spec/front_end/parser_spec.rb
 - spec/front_end/raw_parser_spec.rb
 - spec/front_end/scanner_spec.rb
 - spec/loxxy_spec.rb