loxxy 0.3.01 → 0.3.02

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f6a77cf0f7f4cd0c445d597c534ecc1de82a31222d54a3d0da30330ccbcb216e
-  data.tar.gz: c10cab44247a3f7d75382c7a6bbfbc7938bce368ba14ea48878643ea7778aca5
+  metadata.gz: a0e398714d64763c288f06c315611c86bf3dae2e3403055ae3ca240a10bd292f
+  data.tar.gz: 8db95e837824181e1794277dc3e67e4005432006877124bbd62ffd07def57591
 SHA512:
-  metadata.gz: 5f76a5a66ff5ecdc76207802e195c7becdaf214cb687f9a62be1b58dc56d3ea0a9b3320bb2b8a105a72e3ff79801e3065eb3c10cab6246de2a4a5e74f4ebb722
-  data.tar.gz: eafb0e81fa6c6b5c8c3c2a017907b14e3a4ebadd04ec51cb9d79030905562e86ecf37d9e68511ff52ab4ae45eb598f8c7de4fa6344f90034f21635b8f2c983ff
+  metadata.gz: caf2aab9a8c03997fbde67467b7cb66a786c2fb8ef46fc24869c42ac7da76831f5e771a282c938ec83585666de801602ffc9818fc489454ec93dec9bd76bf5a7
+  data.tar.gz: 9d98db7d9bddec915929dc1cbaed057248ccb5e0cc63efc3d0d7e99536ea9b330925d91d6b1ffd6805194dc3805b0025228f66d11f11b5455cb8f52d7753e6eb

data/CHANGELOG.md

@@ -1,3 +1,18 @@
+## [0.3.02] - 2021-05-22
+- New built-in expressions `getc`, `chr`, `exit` and `print_eeror` , fixes with deeply nested returns, set expressions
+
+### New
+- Class `BackEnd::Engine` new built-in functions `getc`, `chr`, `exit`, and `print_error`
+
+### Changed
+- Class `Ast::LoxSetExpr` value to assign is now a distinct atrrbute instead of a subnode
+-  Class `BackEnd::Engine` two distinct stacks: one of expression evaluation, another for argument passing
+
+### Fixed
+- Class `BackEnd::LoxClass`: in some contexts the init method returned twice 'this'.
+- Method `LoxFunction#call` mismatch between deeply nested returns and environments
+
+
 ## [0.3.01] - 2021-05-08
 - Fix in `Scanner` class, added more tests in test suite.
 

data/lib/loxxy/ast/ast_builder.rb

@@ -318,7 +318,7 @@ module Loxxy
         name_assignee = theChildren[1].token.lexeme.dup
         if theChildren[0].kind_of?(Ast::LoxSetExpr)
           theChildren[0].property = name_assignee
-          theChildren[0].subnodes << theChildren[3]
+          theChildren[0].value = theChildren[3]
           theChildren[0]
         else
           Ast::LoxAssignExpr.new(tokens[1].position, name_assignee, theChildren[3])

data/lib/loxxy/ast/ast_visitor.rb

@@ -126,7 +126,6 @@ module Loxxy
       # @param aSetExpr [AST::LOXGetExpr] the get expression node to visit
       def visit_set_expr(aSetExpr)
         broadcast(:before_set_expr, aSetExpr, self)
-        traverse_subnodes(aSetExpr)
         broadcast(:after_set_expr, aSetExpr, self)
       end
 

data/lib/loxxy/ast/lox_set_expr.rb

@@ -4,17 +4,20 @@ require_relative 'lox_compound_expr'
 
 module Loxxy
   module Ast
-    class LoxSetExpr < LoxCompoundExpr
+    class LoxSetExpr < LoxNode
       # @return [Ast::LoxNode] the object to which the property belongs to
       attr_reader :object
 
       # @return [String] Name of an object property
       attr_accessor :property
 
+      # @return [LoxNode, Datatype] value to assign
+      attr_accessor :value
+
       # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
       # @param anObject [Ast::LoxNode] The object which the given property is being set
       def initialize(aPosition, anObject)
-        super(aPosition, [])
+        super(aPosition)
         @object = anObject
       end
 

data/lib/loxxy/back_end/engine.rb

@@ -20,7 +20,7 @@ module Loxxy
       # @return [BackEnd::SymbolTable]
       attr_reader :symbol_table
 
