loxxy 0.0.20 → 0.0.25

data/lib/loxxy/back_end/variable.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'entry'
+require_relative '../datatype/all_datatypes'
+
+module Loxxy
+  module BackEnd
+    # Representation of a Lox variable.
+    # It is a named slot that can be associated with a value at the time.
+    class Variable
+      include Entry # Add expected behaviour for symbol table entries
+
+      # @return [Datatype::BuiltinDatatype] the value assigned to the variable
+      attr_reader :value
+
+      # Create a variable with given name and initial value
+      # @param aName [String] The name of the variable
+      # @param aValue [Datatype::BuiltinDatatype] the initial assigned value
+      def initialize(aName, aValue = Datatype::Nil.instance)
+        init_name(aName)
+        assign(aValue)
+      end
+
+      # @param aValue [Datatype::BuiltinDatatype] the assigned value
+      def assign(aValue)
+        @value = aValue
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/datatype/builtin_datatype.rb

@@ -62,6 +62,12 @@ module Loxxy
         value.to_s # Default implementation...
       end
 
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [Ast::ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_builtin(self)
+      end
+
       protected
 
       def validated_value(aValue)

data/lib/loxxy/front_end/grammar.rb

@@ -30,8 +30,8 @@ module Loxxy
       rule('program' => 'declaration_plus EOF').as 'lox_program'
 
       # Declarations: bind an identifier to something
-      rule('declaration_plus' => 'declaration_plus declaration')
-      rule('declaration_plus' => 'declaration')
+      rule('declaration_plus' => 'declaration_plus declaration').as 'declaration_plus_more'
+      rule('declaration_plus' => 'declaration').as 'declaration_plus_end'
       rule('declaration' => 'classDecl')
       rule('declaration' => 'funDecl')
       rule('declaration' => 'varDecl')
@@ -46,8 +46,8 @@ module Loxxy
 
       rule('funDecl' => 'FUN function')
 
-      rule('varDecl' => 'VAR IDENTIFIER SEMICOLON')
-      rule('varDecl' => 'VAR IDENTIFIER EQUAL expression SEMICOLON')
+      rule('varDecl' => 'VAR IDENTIFIER SEMICOLON').as 'var_declaration'
+      rule('varDecl' => 'VAR IDENTIFIER EQUAL expression SEMICOLON').as 'var_initialization'
 
       # Statements: produce side effects, but don't introduce bindings
       rule('statement' => 'exprStmt')
@@ -76,14 +76,14 @@ module Loxxy
       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')
+      rule('block' => 'LEFT_BRACE declaration_plus RIGHT_BRACE').as 'block_stmt'
       rule('block' => 'LEFT_BRACE RIGHT_BRACE')
 
       # Expressions: produce values
       rule('expression_opt' => 'expression')
       rule('expression_opt' => [])
       rule('expression' => 'assignment')
-      rule('assignment' => 'owner_opt IDENTIFIER EQUAL assignment')
+      rule('assignment' => 'owner_opt IDENTIFIER EQUAL assignment').as 'assign_expr'
       rule('assignment' => 'logic_or')
       rule('owner_opt' => 'call DOT')
       rule('owner_opt' => [])
@@ -137,7 +137,7 @@ module Loxxy
       rule('primary' => 'THIS')
       rule('primary' => 'NUMBER').as 'literal_expr'
       rule('primary' => 'STRING').as 'literal_expr'
-      rule('primary' => 'IDENTIFIER')
+      rule('primary' => 'IDENTIFIER').as 'variable_expr'
       rule('primary' => 'LEFT_PAREN expression RIGHT_PAREN').as 'grouping_expr'
       rule('primary' => 'SUPER DOT IDENTIFIER')
 

data/lib/loxxy/interpreter.rb

@@ -31,7 +31,7 @@ module Loxxy
       ast_tree = parser.parse(lox_input)
       visitor = Ast::ASTVisitor.new(ast_tree)
 
-      # Back-end launches the tree walking & reponds to visit events
+      # Back-end launches the tree walking & responds to visit events
       # by executing the code determined by the visited AST node.
       engine = BackEnd::Engine.new(config)
       engine.execute(visitor)

data/lib/loxxy/version.rb

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

data/spec/back_end/engine_spec.rb

@@ -31,8 +31,17 @@ module Loxxy
       context 'Listening to visitor events:' do
         let(:greeting) { Datatype::LXString.new('Hello, world') }
         let(:sample_pos) { double('fake-position') }
+        let(:var_decl) { Ast::LoxVarStmt.new(sample_pos, 'greeting', greeting) }
         let(:lit_expr) { Ast::LoxLiteralExpr.new(sample_pos, greeting) }
 
+
+        it "should react to 'after_var_stmt' event" do
+          expect { subject.after_var_stmt(var_decl) }.not_to raise_error
+          current_env = subject.symbol_table.current_env
+          expect(current_env.defns['greeting']).to be_kind_of(Variable)
+          expect(current_env.defns['greeting'].value).to eq(greeting)
+        end
+
         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)

