loxxy 0.0.20 → 0.0.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e6628d902c258d0aa2d589fd0960ab812addbfe8f0fbf162cfb627a90fbc1a40
-  data.tar.gz: c1fe1f5ce4b3dc7109c70783b78953fd72ffbbd837d58f8350d2a03615f80222
+  metadata.gz: fd4cbf32f4ee44a60c45630a76318425850dc35b4d9f6129274cefcbf4e91fcc
+  data.tar.gz: 711e0ae07d2a0b3a080c2fe408d9adf4f7b96bb070af686d66dd3f9dbae8391d
 SHA512:
-  metadata.gz: 301160cc1a00e819cc13cfb3273985b6af1ddadd94b236e4e7be0b346744355327be69d3b2d338ece3b6148a905d10a91dc3f6ef828912b7750efcdb0f4e5238
-  data.tar.gz: cc5bb436b6e487d7752180d42d046d5a09a6817878428d757b65b26f2955133985598b55e7d63c13d249ebef110914a3a2b8292777a2857b15dcba885c74c106
+  metadata.gz: 131f6fe3b23dc0a84b063efe70744b02ecc9edb68742540799964311298f35494a0d48db75bb18a240ddeed039286ab08ba2ef99e2ae4857d2b4d5dc4403d5ba
+  data.tar.gz: b46c18f54147fd01f9819e3ad06564ee78fe72de5c91d6ef8a5bef5945d9f1ad622cad848c4d521ae66f00c91b7825d01e57c831b2a097da830bec0d99f2cf06

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+## [0.0.21] - 2021-01-1x
+- The interpreter supports the declaration global variables.
+
+## Added
+- Class `BackEnd::Entry`, mixin module for objects put in the symbol table
+- Class `BackEnd::Environment` that keeps track of variables in a given context.
+- Class `BackEnd::SymbolTable` that keeps track of environments.
+- Class `BackEnd::Variable` internal representation of a `Lox` variable
+- Method `Ast::ASTBuilder#reduce_var_declaration` and `Ast::ASTBuilder#reduce_var_declaration`
+- Method `Ast::ASTVisitor#visit_var_stmt` for visiting `LoxVarStmt` nodes
+- Attribute `Engine::symbol_table`for keeping track of variables
+- Method `Engine::after_var_stmt` for the implementation of variable declarations
+
 ## [0.0.20] - 2021-01-15
 - The interpreter supports the `if` ... `else` statement.
 

data/README.md

@@ -8,7 +8,7 @@ a simple language used in Bob Nystrom's online book [Crafting Interpreters](http
 
 ### Purpose of this project:
 - To deliver an open source example of a programming language fully implemented in Ruby  
