loxxy 0.0.6 → 0.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de9d3c24db15863c6ea99c2a9c8a2e413b2a243ddf79de28da5583d1944fc4e4
-  data.tar.gz: a5f6dacfd67b6833e3c051273765e1d94c95d1d1700a974a09a3caf0519a1570
+  metadata.gz: 583f5c2f620ea8f45b339607103955eda2f32c02f0358ccb88cf4d20b4398d21
+  data.tar.gz: f349b949c1315473027eaaab589ff1cf2da89deca3b243cd1508c088bf9a9cc5
 SHA512:
-  metadata.gz: 3c4bd62b1a9cd960ee97d807a5f44a26cc360df4344975210ca967117c62585a2138fef382ffb5ea7d79f002b9a9a951ba77622cb8d799973c0ad8a24ffbae52
-  data.tar.gz: 5b14b5c4a6ae98f5e1d9a819160393393654cc3d817e36f1da68cd12fcfedfbce47097463dc6babcf36b5582e970ea41b4cef5ebceb768b962c8bd7b02bcb553
+  metadata.gz: 9c93648c634783348a22b3b65cf710a59c0ca5e3cefc5a20d7c60b9b429b4334e1e5603cc2bf74f302aed881daa71634cb7253445b3f376838197637f79f8cc7
+  data.tar.gz: 67d60e89985322911a7842a2b5fc2e22b4ccc3136ffa216027089ea05ea56a6932d1de9b8917173ad072695aaa6abb2147d456f54d09f2878d7831937c42af74

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,59 @@
+## [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.
+
+## 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.
 

data/README.md

@@ -1,30 +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.
-- [DONE] Tailored parser for generating AST (Abstract Syntax Tree)
-- [STARTED] Custom AST builder class  
-- [TODO] 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.
+## 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.
+  (Abstract Syntax Tree) that will be used by the future tree-walking interpreter.
+  Currently it generates AST for arithmetic expressions with literal numbers only.
 
-### Example using RawParser class
+## 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
+- [X] 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'
 
@@ -48,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
@@ -58,70 +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: ''
 ```
 
-### Example using Parser class
-Except for the `Parser` class name, this example is identical 
-to the previous one.
-
-```ruby
-require 'loxxy'
-
-
-lox_input = <<-LOX_END
-  // Your first Lox program!
-  print "Hello, world!";
-LOX_END
-
-# Show that the parser accepts the above program
-parser = Loxxy::FrontEnd::Parser.new
-
-# Now parse the input into an abstract parse tree...
-ptree = parser.parse(lox_input)
-
-# Display the parse tree thanks to Rley utility classes...
-visitor = Rley::ParseTreeVisitor.new(ptree)
-tree_formatter = Rley::Formatter::Asciitree.new($stdout)
-tree_formatter.render(visitor)
-```
-
-However the output differs significantly:
-```
-program
-+-- declaration_star
-|   +-- printStmt
-|       +-- PRINT: 'print'
-|       +-- logic_or
-|       |   +-- logic_and
-|       |       +-- equality
-|       |           +-- comparison
-|       |               +-- term
-|       |                   +-- factor
-|       |                       +-- call
-|       |                           +-- STRING: '"Hello, world!"'
-|       +-- SEMICOLON: ';'
-+-- EOF: ''
-```
-
-
-
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -143,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/ast/ast_builder.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require_relative '../datatype/all_datatypes'
+require_relative 'lox_literal_expr'
+require_relative 'lox_binary_expr'
 
 module Loxxy
   module Ast
@@ -8,13 +10,31 @@ 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
+      # 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
 
@@ -69,6 +89,129 @@ 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
+
+      # 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)
+        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').as 'logic_or_plus'
+      rule('disjunct_plus' => 'disjunct_plus OR logic_and').as 'logic_or_plus_more'
+      rule('disjunct_plus' => 'OR logic_and').as 'logic_or_plus_end'
+      rule('logic_and' => 'equality')
+      rule('logic_and' => 'equality conjunct_plus').as 'logic_and_plus'
+      rule('conjunct_plus' => 'conjunct_plus AND equality').as 'logic_and_plus_more'
+      rule('conjunct_plus' => 'AND equality').as 'logic_and_plus_end'
+      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')

data/lib/loxxy/version.rb

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

data/spec/front_end/parser_spec.rb

@@ -10,6 +10,18 @@ module Loxxy
     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
@@ -25,11 +37,7 @@ module Loxxy
           # 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('program')
-          expect(aParseTree.root.subnodes.size).to eq(1)
-          eof = aParseTree.root.subnodes[0]
-          expect(eof).to be_kind_of(Rley::PTree::TerminalNode)
-          expect(eof.symbol.name).to eq('EOF')
+          expect(aParseTree.root.symbol.name).to eq('EOF')
         end
 
         it 'should cope with an empty input' do
@@ -52,18 +60,59 @@ module Loxxy
         end
       end # context
 
-      context 'Parsing expressions:' do
-        # 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]
+      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
 
-          curr_node
+        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!
@@ -72,25 +121,237 @@ LOX_END
           ptree = subject.parse(program)
           root = ptree.root
           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')
-          prnt_stmt = decls.subnodes[0]
+          (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(Rley::PTree::NonTerminalNode)
-          # leaf_node = walk_subnodes(prnt_stmt, [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
-          # expect(leaf_node).to be_kind_of(Rley::PTree::TerminalNode)
-          # expect(leaf_node.symbol.name).to eq('STRING')
-          # expect(leaf_node.token.value).to eq('Hello, world!')
+          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
+
+      context 'Parsing logical expressions' do
+        it 'should parse the logical operations betweentwo sub-expression' do
+          %w[or and].each do |connector|
+            input = "5 > 2 #{connector} 3 <= 4;"
+            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(connector.to_sym)
+            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]).to be_kind_of(Ast::LoxBinaryExpr)
+            expect(expr.operands[1].operator).to eq(:<=)
+            expect(expr.operands[1].operands[0].literal.value).to eq(3)
+            expect(expr.operands[1].operands[1].literal.value).to eq(4)
+          end
+        end
+
+        it 'should parse a combinations of logical expressions' do
+          input = '4 > 3 and 1 < 2 or 4 >= 5;'
+          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(:or) # or has lower precedence than and
+          expect(expr.operands[0]).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(expr.operands[0].operator).to eq(:and)
+          conjuncts = expr.operands[0].operands
+          expect(conjuncts[0]).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(conjuncts[0].operator).to eq(:>)
+          expect(conjuncts[0].operands[0].literal.value).to eq(4)
+          expect(conjuncts[0].operands[1].literal.value).to eq(3)
+          expect(conjuncts[1]).to be_kind_of(Ast::LoxBinaryExpr)
+          expect(conjuncts[1].operator).to eq(:<)
+          expect(conjuncts[1].operands[0].literal.value).to eq(1)
+          expect(conjuncts[1].operands[1].literal.value).to eq(2)
+          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(4)
+          expect(expr.operands[1].operands[1].literal.value).to eq(5)
+        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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: loxxy
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.11
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-03 00:00:00.000000000 Z
+date: 2021-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -85,6 +85,11 @@ files:
 - 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