data/spec/back_end/environment_spec.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+
+# Load the class under test
+require_relative '../../lib/loxxy/back_end/environment'
+
+module Loxxy
+  module BackEnd
+    describe Environment do
+      let(:foo) { Datatype::LXString.new('foo') }
+      let(:bar) { Datatype::LXString.new('bar') }
+      let(:mother) { Environment.new }
+      subject { Environment.new(mother) }
+
+      # Shortand factory method.
+      def var(aName, aValue)
+        Variable.new(aName, aValue)
+      end
+
+      context 'Initialization:' do
+        it 'could be initialized without argument' do
+          expect { Environment.new }.not_to raise_error
+        end
+
+        it 'could be initialized with a parent environment' do
+          expect { Environment.new(mother) }.not_to raise_error
+        end
+
+        it "shouldn't have definitions by default" do
+          expect(subject.defns).to be_empty
+        end
+
+        it 'should know its parent (if any)' do
+          expect(subject.enclosing).to eq(mother)
+        end
+      end # context
+
+      context 'Provided services:' do
+        it 'should accept the addition of a variable' do
+          subject.insert(var('a', foo))
+          expect(subject.defns).not_to be_empty
+          var_a = subject.defns['a']
+          expect(var_a).to be_kind_of(Variable)
+          expect(var_a.name).to eq('a')
+        end
+
+        it 'should accept the addition of multiple variables' do
+          subject.insert(var('a', foo))
+          expect(subject.defns).not_to be_empty
+
+          subject.insert(var('b', bar))
+          var_b = subject.defns['b']
+          expect(var_b).to be_kind_of(Variable)
+          expect(var_b.name).to eq('b')
+        end
+
+        # it 'should set the suffix of just created variable' do
+          # subject.insert(var('a'))
+          # var_a = subject.defns['a']
+          # expect(var_a.suffix).to eq("_#{subject.object_id.to_s(16)}")
+        # end
+
+        # it 'should complain when variable names collide' do
+          # subject.insert(var('c'))
+          # expect(subject.defns['c']).to be_kind_of(Datatype::Variable)
+          # err = StandardError
+          # err_msg = "Variable with name 'c' already exists."
+          # expect { subject.insert(var('c')) }.to raise_error(err, err_msg)
+        # end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/back_end/symbol_table_spec.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../../lib/loxxy/back_end/variable'
+
+# Load the class under test
+require_relative '../../lib/loxxy/back_end/symbol_table'
+
+module Loxxy
+  module BackEnd
+    describe SymbolTable do
+      subject { SymbolTable.new }
+
+      context 'Initialization:' do
+        it 'should be initialized without argument' do
+          expect { SymbolTable.new }.not_to raise_error
+        end
+
+        it 'should have a root BackEnd' do
+          expect(subject.root).not_to be_nil
+          expect(subject.current_env).to eq(subject.root)
+          expect(subject.root).to be_kind_of(BackEnd::Environment)
+        end
+
+        it "shouldn't have names at initialization" do
+          expect(subject.name2envs).to be_empty
+        end
+
+        it 'should be empty at initialization' do
+          expect(subject).to be_empty
+        end
+      end # context
+
+      context 'Provided services:' do
+        def var(aName)
+          Variable.new(aName)
+        end
+
+        it 'should allow the addition of a variable' do
+          expect { subject.insert(var('q')) }.not_to raise_error
+          expect(subject).not_to be_empty
+          expect(subject.name2envs['q']).to be_kind_of(Array)
+          expect(subject.name2envs['q'].size).to eq(1)
+          expect(subject.name2envs['q'].first).to eq(subject.current_env)
+          expect(subject.current_env.defns['q']).to be_kind_of(BackEnd::Variable)
+        end
+
+        it 'should allow the addition of several labels for same env' do
+          subject.insert(var('q'))
+          # expect(i_name).to match(/^q_[0-9a-z]*$/)
+
+          expect { subject.insert(var('x')) }.not_to raise_error
+          expect(subject.name2envs['x']).to be_kind_of(Array)
+          expect(subject.name2envs['x'].first).to eq(subject.current_env)
+          expect(subject.current_env.defns['x']).to be_kind_of(BackEnd::Variable)
+        end
+
+        it 'should allow the entry into a new scope' do
+          subject.insert(var('q'))
+          new_env = BackEnd::Environment.new
+          expect { subject.enter_environment(new_env) }.not_to raise_error
+          expect(subject.current_env).to eq(new_env)
+          expect(subject.current_env.enclosing).to eq(subject.root)
+          expect(subject.name2envs['q']).to eq([subject.root])
+        end
+
+        it 'should allow the addition of same name in different scopes' do
+          subject.insert(var('q'))
+          subject.enter_environment(BackEnd::Environment.new)
+          subject.insert(var('q'))
+          expect(subject.name2envs['q']).to be_kind_of(Array)
+          expect(subject.name2envs['q'].size).to eq(2)
+          expect(subject.name2envs['q'].first).to eq(subject.root)
+          expect(subject.name2envs['q'].last).to eq(subject.current_env)
+          expect(subject.current_env.defns['q']).to be_kind_of(BackEnd::Variable)
+        end
+
+        it 'should allow the removal of a scope' do
+          subject.insert(var('q'))
+          new_env = BackEnd::Environment.new
+          subject.enter_environment(new_env)
+          subject.insert(var('q'))
+          expect(subject.name2envs['q'].size).to eq(2)
+
+          expect { subject.leave_environment }.not_to raise_error
+          expect(subject.current_env).to eq(subject.root)
+          expect(subject.name2envs['q'].size).to eq(1)
+          expect(subject.name2envs['q']).to eq([subject.root])
+        end
+
+        it 'should allow the search of an entry based on its name' do
+          subject.insert(var('q'))
+          subject.insert(var('x'))
+          subject.enter_environment(BackEnd::Environment.new)
+          subject.insert(var('q'))
+          subject.insert(var('y'))
+
+          # Search for unknown name
+          expect(subject.lookup('z')).to be_nil
+
+          # Search for existing unique names
+          expect(subject.lookup('y')).to eq(subject.current_env.defns['y'])
+          expect(subject.lookup('x')).to eq(subject.root.defns['x'])
+
+          # Search for redefined name
+          expect(subject.lookup('q')).to eq(subject.current_env.defns['q'])
+        end
+
+        # it 'should allow the search of an entry based on its i_name' do
+          # subject.insert(var('q'))
+          # i_name_x = subject.insert(var('x'))
+          # subject.enter_environment(BackEnd::Environment.new)
+          # i_name_q2 = subject.insert(var('q'))
+          # i_name_y = subject.insert(var('y'))
+
+          # # Search for unknown i_name
+          # expect(subject.lookup_i_name('dummy')).to be_nil
+
+          # curr_scope = subject.current_env
+          # # # Search for existing unique names
+          # expect(subject.lookup_i_name(i_name_y)).to eq(curr_scope.defns['y'])
+          # expect(subject.lookup_i_name(i_name_x)).to eq(subject.root.defns['x'])
+
+          # # Search for redefined name
+          # expect(subject.lookup_i_name(i_name_q2)).to eq(curr_scope.defns['q'])
+        # end
+
+        it 'should list all the variables defined in all the szcope chain' do
+          subject.insert(var('q'))
+          subject.enter_environment(BackEnd::Environment.new)
+          subject.insert(var('x'))
+          subject.enter_environment(BackEnd::Environment.new)
+          subject.insert(var('y'))
+          subject.insert(var('x'))
+
+          vars = subject.all_variables
+          expect(vars.map(&:name)).to eq(%w[q x y x])
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/back_end/variable_spec.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative '../spec_helper' # Use the RSpec framework
+
+# Load the class under test
+require_relative '../../lib/loxxy/back_end/variable'
+
+
+module Loxxy
+  module BackEnd
+    describe Variable do
+      let(:sample_name) { 'iAmAVariable' }
+      let(:sample_value) { 'here is my value' }
+      subject { Variable.new(sample_name, sample_value) }
+
+      context 'Initialization:' do
+        it 'should be initialized with a name and a value, or...' do
+          expect { Variable.new(sample_name, sample_value) }.not_to raise_error
+        end
+
+        it 'should be initialized with just a name' do
+          expect { Variable.new(sample_name) }.not_to raise_error
+        end
+
+        it 'should know its name' do
+          expect(subject.name).to eq(sample_name)
+        end
+
+        it 'should have a frozen name' do
+          expect(subject.name).to be_frozen
+        end
+
+        it 'should know its value (if provided)' do
+          expect(subject.value).to eq(sample_value)
+        end
+
+        it 'should have a nil value otherwise' do
+          instance = Variable.new(sample_name)
+          expect(instance.value).to eq(Datatype::Nil.instance)
+        end
+
+        # it 'should know its default internal name' do
+          # # By default: internal name == label
+          # expect(subject.i_name).to eq(subject.label)
+        # end
+
+        # it 'should have a nil suffix' do
+          # expect(subject.suffix).to be_nil
+        # end
+      end # context
+
+      context 'Provided service:' do
+        let(:sample_suffix) { 'sample-suffix' }
+        it 'should have a label equal to its user-defined name' do
+          # expect(subject.label).to eq(subject.name)
+        end
+
+        it 'should accept a suffix' do
+          # expect { subject.suffix = sample_suffix }.not_to raise_error
+          # expect(subject.suffix).to eq(sample_suffix)
+        end
+
+        it 'should calculate its internal name' do
+          # # Rule: empty suffix => internal name == label
+          # subject.suffix = ''
+          # expect(subject.i_name).to eq(subject.label)
+
+          # # Rule: suffix starting underscore: internal name = label + suffix
+          # subject.suffix = '_10'
+          # expect(subject.i_name).to eq(subject.label + subject.suffix)
+
+          # # Rule: ... otherwise: internal name == suffix
+          # subject.suffix = sample_suffix
+          # expect(subject.i_name).to eq(subject.suffix)
+        end
+      end # context
+    end # describe
+  end # module
+end # module

