loxxy 0.0.24 → 0.1.0

data/lib/loxxy/back_end/environment.rb

@@ -9,9 +9,9 @@ module Loxxy
     # 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.
+      # The  enclosing (parent) environment.
       # @return [Environment, NilClass]
-      attr_accessor :parent
+      attr_accessor :enclosing
 
       # Mapping from user-defined name to related definition
       #  (say, a variable object)
@@ -21,7 +21,7 @@ module Loxxy
       # Construct a environment instance.
       # @param aParent [Environment, NilClass] Parent environment to this one.
       def initialize(aParent = nil)
-        @parent = aParent
+        @enclosing = aParent
         @defns = {}
       end
 

data/lib/loxxy/back_end/function.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative '../datatype/all_datatypes'
+
+module Loxxy
+  module BackEnd
+    # Representation of a Lox function.
+    # It is a named slot that can be associated with a value at the time.
+    class Function
+
+      # @return [String]
+      attr_reader :name
+
+      # @return [Array<>] the parameters
+      attr_reader :parameters
+      
+      attr_reader :body
+
+      attr_reader :stack
+
+      # 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, parameterList, aBody, aStack)
+        @name = aName.dup
+        @parameters = parameterList
+        @body = aBody
+        @stack = aStack
+      end
+
+      def accept(_visitor)
+        stack.push self
+      end
+
+      def call(aVisitor)
+        body.empty? ? Datatype::Nil.instance : body.accept(aVisitor)
+      end
+
+      # Text representation of a Lox function
+      def to_str
+        "<fn #{name}>"
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/back_end/symbol_table.rb

@@ -44,7 +44,7 @@ module Loxxy
       # 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
+        anEnv.enclosing = current_env
         @current_env = anEnv
       end
 
@@ -60,7 +60,7 @@ module Loxxy
         end
         raise StandardError, 'Cannot remove root environment.' if current_env == root
 
-        @current_env = current_env.parent
+        @current_env = current_env.enclosing
       end
 
       # Add an entry with given name to current environment.
@@ -114,7 +114,7 @@ module Loxxy
         while skope
           vars_of_environment = skope.defns.select { |_, item| item.kind_of?(Variable) }
           vars = vars_of_environment.values.concat(vars)
-          skope = skope.parent
+          skope = skope.enclosing
         end
 
         vars

data/lib/loxxy/front_end/grammar.rb

@@ -44,7 +44,7 @@ module Loxxy
       rule('function_star' => 'function_star function')
       rule('function_star' => [])
 
-      rule('funDecl' => 'FUN function')
+      rule('funDecl' => 'FUN function').as 'fun_decl'
 
       rule('varDecl' => 'VAR IDENTIFIER SEMICOLON').as 'var_declaration'
       rule('varDecl' => 'VAR IDENTIFIER EQUAL expression SEMICOLON').as 'var_initialization'
@@ -60,12 +60,12 @@ module Loxxy
 
       rule('exprStmt' => 'expression SEMICOLON').as 'exprStmt'
 
-      rule('forStmt' => 'FOR LEFT_PAREN forControl RIGHT_PAREN statement')
-      rule('forControl' => 'forInitialization forTest forUpdate')
+      rule('forStmt' => 'FOR LEFT_PAREN forControl RIGHT_PAREN statement').as 'for_stmt'
+      rule('forControl' => 'forInitialization forTest forUpdate').as 'for_control'
       rule('forInitialization' => 'varDecl')
       rule('forInitialization' => 'exprStmt')
-      rule('forInitialization' => 'SEMICOLON')
-      rule('forTest' => 'expression_opt SEMICOLON')
+      rule('forInitialization' => 'SEMICOLON').as 'empty_for_initialization'
+      rule('forTest' => 'expression_opt SEMICOLON').as 'for_test'
       rule('forUpdate' => 'expression_opt')
 
       rule('ifStmt' => 'IF ifCondition statement elsePart_opt').as 'if_stmt'
@@ -75,9 +75,9 @@ 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 RIGHT_BRACE')
+      rule('whileStmt' => 'WHILE LEFT_PAREN expression RIGHT_PAREN statement').as 'while_stmt'
+      rule('block' => 'LEFT_BRACE declaration_plus RIGHT_BRACE').as 'block_stmt'
+      rule('block' => 'LEFT_BRACE RIGHT_BRACE').as 'block_empty'
 
       # Expressions: produce values
       rule('expression_opt' => 'expression')
