loxxy 0.0.28 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6b9202e7a755cffecb3226da5764a3cb6f75fd3179803eb25779ae42822bbf15
-  data.tar.gz: 49767873134c5c124aab3e6b20a49c60f968df180dfd6e945f3da2808eee59c7
+  metadata.gz: 42a88690625576399255ae7fadd3ac6aee022fc8d56a8e10c1206b55eca207ab
+  data.tar.gz: 4042d268f199763405a264480765bbd5fe7aeaa998eb5e0a4353ae702c3bef2a
 SHA512:
-  metadata.gz: 29c481015e414ea71eb55c0b4dcc4d793b011a8f16fa7f9218ec704b2baea820e47ba758ba9a2e30e5bdfe08bfd2ad8fa892e6d67e247938b8bcda7b005ff2a9
-  data.tar.gz: cbf671e54aa98e799b6d565cac52fb19fb3f5d7b3ae84841f27067ae427e5a7c25a7d40a07d39645150f73176709fbcc6e3bbf36e9cada14d8b329f335c621d5
+  metadata.gz: 21a6a82509ead9c0d9f38c6798147dda38c436d87b8800a33ca7027553631866ce4215f2eb90c482f3c5a9b0bb42e99b7868fca888b78fcf7eca67afcd7db756
+  data.tar.gz: 71b53af0df630894c0d45639a84f427f34c7b92a5092e07cea16bc3786af666be13b0035a13c07b2910c374c76caa009c3acdbd675f430c8f6e4b7951c2b68a7

data/CHANGELOG.md

@@ -1,3 +1,38 @@
+## [0.1.00] - 2021-02-20
+- Version number bumped, `Loxxy` supports function definitions
+
+### Added
+- Class `Ast::LoxFunStmt` a node that represents a function declaration
+- Method `Ast::ASTBuilder#reduce_fun_decl`
+- Method `Ast::ASTBuilder#reduce_function` creates a `LoxFunStmt` instance
+- Method `Ast::ASTBuilder#reduce_parameters_plus_more` for dealing with function parameters
+- Method `Ast::ASTBuilder#reduce_parameters_plus_end`
+- Method `Ast::ASTVisitor#visit_fun_stmt` for visiting an `Ast::LoxFunStmt` node
+- Method `Ast::LoxBlockStmt#empty?` returns true if the code block is empty
+- Method `BackEnd::Engine#after_fun_stmt`
+- Method `Backend::NativeFunction#call` 
+- Method `Backend::NativeFunction#to_str` 
+- Method `Backend::Function` implementation of a function object.
+
+### Changed
+- Method `BackEnd::Engine#after_call_expr`
+
+### Fixed
+- Fixed inconsistencies in documentation comments.
+
+## [0.0.28] - 2021-02-15
+- The interpreter implements function calls (to a native function).
+
+### Added
+- Class `Ast::LoxCallExpr` a node that represents a function call expression
+- Method `Ast::ASTBuilder#reduce_call_expr`
+- Method `Ast::ASTBuilder#reduce_refinement_plus_end`
+- Method `Ast::ASTBuilder#reduce_call_arglist` creates a `LoxCallExpr` node
+- Method `Ast::ASTBuilder#reduce_arguments_plus_more` builds the function argument array
+- Method `Ast::ASTVisitor#visit_call_expr` for visiting an `Ast::LoxCallExpr` node
+- Method `BackEnd::Engine#after_call_expr`implements the evaluation of a function call.
+- Method `BackEnd::Engine#after_for_stmt` implements most of the `for` control flow
+
 ## [0.0.27] - 2021-01-24
 - The interpreter implements `while` loops.
 

data/lib/loxxy/ast/all_lox_nodes.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative 'lox_fun_stmt'
 require_relative 'lox_variable_expr'
 require_relative 'lox_literal_expr'
 require_relative 'lox_noop_expr'

data/lib/loxxy/ast/ast_builder.rb

@@ -163,6 +163,11 @@ module Loxxy
         [theChildren[0]]
       end
 