data/spec/front_end/parser_spec.rb

@@ -64,7 +64,8 @@ module Loxxy
         it 'should parse a false literal' do
           input = 'false;'
           ptree = subject.parse(input)
-          leaf = ptree.root
+          expect(ptree.root).to be_kind_of(Ast::LoxSeqDecl)
+          leaf = ptree.root.subnodes[0]
           expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
           expect(leaf.literal).to be_equal(Datatype::False.instance)
         end
@@ -72,7 +73,8 @@ module Loxxy
         it 'should parse a true literal' do
           input = 'true;'
           ptree = subject.parse(input)
-          leaf = ptree.root
+          expect(ptree.root).to be_kind_of(Ast::LoxSeqDecl)
+          leaf = ptree.root.subnodes[0]
           expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
           expect(leaf.literal).to be_equal(Datatype::True.instance)
         end
@@ -81,7 +83,7 @@ module Loxxy
           inputs = %w[1234; 12.34;]
           inputs.each do |source|
             ptree = subject.parse(source)
-            leaf = ptree.root
+            leaf = ptree.root.subnodes[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)
@@ -96,7 +98,7 @@ module Loxxy
           ]
           inputs.each do |source|
             ptree = subject.parse(source)
-            leaf = ptree.root
+            leaf = ptree.root.subnodes[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(/(^")|(";$)/, ''))
@@ -106,7 +108,7 @@ module Loxxy
         it 'should parse a nil literal' do
           input = 'nil;'
           ptree = subject.parse(input)