@@ -88,37 +88,37 @@ module Loxxy
       rule('owner_opt' => 'call DOT')
       rule('owner_opt' => [])
       rule('logic_or' => 'logic_and')
-      rule('logic_or' => 'logic_and disjunct_plus').as 'logic_or_plus'
-      rule('disjunct_plus' => 'disjunct_plus OR logic_and').as 'logic_or_plus_more'
-      rule('disjunct_plus' => 'OR logic_and').as 'logic_or_plus_end'
+      rule('logic_or' => 'logic_and disjunct_plus').as 'logical_expr'
+      rule('disjunct_plus' => 'disjunct_plus OR logic_and').as 'binary_plus_more'
+      rule('disjunct_plus' => 'OR logic_and').as 'binary_plus_end'
       rule('logic_and' => 'equality')
-      rule('logic_and' => 'equality conjunct_plus').as 'logic_and_plus'
-      rule('conjunct_plus' => 'conjunct_plus AND equality').as 'logic_and_plus_more'
-      rule('conjunct_plus' => 'AND equality').as 'logic_and_plus_end'
+      rule('logic_and' => 'equality conjunct_plus').as 'logical_expr'
+      rule('conjunct_plus' => 'conjunct_plus AND equality').as 'binary_plus_more'
+      rule('conjunct_plus' => 'AND equality').as 'binary_plus_end'
       rule('equality' => 'comparison')
-      rule('equality' => 'comparison equalityTest_plus').as 'equality_plus'
-      rule('equalityTest_plus' => 'equalityTest_plus equalityTest comparison').as 'equality_t_plus_more'
-      rule('equalityTest_plus' => 'equalityTest comparison').as 'equality_t_plus_end'
+      rule('equality' => 'comparison equalityTest_plus').as 'binary_operator'
+      rule('equalityTest_plus' => 'equalityTest_plus equalityTest comparison').as 'binary_plus_more'
+      rule('equalityTest_plus' => 'equalityTest comparison').as 'binary_plus_end'
       rule('equalityTest' => 'BANG_EQUAL')
       rule('equalityTest' => 'EQUAL_EQUAL')
       rule('comparison' => 'term')
-      rule('comparison' => 'term comparisonTest_plus').as 'comparison_plus'
+      rule('comparison' => 'term comparisonTest_plus').as 'binary_operator'
       rule('comparisonTest_plus' => 'comparisonTest_plus comparisonTest term').as 'comparison_t_plus_more'
-      rule('comparisonTest_plus' => 'comparisonTest term').as 'comparison_t_plus_end'
+      rule('comparisonTest_plus' => 'comparisonTest term').as 'binary_plus_end'
       rule('comparisonTest' => 'GREATER')
       rule('comparisonTest' => 'GREATER_EQUAL')
       rule('comparisonTest' => 'LESS')
       rule('comparisonTest' => 'LESS_EQUAL')
       rule('term' => 'factor')
-      rule('term' => 'factor additive_plus').as 'term_additive'
-      rule('additive_plus' => 'additive_plus additionOp factor').as 'additive_plus_more'
-      rule('additive_plus' => 'additionOp factor').as 'additive_plus_end'
+      rule('term' => 'factor additive_plus').as 'binary_operator'
+      rule('additive_plus' => 'additive_plus additionOp factor').as 'binary_plus_more'
+      rule('additive_plus' => 'additionOp factor').as 'binary_plus_end'
       rule('additionOp' => 'MINUS')
       rule('additionOp' => 'PLUS')
       rule('factor' => 'unary')
-      rule('factor' => 'unary multiplicative_plus').as 'factor_multiplicative'
-      rule('multiplicative_plus' => 'multiplicative_plus multOp unary').as 'multiplicative_plus_more'
-      rule('multiplicative_plus' => 'multOp unary').as 'multiplicative_plus_end'
+      rule('factor' => 'unary multiplicative_plus').as 'binary_operator'
+      rule('multiplicative_plus' => 'multiplicative_plus multOp unary').as 'binary_plus_more'
+      rule('multiplicative_plus' => 'multOp unary').as 'binary_plus_end'
       rule('multOp' => 'SLASH')
       rule('multOp' => 'STAR')
       rule('unary' => 'unaryOp unary').as 'unary_expr'
@@ -126,10 +126,10 @@ module Loxxy
       rule('unaryOp' => 'BANG')
       rule('unaryOp' => 'MINUS')
       rule('call' => 'primary')
