loxxy 0.0.27 → 0.0.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 47ae4c0af1698de7187c530ec5feec9390a664ff681aae6c47a36e351bda229d
-  data.tar.gz: ff309645b8e71608e6a3801d4a4be558b8e86d59d658af4ec2eb796989e88455
+  metadata.gz: 6b9202e7a755cffecb3226da5764a3cb6f75fd3179803eb25779ae42822bbf15
+  data.tar.gz: 49767873134c5c124aab3e6b20a49c60f968df180dfd6e945f3da2808eee59c7
 SHA512:
-  metadata.gz: 73bea958f39a8cb97ed2e59c049ab58006845519a642d20e72cbdd554be60cb3b553f84dcdd64a36410796f83e87bb3239eee9933148b821b074916f4198a810
-  data.tar.gz: a3235fd86a5c99c0ecf581be106e53d59a0643b3ac6299fbd0eccd0f5eacc5a15b63df3a22fb4edef8b30314fa0360432b017d9a2417668e365e2b9dd3f8b2b8
+  metadata.gz: 29c481015e414ea71eb55c0b4dcc4d793b011a8f16fa7f9218ec704b2baea820e47ba758ba9a2e30e5bdfe08bfd2ad8fa892e6d67e247938b8bcda7b005ff2a9
+  data.tar.gz: cbf671e54aa98e799b6d565cac52fb19fb3f5d7b3ae84841f27067ae427e5a7c25a7d40a07d39645150f73176709fbcc6e3bbf36e9cada14d8b329f335c621d5

data/README.md

@@ -14,9 +14,13 @@ a simple language used in Bob Nystrom's online book [Crafting Interpreters](http
 
 ### Current status
 The project is still in inception and the interpreter is being implemented...  
-Currently it can execute a subset of __Lox__ language.
+Currently it can execute all allowed __Lox__ expressions and statement except:
+- Functions and closures,  
+- Classes and objects.
+
+These will be implemented soon.
+
 
-But the __loxxy__ gem hosts also a parser class `RawPaser` that can parse, in principle, any valid Lox input.
 
 ## What's the fuss about Lox?
 ... Nothing...  

data/lib/loxxy/ast/all_lox_nodes.rb

@@ -3,6 +3,7 @@
 require_relative 'lox_variable_expr'
 require_relative 'lox_literal_expr'
 require_relative 'lox_noop_expr'
+require_relative 'lox_call_expr'
 require_relative 'lox_grouping_expr'
 require_relative 'lox_unary_expr'
 require_relative 'lox_binary_expr'

data/lib/loxxy/ast/ast_builder.rb

@@ -233,99 +233,35 @@ module Loxxy
         Ast::LoxAssignExpr.new(tokens[1].position, var_name, theChildren[3])
       end
 
-      # rule('logic_or' => 'logic_and disjunct_plus')
-      def reduce_logic_or_plus(production, range, tokens, theChildren)
-        reduce_logical_expr(production, range, tokens, theChildren)
-      end
-
-      # rule('disjunct_plus' => 'disjunct_plus OR logic_and')
-      def reduce_logic_or_plus_more(production, range, tokens, theChildren)
-        reduce_binary_plus_more(production, range, tokens, theChildren)
-      end
-
-      # rule('disjunct_plus' => 'OR logic_and')
-      def reduce_logic_or_plus_end(production, range, tokens, theChildren)
-        reduce_binary_plus_end(production, range, tokens, theChildren)
-      end
-
-      # rule('logic_and' => 'equality conjunct_plus')
-      def reduce_logic_and_plus(production, range, tokens, theChildren)
-        reduce_logical_expr(production, range, tokens, theChildren)
-      end
-
-      # rule('conjunct_plus' => 'conjunct_plus AND equality')
-      def reduce_logic_and_plus_more(production, range, tokens, theChildren)
-        reduce_binary_plus_more(production, range, tokens, theChildren)
-      end
-
-      # rule('conjunct_plus' => 'AND equality')
-      def reduce_logic_and_plus_end(production, range, tokens, theChildren)
-        reduce_binary_plus_end(production, range, tokens, theChildren)
-      end
-
-      # rule('equality' => 'comparison equalityTest_plus')
-      def reduce_equality_plus(production, range, tokens, theChildren)
-        reduce_binary_operator(production, range, tokens, theChildren)
-      end
-
-      # rule('equalityTest_plus' => 'equalityTest_plus equalityTest comparison')
-      def reduce_equality_t_plus_more(production, range, tokens, theChildren)
-        reduce_binary_plus_more(production, range, tokens, theChildren)
-      end
-
-      # rule('equalityTest_star' => 'equalityTest comparison')
-      def reduce_equality_t_plus_end(production, range, tokens, theChildren)
-        reduce_binary_plus_end(production, range, tokens, theChildren)
-      end
-
-      # rule('comparison' => 'term comparisonTest_plus')
-      def reduce_comparison_plus(production, range, tokens, theChildren)
-        reduce_binary_operator(production, range, tokens, theChildren)
-      end
-
       # rule('comparisonTest_plus' => 'comparisonTest_plus comparisonTest term').as 'comparison_t_plus_more'
       # TODO: is it meaningful to implement this rule?
 
