loxxy 0.0.17 → 0.0.22

data/lib/loxxy/back_end/symbol_table.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require_relative 'environment'
+
+module Loxxy
+  module BackEnd
+    # A symbol table is basically a mapping from a name onto an object
+    # that holds information associated with that name. It is a data structure
+    # that keeps track of variables and their respective environment where they are
+    # declared. The key requirements for the symbol are:
+    # - To perform fast lookup operations: given a name, retrieve the corresponding
+    #   object.
+    # - To allow the efficient insertion of names and related information
+    # - To support the nesting of environments
+    # - To handle the entry environment and exit environment events,
+    # - To cope with variable redefinition in nested environment
+    # The terminology 'symbol table' comes from the compiler design
+    # community.
+    class SymbolTable
+      # Mapping between a name and the environment(s) where it is defined
+      # @return [Hash{String => Array<Environment>}]
+      attr_reader :name2envs
+
+      # @return [Environment] The top-level environment (= root of environment tree)
+      attr_reader :root
+
+      # @return [Environment] The current environment.
+      attr_reader :current_env
+
+      # Build symbol table with given environment as root.
+      # @param anEnv [BackEnd::Environment,NilClass] The top-level Environment
+      def initialize(anEnv = nil)
+        @name2envs = {}
+        init_root(anEnv) # Set default (global) environment
+      end
+
+      # Returns iff there is no entry in the symbol table
+      # @return [Boolean]
+      def empty?
+        name2envs.empty?
+      end
+
+      # Use this method to signal the interpreter that a given environment
+      # to be a child of current environment and to be itself the new current environment.
+      # @param anEnv [BackEnd::Environment] the Environment that
+      def enter_environment(anEnv)
+        anEnv.parent = current_env
+        @current_env = anEnv
+      end
+
+      def leave_environment
+        current_env.defns.each_pair do |nm, _item|
+          environments = name2envs[nm]
+          if environments.size == 1
+            name2envs.delete(nm)
+          else
+            environments.pop
+            name2envs[nm] = environments
+          end
+        end
+        raise StandardError, 'Cannot remove root environment.' if current_env == root
+
+        @current_env = current_env.parent
+      end
+
+      # Add an entry with given name to current environment.
+      # @param anEntry [Variable]
+      # @return [String] Internal name of the entry
+      def insert(anEntry)
+        current_env.insert(anEntry)
+        name = anEntry.name
+        if name2envs.include?(name)
+          name2envs[name] << current_env
+        else
+          name2envs[name] = [current_env]
+        end
+
+        anEntry.name # anEntry.i_name
+      end
+
+      # Search for the object with the given name
+      # @param aName [String]
+      # @return [BackEnd::Variable]
+      def lookup(aName)
+        environments = name2envs.fetch(aName, nil)
+        return nil if environments.nil?
+
+        sc = environments.last
+        sc.defns[aName]
+      end
+
+      # Search for the object with the given i_name
+      # @param anIName [String]
+      # @return [BackEnd::Variable]
+      # def lookup_i_name(anIName)
+        # found = nil
+        # environment = current_env
+
+        # begin
+          # found = environment.defns.values.find { |e| e.i_name == anIName }
+          # break if found
+
+          # environment = environment.parent
+        # end while environment
+
+        # found
+      # end
+
+      # Return all variables defined in the current .. root chain.
+      # Variables are sorted top-down and left-to-right.
+      def all_variables
+        vars = []
+        skope = current_env
+        while skope
+          vars_of_environment = skope.defns.select { |_, item| item.kind_of?(Variable) }
+          vars = vars_of_environment.values.concat(vars)
+          skope = skope.parent
+        end
+
+        vars
+      end
+
+      private
+
+      def init_root(anEnv)
+        @root = valid_environment(anEnv)
+        @current_env = @root
+      end
+
+      def valid_environment(anEnv)
+        anEnv.nil? ? Environment.new : anEnv
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/back_end/variable.rb

@@ -0,0 +1,25 @@
+# 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_accessor :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)
+        @value = aValue
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/datatype/builtin_datatype.rb

@@ -28,6 +28,13 @@ module Loxxy
         true # Default implementation
       end
 
+      # Check for inequality of this object with another Lox object
+      # @param other [Datatype::BuiltinDatatype, Object]
+      # @return [Datatype::Boolean]
+      def !=(other)
+        !(self == other)
+      end
+
       # Negation ('not')
       # Returns a boolean with opposite truthiness value.
       # @return [Datatype::Boolean]
@@ -35,11 +42,18 @@ module Loxxy
         falsey? ? True.instance : False.instance
       end
 
-      # Check for inequality of this object with another Lox object
-      # @param other [Datatype::BuiltinDatatype, Object]
-      # @return [Datatype::Boolean]
-      def !=(other)
-        !(self == other)
+      # Returns the first falsey argument (if any),
+      # otherwise returns the last truthy argument.
+      # @param operand2 [Loxxy::Datatype::BuiltinDatatype, Proc]
+      def and(operand2)
+        falsey? ? self : logical_2nd_arg(operand2)
+      end
+
+      # Returns the first truthy argument (if any),
+      # otherwise returns the last falsey argument.
+      # @param operand2 [Loxxy::Datatype::BuiltinDatatype, Proc]
+      def or(operand2)
+        truthy? ? self : logical_2nd_arg(operand2)
       end
 
       # Method called from Lox to obtain the text representation of the boolean.
@@ -53,6 +67,19 @@ module Loxxy
       def validated_value(aValue)
         aValue
       end
+
+      def logical_2nd_arg(operand2)
+        case operand2
+          when false
+            False.instance # Convert to Lox equivalent
+          when nil
+            Nil.instance # Convert to Lox equivalent
+          when true
+            True.instance # Convert to Lox equivalent
+          else
+            operand2
+        end
+      end
     end # class
   end # module
 end # module

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')
@@ -68,9 +68,9 @@ module Loxxy
       rule('forTest' => 'expression_opt SEMICOLON')
       rule('forUpdate' => 'expression_opt')
 
-      rule('ifStmt' => 'IF ifCondition statement elsePart_opt')
-      rule('ifCondition' => 'LEFT_PAREN expression RIGHT_PAREN')
-      rule('elsePart_opt' => 'ELSE statement')
+      rule('ifStmt' => 'IF ifCondition statement elsePart_opt').as 'if_stmt'
+      rule('ifCondition' => 'LEFT_PAREN expression RIGHT_PAREN').as 'keep_symbol2'
+      rule('elsePart_opt' => 'ELSE statement').as 'keep_symbol2'
       rule('elsePart_opt' => [])
 
       rule('printStmt' => 'PRINT expression SEMICOLON').as 'print_stmt'
@@ -137,8 +137,8 @@ module Loxxy
       rule('primary' => 'THIS')
       rule('primary' => 'NUMBER').as 'literal_expr'
       rule('primary' => 'STRING').as 'literal_expr'
-      rule('primary' => 'IDENTIFIER')
-      rule('primary' => 'LEFT_PAREN expression RIGHT_PAREN')
+      rule('primary' => 'IDENTIFIER').as 'variable_expr'
+      rule('primary' => 'LEFT_PAREN expression RIGHT_PAREN').as 'grouping_expr'
       rule('primary' => 'SUPER DOT IDENTIFIER')
 
       # Utility rules

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.17'
+  VERSION = '0.0.22'
 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.parent).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
+          i_name = 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.parent).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