+      # rule('funDecl' => 'FUN function')
+      def reduce_fun_decl(_production, _range, _tokens, theChildren)
+        theChildren[1]
+      end
+
       # rule('exprStmt' => 'expression SEMICOLON')
       def reduce_exprStmt(_production, range, tokens, theChildren)
       return_first_child(range, tokens, theChildren) # Discard the semicolon
@@ -227,6 +232,11 @@ module Loxxy
         Ast::LoxBlockStmt.new(tokens[1].position, decls)
       end
 
+      # rule('block' => 'LEFT_BRACE RIGHT_BRACE').as 'block_empty'
+      def reduce_block_empty(_production, _range, tokens, theChildren)
+        Ast::LoxBlockStmt.new(tokens[0].position, nil)
+      end
+
       # rule('assignment' => 'owner_opt IDENTIFIER EQUAL assignment')
       def reduce_assign_expr(_production, _range, tokens, theChildren)
         var_name = theChildren[1].token.lexeme.dup
@@ -284,6 +294,23 @@ module Loxxy
         LoxVariableExpr.new(tokens[0].position, var_name)
       end
 
+      # rule('function' => 'IDENTIFIER LEFT_PAREN params_opt RIGHT_PAREN block').as 'function'
+      def reduce_function(_production, _range, _tokens, theChildren)
+        first_child = theChildren.first
+        pos = first_child.token.position
+        fun_stmt = LoxFunStmt.new(pos, first_child.token.lexeme, theChildren[2], theChildren[4])
+      end
+
+      # rule('parameters' => 'parameters COMMA IDENTIFIER')
+      def reduce_parameters_plus_more(_production, _range, _tokens, theChildren)
+        theChildren[0] << theChildren[2].token.lexeme
+      end
+
+      # rule('parameters' => 'IDENTIFIER')
+      def reduce_parameters_plus_end(_production, _range, _tokens, theChildren)
+        [theChildren[0].token.lexeme]
+      end
+
       # rule('arguments' => 'arguments COMMA expression')
       def reduce_arguments_plus_more(_production, _range, _tokens, theChildren)
         theChildren[0] << theChildren[2]

data/lib/loxxy/ast/ast_visitor.rb

@@ -12,7 +12,7 @@ module Loxxy
       # attr_reader(:runtime)
 
       # Build a visitor for the given top.
-      # @param aRoot [AST::LoxNode] the parse tree to visit.
+      # @param aTop [AST::LoxNode] the parse tree to visit.
       def initialize(aTop)
         raise StandardError if aTop.nil?
 
@@ -52,7 +52,7 @@ module Loxxy
       end
 
       # Visit event. The visitor is about to visit a variable declaration statement.
-      # @param aPrintStmt [AST::LOXVarStmt] the variable declaration node to visit
+      # @param aSeqDecls [AST::LOXSeqDecl] the variable declaration node to visit
       def visit_seq_decl(aSeqDecls)
         broadcast(:before_seq_decl, aSeqDecls)
         traverse_subnodes(aSeqDecls)
@@ -60,7 +60,7 @@ module Loxxy
       end
 
       # Visit event. The visitor is about to visit a variable declaration statement.
-      # @param aPrintStmt [AST::LOXVarStmt] the variable declaration node to visit
+      # @param aVarStmt [AST::LOXVarStmt] the variable declaration node to visit
       def visit_var_stmt(aVarStmt)
         broadcast(:before_var_stmt, aVarStmt)
         traverse_subnodes(aVarStmt)
@@ -103,12 +103,12 @@ module Loxxy
       # @param aBlockStmt [AST::LOXBlockStmt] the print statement node to visit
       def visit_block_stmt(aBlockStmt)
         broadcast(:before_block_stmt, aBlockStmt)
-        traverse_subnodes(aBlockStmt)
+        traverse_subnodes(aBlockStmt) unless aBlockStmt.empty?
         broadcast(:after_block_stmt, aBlockStmt)
       end
 
       # Visit event. The visitor is visiting an assignment node
-      # @param aLiteralExpr [AST::LoxAssignExpr] the variable assignment node to visit.
+      # @param anAssignExpr [AST::LoxAssignExpr] the variable assignment node to visit.
       def visit_assign_expr(anAssignExpr)
         broadcast(:before_assign_expr, anAssignExpr)
         traverse_subnodes(anAssignExpr)
