loxxy 0.0.11 → 0.0.16

data/lib/loxxy/datatype/true.rb

@@ -13,6 +13,28 @@ module Loxxy
       def initialize
         super(true)
       end
+
+      # Is this object representing the true value in Lox?
+      # @return [TrueClass]
+      def true?
+        true
+      end
+
+      # Check for equality of a Lox True with another Lox object
+      # @param other [Datatype::True, TrueClass, Object]
+      # @return [Datatype::Boolean]
+      def ==(other)
+        thruthy = other.kind_of?(True) || other.kind_of?(TrueClass)
+        thruthy ? True.instance : False.instance
+      end
+
+      # Check for inequality of a Lox True with another Lox object
+      # @param other [Datatype::BuiltinDatatype, TrueClass, Object]
+      # @return [Datatype::Boolean]
+      def !=(other)
+        thruthy = other.kind_of?(True) || other.kind_of?(TrueClass)
+        thruthy ? False.instance : True.instance
+      end
     end # class
 
     True.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')

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.11'
+  VERSION = '0.0.16'
 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

data/spec/datatype/lx_string_spec.rb

@@ -22,12 +22,39 @@ module Loxxy
       end
 
       context 'Provided services:' do
-        it 'compares with another string' do
-          expect(subject).to eq(sample_text)
-          expect(subject).to eq(LXString.new(sample_text.dup))
+        it 'should give its display representation' do
+          expect(subject.to_str).to eq(sample_text)
+        end
+
+        it 'compares with another Lox string' do
+          result = subject == LXString.new(sample_text.dup)
+          expect(result).to be_true
+
+          result = subject == LXString.new('other-text')
+          expect(result).to be_false
+
+          result = subject == LXString.new('')
+          expect(result).to be_false
+
+          # Two empty strings are equal
+          result = LXString.new('') == LXString.new('')
+          expect(result).to be_true
+        end
+
+        it 'compares with a Ruby string' do
+          result = subject == sample_text.dup
+          expect(result).to be_true
+
+          result = subject == 'other-text'
+          expect(result).to be_false
+
+          result = subject == ''
+          expect(result).to be_false
+        end
 
-          expect(subject).not_to eq('')
-          expect(subject).not_to eq('other-text')
+        it 'performs the concatenation with another string' do
+          concatenation = LXString.new('str') + LXString.new('ing')
+          expect(concatenation == 'string').to be_true
         end
       end
     end # describe

data/spec/datatype/nil_spec.rb

@@ -0,0 +1,26 @@
+# 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 Nil do
+      subject { Nil.instance }
+
+      context 'Initialization:' do
+        it 'should know its value' do
+          expect(subject.value).to be_nil
+        end
+      end
+
+      context 'Provided services:' do
+        it 'should give its display representation' do
+          expect(subject.to_str).to eq('nil')
+        end
+      end
+    end # describe
+  end # module
+end # module

data/spec/datatype/number_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+
+# Load the class under test
+require_relative '../../lib/loxxy/datatype/number'
+
+module Loxxy
+  module Datatype
+    describe Number do
+      let(:sample_value) { -12.34 }
+      subject { Number.new(sample_value) }
+
+      context 'Initialization:' do
+        it 'should accept a Numeric value at initialization' do
+          expect { Number.new(sample_value) }.not_to raise_error
+        end
+
+        it 'should know its value' do
+          expect(subject.value).to eq(sample_value)
+        end
+      end
+
+      context 'Provided services:' do
+        it 'should compare with other Lox numbers' do
+          result = subject == Number.new(sample_value)
+          expect(result).to be_true
+
+          result = subject == Number.new(5)
+          expect(result).to be_false
+        end
+
+        it 'should compare with Ruby numbers' do
+          result = subject == sample_value
+          expect(result).to be_true
+
+          result = subject == 5
+          expect(result).to be_false
+        end
+
+        it 'should give its display representation' do
+          expect(subject.to_str).to eq(sample_value.to_s)
+        end
+
+        it 'should compute the addition with another number' do
+          addition = subject + Number.new(10)
+          expect(addition == -2.34).to be_true
+        end
+
+        it 'should compute the subtraction with another number' do
+          subtraction = subject - Number.new(10)
+          expect(subtraction == -22.34).to be_true
+        end
+      end
+    end # describe
+  end # module
+end # module