-      # @return [Array<Datatype::BuiltinDatatype>] Data stack for the expression results
+      # @return [Array<Datatype::BuiltinDatatype>] Data stack for arguments and return results
       attr_reader :stack
 
      # @return [Hash { Symbol => UnaryOperator}]
@@ -35,17 +35,31 @@ module Loxxy
       # @param theOptions [Hash]
       def initialize(theOptions)
         @config = theOptions
+        @istream = config.include?(:istream) ? config[:istream] : $stdin
         @ostream = config.include?(:ostream) ? config[:ostream] : $stdout
         @symbol_table = SymbolTable.new
         @stack = []
-        @unary_operators = {}
-        @binary_operators = {}
 
+        reset_expr_stack
         init_unary_operators
         init_binary_operators
         init_globals
       end
 
+      # Returns the current environment
+      # @return [Loxxy::BackEnd::Environment]
+      def current_env
+        symbol_table.current_env
+      end
+
+      def expr_stack
+        current_env.expr_stack
+      end
+
+      def reset_expr_stack
+        current_env.expr_stack.clear
+      end
+
       # Given an abstract syntax parse tree visitor, launch the visit
       # and execute the visit events in the output stream.
       # @param aVisitor [AST::ASTVisitor]
@@ -58,7 +72,7 @@ module Loxxy
         aVisitor.subscribe(self)
         aVisitor.start
         aVisitor.unsubscribe(self)
-        stack.empty? ? Datatype::Nil.instance : stack.pop
+        expr_stack.empty? ? Datatype::Nil.instance : expr_stack.pop
       end
 
       ##########################################################################
@@ -69,10 +83,14 @@ module Loxxy
         # Do nothing, subnodes were already evaluated
       end
 
+      def before_class_stmt(_class_stmt)
+        reset_expr_stack
+      end
+
       def after_class_stmt(aClassStmt, aVisitor)
         if aClassStmt.superclass
           aClassStmt.superclass.accept(aVisitor)
-          parent = stack.pop
+          parent = expr_stack.pop
           unless parent.kind_of?(LoxClass)
             raise Loxxy::RuntimeError, 'Superclass must be a class.'
           end
@@ -89,7 +107,7 @@ module Loxxy
         meths = aClassStmt.body.map do |func_node|
           func_node.is_method = true
           func_node.accept(aVisitor)
-          mth = stack.pop
+          mth = expr_stack.pop
           mth.is_initializer = true if mth.name == 'init'
           mth
         end
@@ -104,11 +122,15 @@ module Loxxy
         symbol_table.insert(new_var)
       end
 
+      def before_var_stmt(_var_stmt)
+        reset_expr_stack
+      end
+
       def after_var_stmt(aVarStmt)
         new_var = Variable.new(aVarStmt.name, Datatype::Nil.instance)
         symbol_table.insert(new_var)
 
-        value = stack.pop
+        value = expr_stack.pop
         new_var.assign(value)
       end
 
@@ -116,9 +138,14 @@ module Loxxy
         before_block_stmt(aForStmt)
       end
 
+      def before_if_stmt(_if_stmt)
+        reset_expr_stack
+      end
+
       def after_if_stmt(anIfStmt, aVisitor)
         # Retrieve the result of the condition evaluation
-        condition = stack.pop
+        # condition = stack.pop
+        condition = expr_stack.pop
         if condition.truthy?
           anIfStmt.then_stmt.accept(aVisitor)
         elsif anIfStmt.else_stmt
@@ -126,18 +153,31 @@ module Loxxy
         end
       end
 
+      def before_print_stmt(_print_stmt)
+        reset_expr_stack
+      end
+
       def after_print_stmt(_printStmt)
-        tos = stack.pop
+        tos = expr_stack.pop
         @ostream.print tos ? tos.to_str : 'nil'
       end
 
+      def before_return_stmt(_return_stmt)
+        reset_expr_stack
+      end
+
       def after_return_stmt(_returnStmt, _aVisitor)
+        stack.push(expr_stack.pop)
         throw(:return)
       end
 
+      def before_while_stmt(_while_stmt)
+        reset_expr_stack
+      end
+
       def after_while_stmt(aWhileStmt, aVisitor)
         loop do
-          condition = stack.pop
+          condition = expr_stack.pop
           break unless condition.truthy?
 
           aWhileStmt.body.accept(aVisitor)
@@ -146,6 +186,7 @@ module Loxxy
       end
 
       def before_block_stmt(_aBlockStmt)
+        reset_expr_stack
         new_env = Environment.new
         symbol_table.enter_environment(new_env)
       end