-          leaf = ptree.root
+          leaf = ptree.root.subnodes[0]
           expect(leaf).to be_kind_of(Ast::LoxLiteralExpr)
           expect(leaf.literal).to be_equal(Datatype::Nil.instance)
         end
@@ -119,7 +121,7 @@ module Loxxy
             print "Hello, world!";
 LOX_END
           ptree = subject.parse(program)
-          prnt_stmt = ptree.root
+          prnt_stmt = ptree.root.subnodes[0]
           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)
@@ -131,7 +133,7 @@ LOX_END
         it 'should parse the addition of two number literals' do
           input = '123 + 456;'
           ptree = subject.parse(input)
-          expr = ptree.root
+          expr = ptree.root.subnodes[0]
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:+)
           expect(expr.operands[0].literal.value).to eq(123)
@@ -141,7 +143,7 @@ LOX_END
         it 'should parse the subtraction of two number literals' do
           input = '4 - 3;'
           ptree = subject.parse(input)
-          expr = ptree.root
+          expr = ptree.root.subnodes[0]
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:-)
           expect(expr.operands[0].literal.value).to eq(4)
@@ -151,7 +153,7 @@ LOX_END
         it 'should parse multiple additive operations' do
           input = '5 + 2 - 3;'
           ptree = subject.parse(input)