data/spec/front_end/parser_spec.rb

@@ -37,7 +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('EOF')
+          expect(aParseTree.root).to be_kind_of(Ast::LoxNoopExpr)
         end
 
         it 'should cope with an empty input' do
@@ -64,7 +64,7 @@ module Loxxy
         it 'should parse a false literal' do
           input = 'false;'
           ptree = subject.parse(input)
-          leaf = walk_subnodes(ptree.root, [0, 0])
+          leaf = ptree.root
           expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
           expect(leaf.literal).to be_equal(Datatype::False.instance)
         end
@@ -72,7 +72,7 @@ module Loxxy
         it 'should parse a true literal' do
           input = 'true;'
           ptree = subject.parse(input)
-          leaf = walk_subnodes(ptree.root, [0, 0])
+          leaf = ptree.root
           expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
           expect(leaf.literal).to be_equal(Datatype::True.instance)
         end
@@ -81,7 +81,7 @@ module Loxxy
           inputs = %w[1234; 12.34;]
           inputs.each do |source|
             ptree = subject.parse(source)
-            leaf = walk_subnodes(ptree.root, [0, 0])
+            leaf = ptree.root
             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)
@@ -96,7 +96,7 @@ module Loxxy
           ]
           inputs.each do |source|
             ptree = subject.parse(source)
-            leaf = walk_subnodes(ptree.root, [0, 0])
+            leaf = ptree.root
             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(/(^")|(";$)/, ''))
@@ -106,7 +106,7 @@ module Loxxy
         it 'should parse a nil literal' do
           input = 'nil;'
           ptree = subject.parse(input)
-          leaf = walk_subnodes(ptree.root, [0, 0])
+          leaf = ptree.root
           expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
           expect(leaf.literal).to be_equal(Datatype::Nil.instance)
         end
@@ -119,21 +119,11 @@ module Loxxy
             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')
+          prnt_stmt = ptree.root
+          expect(prnt_stmt).to be_kind_of(Ast::LoxPrintStmt)
+          expect(prnt_stmt.subnodes[0]).to be_kind_of(Ast::LoxLiteralExpr)
+          expect(prnt_stmt.subnodes[0].literal).to be_kind_of(Loxxy::Datatype::LXString)
+          expect(prnt_stmt.subnodes[0].literal.value).to eq('Hello, world!')
         end
       end # context
 
@@ -141,10 +131,7 @@ LOX_END
         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]
+          expr = ptree.root
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:+)
           expect(expr.operands[0].literal.value).to eq(123)
@@ -154,10 +141,7 @@ LOX_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]
+          expr = ptree.root
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:-)
           expect(expr.operands[0].literal.value).to eq(4)
@@ -167,10 +151,7 @@ LOX_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]
+          expr = ptree.root
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:-)
           expect(expr.operands[0]).to be_kind_of(Ast::LoxBinaryExpr)
@@ -183,10 +164,7 @@ LOX_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]
+          expr = ptree.root
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:/)
           expect(expr.operands[0].literal.value).to eq(8)
@@ -196,10 +174,7 @@ LOX_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]
+          expr = ptree.root
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:*)
           expect(expr.operands[0].literal.value).to eq(12.34)
@@ -209,10 +184,7 @@ LOX_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]
+          expr = ptree.root
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:/)
           expect(expr.operands[0]).to be_kind_of(Ast::LoxBinaryExpr)
@@ -225,10 +197,7 @@ LOX_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]
+          expr = ptree.root
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:+)
           expect(expr.operands[0].literal.value).to eq(5)
@@ -243,10 +212,7 @@ LOX_END
         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]
+          expr = ptree.root
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:+)
           expect(expr.operands[0].literal.value).to eq('Lo')
@@ -259,10 +225,7 @@ LOX_END
         %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]
+          expr = ptree.root
           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)
@@ -276,10 +239,7 @@ LOX_END
           %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]
+            expr = ptree.root
             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)
@@ -290,10 +250,7 @@ LOX_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]
+          expr = ptree.root
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:==)
           expect(expr.operands[0]).to be_kind_of(Ast::LoxBinaryExpr)
@@ -309,10 +266,7 @@ LOX_END
           %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]
+            expr = ptree.root
             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)
@@ -329,10 +283,7 @@ LOX_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]
+          expr = ptree.root
           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)