-  (from the scanner, parser, an interpreter).
+  (from the scanner and parser to an interpreter).
 - The implementation should be mature enough to run [LoxLox](https://github.com/benhoyt/loxlox),  
   a Lox interpreter written in Lox.
 
@@ -141,7 +141,9 @@ Here are the language features currently supported by the interpreter:
 - [Datatypes](#datatypes)
 - [Statements](#statements)  
   -[Expressions](#expressions)  
-  -[Print Statement](#print-statement)
+- [Variable declarations](#var-statement)  
+- [If Statement](#if-statement)   
+- [Print Statement](#print-statement)
 
 ### Comments
 
@@ -168,13 +170,15 @@ loxxy supports  all the standard __Lox__ datatypes:
 ### Statements
 
 Loxxy supports the following statements:  
--[Expressions](#expressions)  
+- [Expressions](#expressions)  
   -[Arithmetic expressions](#arithmetic-expressions)  
   -[String concatenation](#string-concatenation)  
   -[Comparison expressions](#comparison-expressions)  
   -[Logical expressions](#logical-expressions)  
   -[Grouping expressions](#grouping-expressions)  
--[If Statement](#if-statement)
+  
+-[Variable declarations](#var-statement)  
+-[If Statement](#if-statement)  
 -[Print Statement](#print-statement)
 
 #### Expressions
@@ -254,6 +258,16 @@ print 3 + 4 * 5;  // => 23
 print (3 + 4) * 5; // => 35
 ```
 
+#### Variable declarations
+``` javascript
+var iAmAVariable = "my-initial-value";
+var iAmNil; // __Lox__ initializes variables to nil by default;
+```
+
+Warning: current version cannot retrieve the value of a variable.
+Expect this capability to be implemented in the coming days.
+
+
 #### If statement
 
 Based on a given condition, an if statement executes one of two statements:

data/lib/loxxy/ast/all_lox_nodes.rb

@@ -8,3 +8,4 @@ require_relative 'lox_binary_expr'
 require_relative 'lox_logical_expr'
 require_relative 'lox_print_stmt'
 require_relative 'lox_if_stmt'
+require_relative 'lox_var_stmt'

data/lib/loxxy/ast/ast_builder.rb

@@ -158,6 +158,19 @@ module Loxxy
       return_first_child(range, tokens, theChildren) # Discard the semicolon
       end
 
+      # rule('varDecl' => 'VAR IDENTIFIER SEMICOLON')
+      def reduce_var_declaration(_production, _range, tokens, theChildren)
+        var_name = theChildren[1].token.lexeme.dup
+        Ast::LoxVarStmt.new(tokens[1].position, var_name, nil)
+      end
+
+      # rule('varDecl' => 'VAR IDENTIFIER EQUAL expression SEMICOLON')
+      def reduce_var_initialization(_production, _range, tokens, theChildren)
+        var_name = theChildren[1].token.lexeme.dup
+        Ast::LoxVarStmt.new(tokens[1].position, var_name, theChildren[3])
+      end
+
+
       # rule('ifStmt' => 'IF ifCondition statement elsePart_opt')
       def reduce_if_stmt(_production, _range, tokens, theChildren)
         condition = theChildren[1]

data/lib/loxxy/ast/ast_visitor.rb

@@ -51,6 +51,14 @@ module Loxxy
         broadcast(:after_ptree, aParseTree)
       end
 
+      # Visit event. The visitor is about to visit a variable declaration statement.
+      # @param aPrintStmt [AST::LOXVarStmt] the variable declaration node to visit
+      def visit_var_stmt(aVarStmt)
+        broadcast(:before_var_stmt, aVarStmt)
+        traverse_subnodes(aVarStmt)
+        broadcast(:after_var_stmt, aVarStmt)
+      end
+
       # Visit event. The visitor is about to visit a if statement.
       # @param anIfStmt [AST::LOXIfStmt] the if statement node to visit
       def visit_if_stmt(anIfStmt)

data/lib/loxxy/ast/lox_var_stmt.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'lox_compound_expr'
+
+module Loxxy
+  module Ast
+    # This AST node represents a variable declaration
+    class LoxVarStmt < LoxCompoundExpr
+      # @return [String] variable name
+      attr_reader :name
+
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      # @param aName [String] name of the variable
+      # @param aValue [Loxxy::Ast::LoxNode, NilClass] initial value for the variable
+      def initialize(aPosition, aName, aValue)
+        initial_value = aValue ? [aValue] : []
+        super(aPosition, initial_value)
+        @name = aName
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [Ast::ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_var_stmt(self)
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/back_end/engine.rb

@@ -2,6 +2,7 @@
 
 # Load all the classes implementing AST nodes
 require_relative '../ast/all_lox_nodes'
+require_relative 'symbol_table'
 
 module Loxxy
   module BackEnd
@@ -12,13 +13,17 @@ module Loxxy
       # @return [Hash] A set of configuration options
       attr_reader :config
 
-      # @return [Array] Data stack used for passing data between statements
+      # @return [BackEnd::SymbolTable]
+      attr_reader :symbol_table
+
+      # @return [Array<Datatype::BuiltinDatatyp>] Stack for the values of expr
       attr_reader :stack
 
       # @param theOptions [Hash]
       def initialize(theOptions)
         @config = theOptions
         @ostream = config.include?(:ostream) ? config[:ostream] : $stdout
+        @symbol_table = SymbolTable.new
         @stack = []
       end
 
@@ -36,6 +41,11 @@ module Loxxy
       ##########################################################################
       # Visit event handling
       ##########################################################################
+      def after_var_stmt(aVarStmt)
+        new_var = Variable.new(aVarStmt.name, aVarStmt.subnodes[0])
+        symbol_table.insert(new_var)
+      end
+
       def after_if_stmt(anIfStmt, aVisitor)
         # Retrieve the result of the condition evaluation
         condition = stack.pop

data/lib/loxxy/back_end/entry.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Loxxy
+  module BackEnd
+    # Mix-in module that implements the expected common behaviour of entries
+    # placed in the symbol table.
+    module Entry
+      # @return [String] User-defined name of the entry.
+      attr_reader :name
+
+=begin
+      # @return [String] Suffix for building the internal name of the entry.
+      attr_accessor :suffix
+=end      
+
+      # Initialize the entry with given name
+      # @param aName [String] The name of the entry
+      def init_name(aName)
+        @name = aName.dup
+        @name.freeze
+      end
+=begin
+      # Return the internal name of the entry
+      # Internal names used to disambiguate entry names.
+      # There might be homonyns between variable because:
+      #   - A child Scope may have a entry with same name as one of its
+      #     ancestor(s).
+      #   - Multiple calls to same defrel or procedure may imply multiple creation
+      #     of a entry given name...
+      # @return [String] internal name
+      def i_name
+        if suffix =~ /^_/
+          label + suffix
+        else
+          (suffix.nil? || suffix.empty?) ? label : suffix
+        end
+      end
+=end      
+    end # module
+  end # module
+end # module

data/lib/loxxy/back_end/environment.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative 'variable'
+
+module Loxxy
+  module BackEnd
+    # A environment is a name space that corresponds either to a specific
+    # delimited region in Loxxy source code or to an activation record
+    # of a relation or a relation definition.
+    # It contains a map of names to the objects they name (e.g. logical var)
+    class Environment
+      # The parent (enclosing) environment.
+      # @return [Environment, NilClass]
+      attr_accessor :parent
+
+      # Mapping from user-defined name to related definition
+      #  (say, a variable object)
+      # @return [Hash{String => Variable}] Pairs of the kind
+      attr_reader :defns
+
+      # Construct a environment instance.
+      # @param aParent [Environment, NilClass] Parent environment to this one.
+      def initialize(aParent = nil)
+        @parent = aParent
+        @defns = {}
+      end
+
+      # Add a new variable to the environment.
+      # @param anEntry [BackEnd::Variable]
+      # @return [BackEnd::Variable] the variable
+      def insert(anEntry)
+        e = validated_entry(anEntry)
+        # e.suffix = default_suffix if e.kind_of?(BackEnd::Variable)
+        defns[e.name] = e
+
+        e
+      end
+
+      # Returns a string with a human-readable representation of the object.
+      # @return [String]
+      def inspect
+        +"#<#{self.class}:#{object_id.to_s(16)}>"
+      end
+
+      private
+
+      def validated_entry(anEntry)
+        name = anEntry.name
+        unless name.kind_of?(String) && !name.empty?
+          err_msg = 'Invalid variable name argument.'
+          raise StandardError, err_msg
+        end
+        if defns.include?(name) && !anEntry.kind_of?(Variable)
+          err_msg = "Variable with name '#{name}' already exists."
+          raise StandardError, err_msg
+        end
+
+        anEntry
+      end
+
+      # def default_suffix
+        # @default_suffix ||= "_#{object_id.to_s(16)}"
+      # end
+    end # class
+  end # module
+end # module

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/front_end/grammar.rb

@@ -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')

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.21'
 end

data/spec/back_end/engine_spec.rb

@@ -31,8 +31,16 @@ 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

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/interpreter_spec.rb

@@ -211,7 +211,7 @@ module Loxxy
         end
       end
 
-      it 'should supprt expressions between parentheses' do
+      it 'should support expressions between parentheses' do
         [
           ['3 + 4 * 5;', 23],
           ['(3 + 4) * 5;', 35],
@@ -250,6 +250,15 @@ module Loxxy
         end
       end
 
+      it 'should accept variable declarations' do
+        # Variable with initialization value
+        var_decl = 'var iAmAVariable = "here is my value";'
+        expect { subject.evaluate(var_decl) }.not_to raise_error
+
+        # Variable without initialization value
+        expect { subject.evaluate('var iAmNil;') }.not_to raise_error
+      end
+
       it 'should print the hello world message' do
         expect { subject.evaluate(hello_world) }.not_to raise_error
         expect(sample_cfg[:ostream].string).to eq('Hello, world!')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: loxxy
 version: !ruby/object:Gem::Version
-  version: 0.0.20
+  version: 0.0.21
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-15 00:00:00.000000000 Z
+date: 2021-01-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -97,7 +97,12 @@ files:
 - lib/loxxy/ast/lox_noop_expr.rb
 - lib/loxxy/ast/lox_print_stmt.rb
 - lib/loxxy/ast/lox_unary_expr.rb
+- lib/loxxy/ast/lox_var_stmt.rb
 - lib/loxxy/back_end/engine.rb
+- lib/loxxy/back_end/entry.rb
+- lib/loxxy/back_end/environment.rb
+- lib/loxxy/back_end/symbol_table.rb
+- lib/loxxy/back_end/variable.rb
 - lib/loxxy/datatype/all_datatypes.rb
 - lib/loxxy/datatype/boolean.rb
 - lib/loxxy/datatype/builtin_datatype.rb
@@ -115,6 +120,9 @@ files:
 - lib/loxxy/version.rb
 - loxxy.gemspec
 - spec/back_end/engine_spec.rb
+- spec/back_end/environment_spec.rb
+- spec/back_end/symbol_table_spec.rb
+- spec/back_end/variable_spec.rb
 - spec/datatype/boolean_spec.rb
 - spec/datatype/lx_string_spec.rb
 - spec/datatype/nil_spec.rb
@@ -151,6 +159,9 @@ specification_version: 4
 summary: An implementation of the Lox programming language. WIP
 test_files:
 - spec/back_end/engine_spec.rb
+- spec/back_end/environment_spec.rb
+- spec/back_end/symbol_table_spec.rb
+- spec/back_end/variable_spec.rb
 - spec/datatype/boolean_spec.rb
 - spec/datatype/lx_string_spec.rb
 - spec/datatype/nil_spec.rb