loxxy 0.0.8 → 0.0.13

data/lib/loxxy/ast/ast_visitor.rb

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

data/lib/loxxy/ast/lox_compound_expr.rb

@@ -5,7 +5,7 @@ require_relative 'lox_node'
 module Loxxy
   module Ast
     class LoxCompoundExpr < LoxNode
-      # @return [Array<Ast::LoxNode>]
+      # @return [Array<Ast::LoxNode>] the children nodes (sub-expressions)
       attr_reader :subnodes
 
       # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.

data/lib/loxxy/ast/lox_node.rb

@@ -11,6 +11,11 @@ module Loxxy
         @position = aPosition
       end
 
+      # Notification that the parsing was successfully completed
+      def done!
+        # Default: do nothing ...
+      end
+
       # Abstract method.
       # Part of the 'visitee' role in Visitor design pattern.
       # @param _visitor [LoxxyTreeVisitor] the visitor

data/lib/loxxy/ast/lox_noop_expr.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative 'lox_node'
+
+module Loxxy
+  module Ast
+    class LoxNoopExpr < LoxNode
+      # Abstract method.
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param _visitor [LoxxyTreeVisitor] the visitor
+      def accept(_visitor)
+        # Do nothing...
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/ast/lox_print_stmt.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative 'lox_compound_expr'
+
+module Loxxy
+  module Ast
+    class LoxPrintStmt < LoxCompoundExpr
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      # @param anExpression [Ast::LoxNode] expression to output
+      def initialize(aPosition, anExpression)
+        super(aPosition, [anExpression])
+      end
+
+      # Abstract method.
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [Ast::ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_print_stmt(self)
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/back_end/engine.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# Load all the classes implementing AST nodes
+require_relative '../ast/all_lox_nodes'
+
+module Loxxy
+  module BackEnd
+    # An instance of this class executes the statements as when they
+    # occur during the abstract syntax tree walking.
+    # @note WIP: very crude implementation.
+    class Engine
+      # @return [Hash] A set of configuration options
+      attr_reader :config
+
+      # @return [Array] Data stack used for passing data between statements
+      attr_reader :stack
+
+      # @param theOptions [Hash]
+      def initialize(theOptions)
+        @config = theOptions
+        @ostream = config.include?(:ostream) ? config[:ostream] : $stdout
+        @stack = []
+      end
+
+      # Given an abstract syntax parse tree visitor, luanch the visit
+      # and execute the visit events in the output stream.
+      # @param aVisitor [AST::ASTVisitor]
+      # @return [Loxxy::Datatype::BuiltinDatatype]
+      def execute(aVisitor)
+        aVisitor.subscribe(self)
+        aVisitor.start
+        aVisitor.unsubscribe(self)
+        stack.empty? ? Datatype::Nil.instance : stack.pop
+      end
+
+      # Visit event handling
+
+      def after_print_stmt(_printStmt)
+        tos = stack.pop
+        @ostream.print tos.to_str
+      end
+
+      # @param literalExpr [Ast::LoxLiteralExpr]
+      def before_literal_expr(literalExpr)
+        stack.push(literalExpr.literal)
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/datatype/builtin_datatype.rb

@@ -14,6 +14,12 @@ module Loxxy
         @value = validated_value(aValue)
       end
 
+      # Method called from Lox to obtain the text representation of the boolean.
+      # @return [String]
+      def to_str
+        value.to_s # Default implementation...
+      end
+
       protected
 
       def validated_value(aValue)

data/lib/loxxy/datatype/lx_string.rb

@@ -21,6 +21,12 @@ module Loxxy
         end
       end
 
+      # Method called from Lox to obtain the text representation of the object.
+      # @return [String]
+      def to_str
+        value
+      end
+
       protected
 
       def validated_value(aValue)

data/lib/loxxy/datatype/nil.rb

@@ -13,6 +13,12 @@ module Loxxy
       def initialize
         super(nil)
       end
+
+      # Method called from Lox to obtain the text representation of nil.
+      # @return [String]
+      def to_str
+        'nil'
+      end
     end # class
 
     Nil.instance.freeze # Make the sole instance immutable

data/lib/loxxy/front_end/grammar.rb

@@ -26,8 +26,8 @@ module Loxxy
       add_terminals('EOF')
 
       # Top-level rule that matches an entire Lox program
-      rule('program' => 'EOF')
-      rule('program' => 'declaration_plus EOF')
+      rule('program' => 'EOF').as 'null_program'
+      rule('program' => 'declaration_plus EOF').as 'lox_program'
 
       # Declarations: bind an identifier to something
       rule('declaration_plus' => 'declaration_plus declaration')
@@ -58,7 +58,7 @@ module Loxxy
       rule('statement' => 'whileStmt')
       rule('statement' => 'block')
 
-      rule('exprStmt' => 'expression SEMICOLON')
+      rule('exprStmt' => 'expression SEMICOLON').as 'exprStmt'
 
       rule('forStmt' => 'FOR LEFT_PAREN forControl RIGHT_PAREN statement')
       rule('forControl' => 'forInitialization forTest forUpdate')
@@ -73,7 +73,7 @@ module Loxxy
       rule('elsePart_opt' => 'ELSE statement')
       rule('elsePart_opt' => [])
 
-      rule('printStmt' => 'PRINT expression SEMICOLON')
+      rule('printStmt' => 'PRINT expression SEMICOLON').as 'print_stmt'
       rule('returnStmt' => 'RETURN expression_opt SEMICOLON')
       rule('whileStmt' => 'WHILE LEFT_PAREN expression RIGHT_PAREN statement')
       rule('block' => 'LEFT_BRACE declaration_plus RIGHT_BRACE')
@@ -88,23 +88,23 @@ module Loxxy
       rule('owner_opt' => 'call DOT')
       rule('owner_opt' => [])
       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_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')
-      rule('conjunct_plus' => 'conjunct_plus AND equality')
-      rule('conjunct_' => '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')
-      rule('equalityTest_plus' => 'equalityTest_plus equalityTest comparison')
-      rule('equalityTest_star' => 'equalityTest 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')
-      rule('comparison' => 'term comparisonTest_plus')
-      rule('comparisonTest_plus' => 'comparisonTest_plus comparisonTest term')
-      rule('comparisonTest_plus' => 'comparisonTest 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')

data/lib/loxxy/interpreter.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative './front_end/parser'
+require_relative './ast/ast_visitor'
+require_relative './back_end/engine'
+
+module Loxxy
+  # A Lox tree-walking interpreter.
+  # It acts as a facade object that:
+  # - hides the internal plumbings of the front-end and back-end parts.
+  # - delegates all the core work to its subordinate objects.
+  # @note WIP: very crude implementation.
+  class Interpreter
+    # return [Hash]
+    attr_reader :config
+
+    # @param theOptions [Hash]
+    def initialize(theOptions = {})
+      @config = theOptions
+    end
+
+    # Evaluate the given Lox program.
+    # Return the result of the last executed expression (if any)
+    # @param lox_input [String] Lox program to evaluate
+    # @return [Loxxy::Datatype::BuiltinDatatype]
+    def evaluate(lox_input)
+      # Front-end scans, parses the input and blurps an AST...
+      parser = FrontEnd::Parser.new
+
+      # The AST is the data object passed to the back-end
+      ast_tree = parser.parse(lox_input)
+      visitor = Ast::ASTVisitor.new(ast_tree)
+
+      # Back-end launches the tree walking & reponds to visit events
+      # by executing the code determined by the visited AST node.
+      engine = BackEnd::Engine.new(config)
+      engine.execute(visitor)
+    end
+  end # class
+end # module

data/lib/loxxy/version.rb

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

data/spec/back_end/engine_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+require 'stringio'
+
+# Load the class under test
+require_relative '../../lib/loxxy/back_end/engine'
+
+module Loxxy
+  module BackEnd
+    describe Engine do
+      let(:sample_options) do
+        { ostream: StringIO.new }
+      end
+      subject { Engine.new(sample_options) }
+
+      context 'Initialization:' do
+        it 'should accept a option Hash at initialization' do
+          expect { Engine.new(sample_options) }.not_to raise_error
+        end
+
+        it 'should know its config options' do
+          expect(subject.config).to eq(sample_options)
+        end
+
+        it 'should have an empty stack' do
+          expect(subject.stack).to be_empty
+        end
+      end
+
+      context 'Listening to visitor events:' do
+        let(:greeting) { Datatype::LXString.new('Hello, world') }
+        let(:sample_pos) { double('fake-position') }
+        let(:lit_expr) { Ast::LoxLiteralExpr.new(sample_pos, greeting) }
+
+        it "should react to 'before_literal_expr' event" do
+          expect { subject.before_literal_expr(lit_expr) }.not_to raise_error
+          expect(subject.stack.pop).to eq(greeting)
+        end
+      end
+    end # describe
+  end # module
+end # module

data/spec/datatype/boolean_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+
+# Load the class under test
+require_relative '../../lib/loxxy/datatype/boolean'
+
+module Loxxy
+  module Datatype
+    describe Boolean do
+      let(:thruth_value) { false }
+      subject { Boolean.new(thruth_value) }
+
+      context 'Initialization:' do
+        it 'should accept a boolean value at initialization' do
+          expect { Boolean.new(thruth_value) }.not_to raise_error
+        end
+
+        it 'should know its value' do
+          expect(subject.value).to eq(thruth_value)
+        end
+      end
+
+      context 'Provided services:' do
+        it 'should give its display representation' do
+          expect(subject.to_str).to eq('false')
+        end
+      end
+    end # describe
+  end # module
+end # module