-      # rule('comparisonTest_plus' => 'comparisonTest term')
-      def reduce_comparison_t_plus_end(production, range, tokens, theChildren)
-        reduce_binary_plus_end(production, range, tokens, theChildren)
-      end
-
-      # rule('term' => 'factor additive_plus')
-      def reduce_term_additive(production, range, tokens, theChildren)
-        reduce_binary_operator(production, range, tokens, theChildren)
-      end
-
-      # rule('additive_star' => 'additive_star additionOp factor').as 'additionOp_expr'
-      def reduce_additive_plus_more(production, range, tokens, theChildren)
-        reduce_binary_plus_more(production, range, tokens, theChildren)
-      end
-
-      # rule('additive_plus' => 'additionOp factor')
-      def reduce_additive_plus_end(production, range, tokens, theChildren)
-        reduce_binary_plus_end(production, range, tokens, theChildren)
+      # rule('unary' => 'unaryOp unary')
+      def reduce_unary_expr(_production, _range, tokens, theChildren)
+        operator = Name2unary[theChildren[0].symbol.name].to_sym
+        operand = theChildren[1]
+        LoxUnaryExpr.new(tokens[0].position, operator, operand)
       end
 
-      # rule('factor' => 'multiplicative_plus')
-      def reduce_factor_multiplicative(production, range, tokens, theChildren)
-        reduce_binary_operator(production, range, tokens, theChildren)
+      # rule('call' => 'primary refinement_plus').as 'call_expr'
+      def reduce_call_expr(_production, _range, _tokens, theChildren)
+        theChildren[1].callee = theChildren[0]
+        theChildren[1]
       end
 
-      # rule('multiplicative_plus' => 'multiplicative_plus multOp unary')
-      def reduce_multiplicative_plus_more(production, range, tokens, theChildren)
-        reduce_binary_plus_more(production, range, tokens, theChildren)
+      # rule('refinement_plus' => 'refinement').
+      def reduce_refinement_plus_end(_production, _range, _tokens, theChildren)
+        theChildren[0]
       end
 
-      # rule('multiplicative_plus' => 'multOp unary')
-      def reduce_multiplicative_plus_end(production, range, tokens, theChildren)
-        reduce_binary_plus_end(production, range, tokens, theChildren)
-      end
+      # rule('refinement' => 'LEFT_PAREN arguments_opt RIGHT_PAREN')
+      def reduce_call_arglist(_production, _range, tokens, theChildren)
+        args = theChildren[1] || []
+        if args.size > 255
+          raise StandardError, "Can't have more than 255 arguments."
+        end
 
-      # rule('unary' => 'unaryOp unary')
-      def reduce_unary_expr(_production, _range, tokens, theChildren)
-        operator = Name2unary[theChildren[0].symbol.name].to_sym
-        operand = theChildren[1]
-        LoxUnaryExpr.new(tokens[0].position, operator, operand)
+        LoxCallExpr.new(tokens[0].position, args)
       end
 
       # rule('primary' => 'LEFT_PAREN expression RIGHT_PAREN')
@@ -347,6 +283,16 @@ module Loxxy
         var_name = theChildren[0].token.lexeme
         LoxVariableExpr.new(tokens[0].position, var_name)
       end
+
+      # rule('arguments' => 'arguments COMMA expression')
+      def reduce_arguments_plus_more(_production, _range, _tokens, theChildren)
+        theChildren[0] << theChildren[2]
+      end
+
+      # rule('arguments' => 'expression')
+      def reduce_arguments_plus_end(_production, _range, _tokens, theChildren)
+        theChildren
+      end
     end # class
   end # module
 end # module

data/lib/loxxy/ast/ast_visitor.rb

@@ -145,6 +145,14 @@ module Loxxy
         broadcast(:after_unary_expr, anUnaryExpr)
       end
 
+      # Visit event. The visitor is about to visit a call expression.
+      # @param aCallExpr [AST::LoxCallExpr] call expression to visit
+      def visit_call_expr(aCallExpr)
+        broadcast(:before_call_expr, aCallExpr)
+        traverse_subnodes(aCallExpr)
+        broadcast(:after_call_expr, aCallExpr, self)
+      end
+
       # Visit event. The visitor is about to visit a grouping expression.
       # @param aGroupingExpr [AST::LoxGroupingExpr] grouping expression to visit
       def visit_grouping_expr(aGroupingExpr)