@@ -159,40 +200,42 @@ module Loxxy
         variable = variable_lookup(anAssignExpr)
         raise Loxxy::RuntimeError, "Undefined variable '#{var_name}'." unless variable
 
-        value = stack.last # ToS remains since an assignment produces a value
+        value = expr_stack.last # ToS remains since an assignment produces a value
         variable.assign(value)
       end
 
-      def before_set_expr(aSetExpr, aVisitor)
-        # Evaluate receiver object part
-        aSetExpr.object.accept(aVisitor)
+      def before_set_expr(_set_expr, _visitor)
+        reset_expr_stack
       end
 
-      def after_set_expr(aSetExpr, _visitor)
-        value = stack.pop
-        assignee = stack.pop
+      def after_set_expr(aSetExpr, aVisitor)
+        # Evaluate receiver object part (i.e. 'this')
+        aSetExpr.object.accept(aVisitor)
+        assignee = expr_stack.pop
         unless assignee.kind_of?(LoxInstance)
           raise Loxxy::RuntimeError, 'Only instances have fields.'
         end
 
+        aSetExpr.value.accept(aVisitor)
+        value = expr_stack.pop
+
         assignee.set(aSetExpr.property, value)
-        stack.push value
+        expr_stack.push value
       end
 
       def after_logical_expr(aLogicalExpr, visitor)
         op = aLogicalExpr.operator
-        operand1 = stack.pop # only first operand was evaluated
+        operand1 = expr_stack.pop # only first operand was evaluated
         result = nil
         if ((op == :and) && operand1.falsey?) || ((op == :or) && operand1.truthy?)
           result = operand1
         else
           raw_operand2 = aLogicalExpr.subnodes[1]
           raw_operand2.accept(visitor) # Visit means operand2 is evaluated
-          operand2 = stack.pop
+          operand2 = expr_stack.pop
           result = logical_2nd_arg(operand2)
         end
-
-        stack.push result
+        expr_stack.push result
       end
 
       def logical_2nd_arg(operand2)
@@ -212,14 +255,14 @@ module Loxxy
       end
 
       def after_binary_expr(aBinaryExpr)
-        operand2 = stack.pop
-        operand1 = stack.pop
+        operand2 = expr_stack.pop
+        operand1 = expr_stack.pop
         op = aBinaryExpr.operator
         operator = binary_operators[op]
         operator.validate_operands(operand1, operand2)
         if operand1.respond_to?(op)
           result = operand1.send(op, operand2)
-          stack.push convert2lox_datatype(result)
+          expr_stack.push convert2lox_datatype(result)
         else
           msg1 = "`#{op}': Unimplemented operator for a #{operand1.class}."
           raise StandardError, msg1
@@ -227,13 +270,13 @@ module Loxxy
       end
 
       def after_unary_expr(anUnaryExpr)
-        operand = stack.pop
+        operand = expr_stack.pop
         op = anUnaryExpr.operator
         operator = unary_operators[op]
         operator.validate_operand(operand)
         if operand.respond_to?(op)
           result = operand.send(op)
-          stack.push convert2lox_datatype(result)
+          expr_stack.push convert2lox_datatype(result)
         else
           msg1 = "`#{op}': Unimplemented operator for a #{operand.class}."
           raise StandardError, msg1
@@ -243,12 +286,17 @@ module Loxxy
       def after_call_expr(aCallExpr, aVisitor)
         # Evaluate callee part
         aCallExpr.callee.accept(aVisitor)
-        callee = stack.pop
+        callee = expr_stack.pop
+        before_size = expr_stack.size
         aCallExpr.arguments.reverse_each { |arg| arg.accept(aVisitor) }
+        after_size = expr_stack.size
+        if after_size > before_size
+          stack.concat(expr_stack.pop(after_size - before_size))
+        end
 
         case callee
         when NativeFunction
-          stack.push callee.call # Pass arguments
+          expr_stack.push callee.call # Pass arguments
         when LoxFunction, LoxClass
           arg_count = aCallExpr.arguments.size
           if arg_count != callee.arity
@@ -263,12 +311,12 @@ module Loxxy
 
       def after_get_expr(aGetExpr, aVisitor)
         aGetExpr.object.accept(aVisitor)
-        instance = stack.pop
+        instance = expr_stack.pop
         unless instance.kind_of?(LoxInstance)
           raise Loxxy::RuntimeError, 'Only instances have properties.'
         end
 