-      rule('call' => 'primary refinement_plus')
-      rule('refinement_plus' => 'refinement_plus refinement')
-      rule('refinement_plus' => 'refinement')
-      rule('refinement' => 'LEFT_PAREN arguments_opt RIGHT_PAREN')
+      rule('call' => 'primary refinement_plus').as 'call_expr'
+      rule('refinement_plus' => 'refinement_plus refinement') # .as 'refinement_plus_more'
+      rule('refinement_plus' => 'refinement').as 'refinement_plus_end'
+      rule('refinement' => 'LEFT_PAREN arguments_opt RIGHT_PAREN').as 'call_arglist'
       rule('refinement' => 'DOT IDENTIFIER')
       rule('primary' => 'TRUE').as 'literal_expr'
       rule('primary' => 'FALSE').as 'literal_expr'
@@ -142,15 +142,15 @@ module Loxxy
       rule('primary' => 'SUPER DOT IDENTIFIER')
 
       # Utility rules
-      rule('function' => 'IDENTIFIER LEFT_PAREN params_opt RIGHT_PAREN block')
+      rule('function' => 'IDENTIFIER LEFT_PAREN params_opt RIGHT_PAREN block').as 'function'
       rule('params_opt' => 'parameters')
       rule('params_opt' => [])
-      rule('parameters' => 'parameters COMMA IDENTIFIER')
-      rule('parameters' => 'IDENTIFIER')
+      rule('parameters' => 'parameters COMMA IDENTIFIER').as 'parameters_plus_more'
+      rule('parameters' => 'IDENTIFIER').as 'parameters_plus_end'
       rule('arguments_opt' => 'arguments')
       rule('arguments_opt' => [])
-      rule('arguments' => 'arguments COMMA expression')
-      rule('arguments' => 'expression')
+      rule('arguments' => 'arguments COMMA expression').as 'arguments_plus_more'
+      rule('arguments' => 'expression').as 'arguments_plus_end'
     end
 
     unless defined?(Grammar)

data/lib/loxxy/front_end/literal.rb

@@ -11,7 +11,7 @@ module Loxxy
 
       # Constructor.
       # @param aValue [Datatype::BuiltinDatatype] the Lox data value
-      # @param theLexeme [String] the lexeme (= piece of text from input)
+      # @param aLexeme [String] the lexeme (= piece of text from input)
       # @param aTerminal [Rley::Syntax::Terminal, String]
       #   The terminal symbol corresponding to the lexeme.
       # @param aPosition [Rley::Lexical::Position] The position of lexeme

data/lib/loxxy/version.rb

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

data/spec/back_end/environment_spec.rb

@@ -32,7 +32,7 @@ module Loxxy
         end
 
         it 'should know its parent (if any)' do
-          expect(subject.parent).to eq(mother)
+          expect(subject.enclosing).to eq(mother)
         end
       end # context
 

data/spec/back_end/symbol_table_spec.rb

@@ -60,7 +60,7 @@ module Loxxy
           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.current_env.enclosing).to eq(subject.root)
           expect(subject.name2envs['q']).to eq([subject.root])
         end
 

data/spec/datatype/lx_string_spec.rb

@@ -26,6 +26,7 @@ module Loxxy
           expect(subject.to_str).to eq(sample_text)
         end
 
+        # rubocop: disable Lint/BinaryOperatorWithIdenticalOperands
         it 'compares with another Lox string' do
           result = subject == LXString.new(sample_text.dup)
           expect(result).to be_true
@@ -40,6 +41,7 @@ module Loxxy
           result = LXString.new('') == LXString.new('')
           expect(result).to be_true
         end
+        # rubocop: enable Lint/BinaryOperatorWithIdenticalOperands
 
         it 'compares with a Ruby string' do
           result = subject == sample_text.dup

data/spec/datatype/number_spec.rb

@@ -21,6 +21,7 @@ module Loxxy
         end
       end
 
+      # rubocop: disable Lint/FloatComparison
       context 'Provided services:' do
         it 'should compare with other Lox numbers' do
           result = subject == Number.new(sample_value)
@@ -51,7 +52,8 @@ module Loxxy
           subtraction = subject - Number.new(10)
           expect(subtraction == -22.34).to be_true
         end
-      end
+      end # context
+      # rubocop: enable Lint/FloatComparison
     end # describe
   end # module
 end # module

data/spec/front_end/scanner_spec.rb

@@ -208,6 +208,7 @@ LOX_END
           expect(eof_token.terminal).to eq('EOF')
         end
 