@@ -177,10 +185,12 @@ module Loxxy
 
       # Visit event. The visitor is about to visit the given non terminal node.
       # @param aNonTerminalNode [Rley::PTree::NonTerminalNode] the node to visit.
-      def visit_nonterminal(_non_terminal_node)
+      def visit_nonterminal(non_terminal_node)
         # Loxxy interpreter encountered a CST node (Concrete Syntax Tree)
         # that it cannot handle.
-        raise NotImplementedError, 'Loxxy cannot execute this code yet.'
+        symb = non_terminal_node.symbol.name
+        msg = "Loxxy cannot execute this code yet for non-terminal symbol '#{symb}'."
+        raise NotImplementedError, msg
       end
 
       private

data/lib/loxxy/ast/lox_call_expr.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'lox_compound_expr'
+
+module Loxxy
+  module Ast
+    class LoxCallExpr < LoxCompoundExpr
+      attr_accessor :callee
+      attr_reader :arguments
+
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      # @param argList [Array<Loxxy::Ast::LoxNode>]
+      def initialize(aPosition, argList)
+        super(aPosition, [])
+        @arguments = argList
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [Ast::ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_call_expr(self)
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/back_end/engine.rb

@@ -25,6 +25,8 @@ module Loxxy
         @ostream = config.include?(:ostream) ? config[:ostream] : $stdout
         @symbol_table = SymbolTable.new
         @stack = []
+
+        init_globals
       end
 
       # Given an abstract syntax parse tree visitor, launch the visit
@@ -167,6 +169,17 @@ module Loxxy
         end
       end
 
+      def after_call_expr(aCallExpr, aVisitor)
+        # Evaluate callee part
+        aCallExpr.callee.accept(aVisitor)
+        callee = stack.pop
+        # TODO: reverse order?
+        aCallExpr.arguments.each do |arg|
+          arg.evaluate(aVisitor)
+        end
+        stack.push callee.call # Pass arguments
+      end
+
       def after_grouping_expr(_groupingExpr)
         # Do nothing: work was already done by visiting /evaluating the subexpression
       end
@@ -188,6 +201,32 @@ module Loxxy
       def before_visit_builtin(aValue)
         stack.push(aValue)
       end
+
+      private
+
+      NativeFunction = Struct.new(:callable, :interp) do
+        def accept(_visitor)
+          interp.stack.push callable
+        end
+      end
+
+      def init_globals
+        add_native_fun('clock', native_clock)
+      end
+
+      def add_native_fun(aName, aProc)
+        native_fun = Variable.new(aName, NativeFunction.new(aProc, self))
+        symbol_table.insert(native_fun)
+      end
+
+      # Ruby-native function that returns (as float) the number of seconds since
+      # a given time reference.
+      def native_clock
+        proc do
+          now = Time.now.to_f
+          Datatype::Number.new(now)
+        end
+      end
     end # class
   end # module
 end # module

data/lib/loxxy/front_end/grammar.rb

@@ -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'
@@ -149,8 +149,8 @@ module Loxxy
       rule('parameters' => 'IDENTIFIER')
       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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Loxxy
-  VERSION = '0.0.27'
+  VERSION = '0.0.28'
 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

@@ -384,18 +384,16 @@ LOX_END
         expect(sample_cfg[:ostream].string).to eq('012')
       end
 
-      it 'should implement for loops without initialization' do
+      it 'should implement nullary function calls' do
         program = <<-LOX_END
-          var i = 0;
-          // No variable in initialization.
-          for (; i < 2; i = i + 1) print i;
-          // output: 0
-          // output: 1
+          print clock(); // Lox expect the 'clock' predefined native function
         LOX_END
         expect { subject.evaluate(program) }.not_to raise_error
-        expect(sample_cfg[:ostream].string).to eq('01')
+        tick = sample_cfg[:ostream].string
+        expect(Time.now.to_f - tick.to_f).to be < 0.1
       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.27
+  version: 0.0.28
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-24 00:00:00.000000000 Z
+date: 2021-02-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -90,6 +90,7 @@ files:
 - lib/loxxy/ast/lox_assign_expr.rb
 - lib/loxxy/ast/lox_binary_expr.rb
 - lib/loxxy/ast/lox_block_stmt.rb
+- lib/loxxy/ast/lox_call_expr.rb
 - lib/loxxy/ast/lox_compound_expr.rb
 - lib/loxxy/ast/lox_for_stmt.rb
 - lib/loxxy/ast/lox_grouping_expr.rb