-        stack.push instance.get(aGetExpr.property)
+        expr_stack.push instance.get(aGetExpr.property)
       end
 
       def after_grouping_expr(_groupingExpr)
@@ -285,7 +333,7 @@ module Loxxy
 
       # @param literalExpr [Ast::LoxLiteralExpr]
       def before_literal_expr(literalExpr)
-        stack.push(literalExpr.literal)
+        expr_stack.push(literalExpr.literal)
       end
 
       def after_this_expr(aThisExpr, aVisitor)
@@ -304,18 +352,22 @@ module Loxxy
           raise Loxxy::RuntimeError, "Undefined property '#{aSuperExpr.property}'."
         end
 
-        stack.push method.bind(instance)
+        expr_stack.push method.bind(instance)
       end
 
       # @param aValue [Ast::BuiltinDattype] the built-in datatype value
       def before_visit_builtin(aValue)
-        stack.push(aValue)
+        expr_stack.push(aValue)
+      end
+
+      def before_fun_stmt(_fun_stmt, _visitor)
+        reset_expr_stack
       end
 
       def after_fun_stmt(aFunStmt, _visitor)
         function = LoxFunction.new(aFunStmt.name, aFunStmt.params, aFunStmt.body, self)
         if aFunStmt.is_method
-          stack.push function
+          expr_stack.push function
         else
           new_var = Variable.new(aFunStmt.name, function)
           symbol_table.insert(new_var)
@@ -337,21 +389,9 @@ module Loxxy
         env.defns[aVarNode.name]
       end
 
-      NativeFunction = Struct.new(:callable, :interp) do
-        def accept(_visitor)
-          interp.stack.push self
-        end
-
-        def call
-          callable.call
-        end
-
-        def to_str
-          '<native fn>'
-        end
-      end
-
       def init_unary_operators
+        @unary_operators = {}
+
         negate_op = UnaryOperator.new('-', [Datatype::Number])
         unary_operators[:-@] = negate_op
 
@@ -361,6 +401,8 @@ module Loxxy
       end
 
       def init_binary_operators
+        @binary_operators = {}
+
         plus_op = BinaryOperator.new('+', [[Datatype::Number, :idem],
           [Datatype::LXString, :idem]])
         binary_operators[:+] = plus_op
@@ -395,6 +437,24 @@ module Loxxy
 
       def init_globals
         add_native_fun('clock', native_clock)
+        add_native_fun('getc', native_getc)
+        add_native_fun('chr', native_chr)
+        add_native_fun('exit', native_exit)
+        add_native_fun('print_error', native_print_error)
+      end
+
+      NativeFunction = Struct.new(:callable, :interp) do
+        def accept(_visitor)
+          interp.expr_stack.push self
+        end
+
+        def call
+          callable.call
+        end
+
+        def to_str
+          '<native fn>'
+        end
       end
 
       def add_native_fun(aName, aProc)
@@ -411,6 +471,38 @@ module Loxxy
         end
       end
 
+      # Read a single character and return the character code as an integer.
+      def native_getc
+        proc do
+          ch = @istream.getc
+          Datatype::Number.new(ch.codepoints[0])
+        end
+      end
+
+      # chr(ch): Convert given character code number to a single-character string.
+      def native_chr
+        proc do
+          codepoint = stack.pop
+          Datatype::LXString.new(codepoint.value.chr)
+        end
+      end
+
+      # exit(status): Exit with given status code.
+      def native_exit
+        proc do
+          status = stack.pop
+          exit(status.value)
+        end
+      end
+
+      # print_error(message): Print message string on stderr.
+      def native_print_error
+        proc do
+          message = stack.pop
+          $stderr.print message.value
+        end
+      end
+
       def convert2lox_datatype(item)
         case item
         when TrueClass then Datatype::True.instance

data/lib/loxxy/back_end/environment.rb

@@ -25,11 +25,15 @@ module Loxxy
       # @return [Hash{String => Variable}] Pairs of the kind
       attr_reader :defns
 
+      # @return [Array<LoxNode>] stack of values needed in evaluating an expression
+      attr_reader :expr_stack
+
       # Construct a environment instance.
       # @param aParent [Environment, NilClass] Parent environment to this one.
       def initialize(aParent = nil)
         @enclosing = aParent
         @defns = {}
+        @expr_stack = []
       end
 
       # Add a new variable to the environment.

data/lib/loxxy/back_end/lox_class.rb

@@ -7,17 +7,15 @@ module Loxxy
   module BackEnd
     # Runtime representation of a Lox class.
     class LoxClass