-          expr = ptree.root
+          expr = ptree.root.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)
@@ -164,7 +166,7 @@ LOX_END
         it 'should parse the division of two number literals' do
           input = '8 / 2;'
           ptree = subject.parse(input)
-          expr = ptree.root
+          expr = ptree.root.subnodes[0]
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:/)
           expect(expr.operands[0].literal.value).to eq(8)
@@ -174,7 +176,7 @@ LOX_END
         it 'should parse the product of two number literals' do
           input = '12.34 * 0.3;'
           ptree = subject.parse(input)
-          expr = ptree.root
+          expr = ptree.root.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)
@@ -184,7 +186,7 @@ LOX_END
         it 'should parse multiple multiplicative operations' do
           input = '5 * 2 / 3;'
           ptree = subject.parse(input)
-          expr = ptree.root
+          expr = ptree.root.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)
@@ -197,7 +199,7 @@ LOX_END
         it 'should parse combination of terms and factors' do
           input = '5 + 2 / 3;'
           ptree = subject.parse(input)
-          expr = ptree.root
+          expr = ptree.root.subnodes[0]
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:+)
           expect(expr.operands[0].literal.value).to eq(5)
@@ -212,7 +214,7 @@ LOX_END
         it 'should parse the concatenation of two string literals' do
           input = '"Lo" + "ve";'
           ptree = subject.parse(input)
-          expr = ptree.root
+          expr = ptree.root.subnodes[0]
           expect(expr).to be_kind_of(Ast::LoxBinaryExpr)
           expect(expr.operator).to eq(:+)
           expect(expr.operands[0].literal.value).to eq('Lo')
@@ -225,7 +227,7 @@ LOX_END
         %w[> >= < <=].each do |predicate|
           input = "3 #{predicate} 2;"
           ptree = subject.parse(input)
-          expr = ptree.root
+          expr = ptree.root.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)
@@ -239,7 +241,7 @@ LOX_END
           %w[!= ==].each do |predicate|
             input = "3 #{predicate} 2;"
             ptree = subject.parse(input)
-            expr = ptree.root
+            expr = ptree.root.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)
@@ -250,7 +252,7 @@ LOX_END
         it 'should parse combination of equality expressions' do
           input = '5 != 2 == false; // A bit contrived example'
           ptree = subject.parse(input)
-          expr = ptree.root
+          expr = ptree.root.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)
@@ -266,7 +268,7 @@ LOX_END
           %w[or and].each do |connector|
             input = "5 > 2 #{connector} 3 <= 4;"
             ptree = subject.parse(input)
-            expr = ptree.root
+            expr = ptree.root.subnodes[0]
             expect(expr).to be_kind_of(Ast::LoxLogicalExpr)
             expect(expr.operator).to eq(connector.to_sym)
             expect(expr.operands[0]).to be_kind_of(Ast::LoxBinaryExpr)
@@ -283,7 +285,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)
-          expr = ptree.root
+          expr = ptree.root.subnodes[0]
           expect(expr).to be_kind_of(Ast::LoxLogicalExpr)
           expect(expr.operator).to eq(:or) # or has lower precedence than and
           expect(expr.operands[0]).to be_kind_of(Ast::LoxLogicalExpr)