@@ -118,7 +118,7 @@ module Loxxy
       # Visit event. The visitor is about to visit a logical expression.
       # Since logical expressions may take shorcuts by not evaluating all their
       # sub-expressiosns, they are responsible for visiting or not their children.
-      # @param aBinaryExpr [AST::LOXBinaryExpr] the logical expression node to visit
+      # @param aLogicalExpr [AST::LOXLogicalExpr] the logical expression node to visit
       def visit_logical_expr(aLogicalExpr)
         broadcast(:before_logical_expr, aLogicalExpr)
 
@@ -170,25 +170,33 @@ module Loxxy
       end
 
       # Visit event. The visitor is visiting a variable usage node
-      # @param aLiteralExpr [AST::LoxVariableExpr] the variable reference node to visit.
+      # @param aVariableExpr [AST::LoxVariableExpr] the variable reference node to visit.
       def visit_variable_expr(aVariableExpr)
         broadcast(:before_variable_expr, aVariableExpr)
         broadcast(:after_variable_expr, aVariableExpr, self)
       end
 
       # Visit event. The visitor is about to visit the given terminal datatype value.
-      # @param aNonTerminalNode [Ast::BuiltinDattype] the built-in datatype value
+      # @param aValue [Ast::BuiltinDattype] the built-in datatype value
       def visit_builtin(aValue)
         broadcast(:before_visit_builtin, aValue)
         broadcast(:after_visit_builtin, aValue)
       end
 
+      # Visit event. The visitor is about to visit a function statement node.
+      # @param aFunStmt [AST::LoxFunStmt] function declaration to visit
+      def visit_fun_stmt(aFunStmt)
+        broadcast(:before_fun_stmt, aFunStmt)
+        traverse_subnodes(aFunStmt)
+        broadcast(:after_fun_stmt, aFunStmt, self)
+      end
+
       # 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(aNonTerminalNode)
         # Loxxy interpreter encountered a CST node (Concrete Syntax Tree)
         # that it cannot handle.
-        symb = non_terminal_node.symbol.name
+        symb = aNonTerminalNode.symbol.name
         msg = "Loxxy cannot execute this code yet for non-terminal symbol '#{symb}'."
         raise NotImplementedError, msg
       end

data/lib/loxxy/ast/lox_block_stmt.rb

@@ -6,11 +6,15 @@ module Loxxy
   module Ast
     class LoxBlockStmt < LoxCompoundExpr
       # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
-      # @param operand [Loxxy::Ast::LoxSeqDecl]
+      # @param decls [Loxxy::Ast::LoxSeqDecl]
       def initialize(aPosition, decls)
         super(aPosition, [decls])
       end
 
+      def empty?
+        subnodes.size == 1 && subnodes[0].nil?
+      end
+
       # Part of the 'visitee' role in Visitor design pattern.
       # @param visitor [Ast::ASTVisitor] the visitor
       def accept(visitor)

data/lib/loxxy/ast/lox_for_stmt.rb

@@ -18,7 +18,6 @@ module Loxxy
       # @param initialization [Loxxy::Ast::LoxNode]
       # @param testExpr [Loxxy::Ast::LoxNode]
       # @param updateExpr [Loxxy::Ast::LoxNode]
-      # @param body [Loxxy::Ast::LoxNode]
       def initialize(aPosition, initialization, testExpr, updateExpr)
         child = initialization ? [initialization] : []
         super(aPosition, child)