-      # rubocop: disable Style/AccessorGrouping
-
       # @return [String] The name of the class
       attr_reader :name
       attr_reader :superclass
 
       # @return [Hash{String => LoxFunction}] the list of methods
       attr_reader :meths
-      attr_reader :stack
 
-      # rubocop: enable Style/AccessorGrouping
+      # @return [Loxxy::BackEnd::Engine]
+      attr_reader :engine
 
       # Create a class with given name
       # @param aName [String] The name of the class
@@ -28,11 +26,11 @@ module Loxxy
         theMethods.each do |func|
           meths[func.name] = func
         end
-        @stack = anEngine.stack
+        @engine = anEngine
       end
 
       def accept(_visitor)
-        stack.push self
+        engine.expr_stack.push self
       end
 
       def arity
@@ -46,9 +44,9 @@ module Loxxy
         if initializer
           constructor = initializer.bind(instance)
           constructor.call(engine, visitor)
+        else
+          engine.expr_stack.push(instance)
         end
-
-        engine.stack.push(instance)
       end
 
       # @param aName [String] the method name to search for

data/lib/loxxy/back_end/lox_function.rb

@@ -13,7 +13,7 @@ module Loxxy
       # @return [Array<>] the parameters
       attr_reader :parameters
       attr_reader :body
-      attr_reader :stack
+      attr_reader :engine
       attr_reader :closure
       attr_accessor :is_initializer
 
@@ -23,7 +23,7 @@ module Loxxy
         @name = aName.dup
         @parameters = parameterList
         @body = aBody.kind_of?(Ast::LoxNoopExpr) ? aBody : aBody.subnodes[0]
-        @stack = anEngine.stack
+        @engine = anEngine
         @closure = anEngine.symbol_table.current_env
         @is_initializer = false
         anEngine.symbol_table.current_env.embedding = true
@@ -34,28 +34,34 @@ module Loxxy
       end
 
       def accept(_visitor)
-        stack.push self
+        engine.expr_stack.push self
       end
 
-      def call(engine, aVisitor)
+      def call(_engine, aVisitor)
         new_env = Environment.new(closure)
         engine.symbol_table.enter_environment(new_env)
 
         parameters&.each do |param_name|
-          local = Variable.new(param_name, stack.pop)
+          local = Variable.new(param_name, engine.stack.pop)
           engine.symbol_table.insert(local)
         end
 
         catch(:return) do
-          (body.nil? || body.kind_of?(Ast::LoxNoopExpr)) ? Datatype::Nil.instance : body.accept(aVisitor)
-          throw(:return)
+          body.accept(aVisitor) unless body.nil? || body.kind_of?(Ast::LoxNoopExpr)
+          # implicit return at end of function...
+          engine.stack.push(Datatype::Nil.instance) unless is_initializer
         end
+        # Compensate for deeply nested return
+        engine.symbol_table.leave_environment while engine.current_env != new_env
+
         if is_initializer
           enclosing_env = engine.symbol_table.current_env.enclosing
           engine.stack.push(enclosing_env.defns['this'].value)
         end
 
         engine.symbol_table.leave_environment
+        # engine.expr_stack.clear
+        engine.expr_stack.push(engine.stack.pop) unless engine.stack.empty?
       end
 
       def bind(anInstance)

data/lib/loxxy/back_end/lox_instance.rb

@@ -23,7 +23,7 @@ module Loxxy
       end
 
       def accept(_visitor)
-        engine.stack.push self
+        engine.expr_stack.push self
       end
 
       # Text representation of a Lox instance

data/lib/loxxy/back_end/resolver.rb

@@ -133,6 +133,7 @@ module Loxxy
       end
 
       def after_set_expr(aSetExpr, aVisitor)
+        aSetExpr.value.accept(aVisitor)
         # Evaluate object part
         aSetExpr.object.accept(aVisitor)
       end

data/lib/loxxy/front_end/scanner.rb

@@ -91,7 +91,6 @@ module Loxxy
 
       private
 
-      # rubocop: disable Lint/DuplicateBranch
       def _next_token
         skip_intertoken_spaces
         curr_ch = scanner.peek(1)
@@ -125,7 +124,6 @@ module Loxxy
 
         return token
       end
-      # rubocop: enable Lint/DuplicateBranch
 
       def build_token(aSymbolName, aLexeme)
         begin

data/lib/loxxy/version.rb

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

data/spec/back_end/engine_spec.rb