+        # rubocop: disable Lint/PercentStringArray
         it 'should skip end of line comments' do
           input = <<-LOX_END
             // first comment
@@ -223,6 +224,7 @@ LOX_END
           ]
           match_expectations(subject, expectations)
         end
+        # rubocop: enable Lint/PercentStringArray
 
         it 'should cope with single slash (divide) expression' do
           subject.start_with('8 / 2')

data/spec/interpreter_spec.rb

@@ -288,10 +288,10 @@ LOX_END
         program = <<-LOX_END
           var a = "before";
           print a; // output: before
-          
+
           a = "after";
           print a; // output: after
-          
+
           print a = "arg"; // output: arg
           print a; // output: arg
         LOX_END
@@ -299,6 +299,130 @@ LOX_END
         expect(sample_cfg[:ostream].string).to eq('beforeafterargarg')
       end
 
+      it 'should support variables local to a block' do
+        program = <<-LOX_END
+        {
+          var a = "first";
+          print a;
+        }
+        {
+          var a = "second";
+          print a;
+        }
+        LOX_END
+        expect { subject.evaluate(program) }.not_to raise_error
+        expect(sample_cfg[:ostream].string).to eq('firstsecond')
+      end
+
+      it 'should support the shadowing of variables in a block' do
+        program = <<-LOX_END
+        var a = "outer";
+
+        {
+          var a = "inner";
+          print a; // output: inner
+        }
+
+        print a; // output: outer
+        LOX_END
+        expect { subject.evaluate(program) }.not_to raise_error
+        expect(sample_cfg[:ostream].string).to eq('innerouter')
+      end
+
+      it 'should implement single statement while loops' do
+        program = <<-LOX_END
+          // Single-expression body.
+          var c = 0;
+          while (c < 3) print c = c + 1;
+          // output: 1
+          // output: 2
+          // output: 3
+        LOX_END
+        expect { subject.evaluate(program) }.not_to raise_error
+        expect(sample_cfg[:ostream].string).to eq('123')
+      end
+
+      it 'should implement block body while loops' do
+        program = <<-LOX_END
+          // Block body.
+          var a = 0;
+          while (a < 3) {
+            print a;
+            a = a + 1;
+          }
+          // output: 0
+          // output: 1
+          // output: 2
+        LOX_END
+        expect { subject.evaluate(program) }.not_to raise_error
+        expect(sample_cfg[:ostream].string).to eq('012')
+      end
+
+      it 'should implement single statement for loops' do
+        program = <<-LOX_END
+          // Single-expression body.
+          for (var c = 0; c < 3;) print c = c + 1;
+          // output: 1
+          // output: 2
+          // output: 3
+        LOX_END
+        expect { subject.evaluate(program) }.not_to raise_error
+        expect(sample_cfg[:ostream].string).to eq('123')
+      end
+
+      it 'should implement for loops with block body' do
+        program = <<-LOX_END
+          // Block body.
+          for (var a = 0; a < 3; a = a + 1) {
+            print a;
+          }
+          // output: 0
+          // output: 1
+          // output: 2
+        LOX_END
+        expect { subject.evaluate(program) }.not_to raise_error
+        expect(sample_cfg[:ostream].string).to eq('012')
+      end
+
+      it 'should implement nullary function calls' do
+        program = <<-LOX_END
+          print clock(); // Lox expects the 'clock' predefined native function
+        LOX_END
+        expect { subject.evaluate(program) }.not_to raise_error
+        tick = sample_cfg[:ostream].string
+        expect(Time.now.to_f - tick.to_f).to be < 0.1
+      end
+
+      it 'should implement function definition' do
+        program = <<-LOX_END
+          fun printSum(a, b) {
+             print a + b;
+          }
+          printSum(1, 2);
+        LOX_END
+        expect { subject.evaluate(program) }.not_to raise_error
+        expect(sample_cfg[:ostream].string).to eq('3')
+      end
+
+      it 'should support functions with empty body' do
+        program = <<-LOX_END
+          fun f() {}
+          print f();
+        LOX_END
+        expect { subject.evaluate(program) }.not_to raise_error
+        expect(sample_cfg[:ostream].string).to eq('nil')
+      end
+
+      it 'should provide print representation of functions' do
+        program = <<-LOX_END
+          fun foo() {}
+          print foo; // output: <fn foo>
+          print clock; // output: <native fn>
+        LOX_END
+        expect { subject.evaluate(program) }.not_to raise_error
+        expect(sample_cfg[:ostream].string).to eq('<fn foo><native fn>')
+      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!')