data/lib/loxxy/ast/lox_fun_stmt.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'lox_compound_expr'
+
+module Loxxy
+  module Ast
+    class LoxFunStmt < LoxCompoundExpr
+      attr_reader :name
+      attr_reader :params
+      attr_reader :body
+
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      # @param aName [String]
+      # @param arguments [Array<String>]
+      # @param body [Ast::LoxBlockStmt]
+      def initialize(aPosition, aName, paramList, aBody)
+        super(aPosition, [])
+        @name = aName
+        @params = paramList
+        @body = aBody
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [Ast::ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_fun_stmt(self)
+      end
+
+      alias operands subnodes
+    end # class
+  end # module
+end # module

data/lib/loxxy/ast/lox_if_stmt.rb

@@ -12,7 +12,9 @@ module Loxxy
       attr_reader :else_stmt
 
       # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
-      # @param subExpr [Loxxy::Ast::LoxNode]
+      # @param condExpr [Loxxy::Ast::LoxNode]
+      # @param thenStmt [Loxxy::Ast::LoxNode]
+      # @param elseStmt [Loxxy::Ast::LoxNode]
       def initialize(aPosition, condExpr, thenStmt, elseStmt)
         super(aPosition, [condExpr])
         @then_stmt = thenStmt

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 'function'
 require_relative 'symbol_table'
 
 module Loxxy
@@ -173,11 +174,21 @@ module Loxxy
         # Evaluate callee part
         aCallExpr.callee.accept(aVisitor)
         callee = stack.pop
-        # TODO: reverse order?
-        aCallExpr.arguments.each do |arg|
-          arg.evaluate(aVisitor)
+        aCallExpr.arguments.reverse_each { |arg| arg.accept(aVisitor) }
+
+        if callee.kind_of?(NativeFunction)
+          stack.push callee.call # Pass arguments
+        else
+          new_env = Environment.new(symbol_table.current_env)
+          symbol_table.enter_environment(new_env)
+          callee.parameters&.each do |param_name|
+            local = Variable.new(param_name, stack.pop)
+            symbol_table.insert(local)
+          end
+          stack.push callee.call(aVisitor)
+
+          symbol_table.leave_environment
         end
-        stack.push callee.call # Pass arguments
       end
 
       def after_grouping_expr(_groupingExpr)
@@ -197,16 +208,30 @@ module Loxxy
         stack.push(literalExpr.literal)
       end
 
-      # @param aNonTerminalNode [Ast::BuiltinDattype] the built-in datatype value
+      # @param aValue [Ast::BuiltinDattype] the built-in datatype value
       def before_visit_builtin(aValue)
         stack.push(aValue)
       end
 
+      def after_fun_stmt(aFunStmt, aVisitor)
+        function = Function.new(aFunStmt.name, aFunStmt.params, aFunStmt.body, stack)
+        new_var = Variable.new(aFunStmt.name, function)
+        symbol_table.insert(new_var)
+      end
+
       private
 
       NativeFunction = Struct.new(:callable, :interp) do
         def accept(_visitor)
-          interp.stack.push callable
+          interp.stack.push self
+        end
+
+        def call
+          callable.call
+        end
+
+        def to_str
+          '<native fn>'
         end
       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/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'
@@ -77,7 +77,7 @@ module Loxxy
       rule('returnStmt' => 'RETURN expression_opt SEMICOLON')
       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')
+      rule('block' => 'LEFT_BRACE RIGHT_BRACE').as 'block_empty'
 
       # Expressions: produce values
       rule('expression_opt' => 'expression')
@@ -142,11 +142,11 @@ 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').as 'arguments_plus_more'

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.28'
+  VERSION = '0.1.0'
 end

data/spec/interpreter_spec.rb

@@ -386,13 +386,42 @@ LOX_END
 
       it 'should implement nullary function calls' do
         program = <<-LOX_END
-          print clock(); // Lox expect the 'clock' predefined native function
+          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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: loxxy
 version: !ruby/object:Gem::Version
-  version: 0.0.28
+  version: 0.1.0
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-02-15 00:00:00.000000000 Z
+date: 2021-02-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -93,6 +93,7 @@ files:
 - 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_fun_stmt.rb
 - lib/loxxy/ast/lox_grouping_expr.rb
 - lib/loxxy/ast/lox_if_stmt.rb
 - lib/loxxy/ast/lox_literal_expr.rb
@@ -108,6 +109,7 @@ files:
 - lib/loxxy/back_end/engine.rb
 - lib/loxxy/back_end/entry.rb
 - lib/loxxy/back_end/environment.rb
+- lib/loxxy/back_end/function.rb
 - lib/loxxy/back_end/symbol_table.rb
 - lib/loxxy/back_end/variable.rb
 - lib/loxxy/datatype/all_datatypes.rb