@@ -35,8 +35,8 @@ module Loxxy
         let(:lit_expr) { Ast::LoxLiteralExpr.new(sample_pos, greeting) }
 
         it "should react to 'after_var_stmt' event" do
-          # Precondition: value to assign is on top of stack
-          subject.stack.push(greeting)
+          # Precondition: value to assign is on top of expr stack
+          subject.expr_stack.push(greeting)
 
           expect { subject.after_var_stmt(var_decl) }.not_to raise_error
           current_env = subject.symbol_table.current_env
@@ -46,7 +46,17 @@ module Loxxy
 
         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)
+          expect(subject.expr_stack.pop).to eq(greeting)
+        end
+      end
+
+      context 'Built-in functions:' do
+        it 'should provide built-in functions' do
+          symb_table = subject.symbol_table
+          %w[clock getc chr exit print_error].each do |name|
+            fun_var = symb_table.current_env.defns[name]
+            expect(fun_var.value).to be_kind_of(BackEnd::Engine::NativeFunction)
+          end
         end
       end
     end # describe

data/spec/front_end/parser_spec.rb

@@ -353,8 +353,8 @@ LOX_END
           expect(expr).to be_kind_of(Ast::LoxSetExpr)
           expect(expr.object.name).to eq('someObject')
           expect(expr.property).to eq('someProperty')
-          expect(expr.subnodes[0]).to be_kind_of(Ast::LoxVariableExpr)
-          expect(expr.subnodes[0].name).to eq('value')
+          expect(expr.value).to be_kind_of(Ast::LoxVariableExpr)
+          expect(expr.value.name).to eq('value')
         end
 
         it 'should parse complex set access' do
@@ -372,8 +372,8 @@ LOX_END
           expr = ptree.root.subnodes[0]
           expect(expr).to be_kind_of(Ast::LoxSetExpr)
           expect(expr.property).to eq('meat')
-          expect(expr.subnodes[0]).to be_kind_of(Ast::LoxVariableExpr)
-          expect(expr.subnodes[0].name).to eq('ham')
+          expect(expr.value).to be_kind_of(Ast::LoxVariableExpr)
+          expect(expr.value.name).to eq('ham')
           expect(expr.object).to be_kind_of(Ast::LoxGetExpr)
           expect(expr.object.property).to eq('filling')
           expect(expr.object.object).to be_kind_of(Ast::LoxGetExpr)

data/spec/interpreter_spec.rb

@@ -430,6 +430,50 @@ LOX_END
         expect(sample_cfg[:ostream].string).to eq('<fn foo><native fn>')
       end
 
+      it "should implement 'getc' function" do
+        input_str = 'Abc'
+        cfg = { istream: StringIO.new(input_str) }
+        interpreter = Loxxy::Interpreter.new(cfg)
+        source = 'getc();'
+        result = interpreter.evaluate(source)
+        expect(result.value).to eq(65) # codepoint for letter 'A'
+      end
+
+      it "should implement 'chr' function" do
+        source = 'chr(65); // => "A"'
+        result = subject.evaluate(source)
+        expect(result.value).to eq('A')
+      end
+
+      # This test is disabled since it causes RSpec to stop immediately
+      # it "should implement 'exit' function" do
+      #   source = 'exit(100); // Process halts with exit code 100'
+      #   expect { subject.evaluate(source) }.to raise(SystemExit)
+      # end
+
+      it "should implement 'print_error' function" do
+        source = 'print_error("Some error"); // => Some error on stderr'
+        stderr_backup = $stderr
+        $stderr = StringIO.new
+        expect { subject.evaluate(source) }.not_to raise_error
+        expect($stderr.string).to eq('Some error')
+        $stderr = stderr_backup
+      end
+
+      # rubocop: disable Style/StringConcatenation
+      it 'should return in absence of explicit return statement' do
+        program = <<-LOX_END
+          fun foo() {
+            print "foo";
+          }
+
+          print foo();
+        LOX_END
+        expect { subject.evaluate(program) }.not_to raise_error
+        expect(sample_cfg[:ostream].string).to eq('foo' + 'nil')
+      end
+      # rubocop: enable Style/StringConcatenation
+
       it 'should support return statements' do
         program = <<-LOX_END
           fun max(a, b) {

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: loxxy
 version: !ruby/object:Gem::Version
-  version: 0.3.01
+  version: 0.3.02
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-05-08 00:00:00.000000000 Z
+date: 2021-05-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley