loxxy 0.2.06 → 0.4.00

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cbb2f24e245891baabf20458e5b663784ba7f82ff902ab7892007d9b53d99347
-  data.tar.gz: eab4ede6f48470449f731e3074b2ac2fe72b53449c9471231ea64d0007a873ae
+  metadata.gz: 47c5d65fa1f3c2d0025013577f46edf741572df743d8986e238f49a08ea32702
+  data.tar.gz: 72a3beb6828362e6dc7c73072555ed6f87ed5bf57b4052ac55e06503b9582e29
 SHA512:
-  metadata.gz: 8037d3c239e39d47554c4e7f7698e5908cdaa5e460c8972fe8dc5b58ee5fd59647c413db95250ff739c08f9ca891c8f576eb8d78aa63cf40039e8d1b3328e9a2
-  data.tar.gz: 795face50a76140ba2f6be2e6e6c44e671992baaea2ecade980acf1baed173dc59cbe7cd2ce419b509e8593068ffc3e637e0678dab2db72a96250d4e53ef0338
+  metadata.gz: e83ee511c1ead4592153bb1e8ed8167439894bfefa2bb54060100eb9d221d77c453b4bad3d3e4a36209f3761812a5b9b0aa98b02a53556314c022d1f0b605bca
+  data.tar.gz: 8d939d7ff60687dd64c4dc6e4beccffa512e3483f5b38042a83fffbc0a5cc83d218999f855b8765a47e24b8c0df7808ecd649e70cec11832a0591b5c141a659c

data/CHANGELOG.md

@@ -1,3 +1,53 @@
+## [0.4.00] - 2021-05-24
+- Version bump. `Loxxy` is capable to run the LoxLox interpreter, an interpreter written in `Lox`.
+
+### New
+- Method `BackEnd::LoxInstance#falsey?` added
+- Method `BackEnd::LoxInstance#truthy?` added
+
+### Changed
+-  Method `BackEnd::Engine#after_variable_expr` the error message `Undefined variable` nows gives the location of the offending variable.
+- Class `Ast::LoxClassStmt`is now a subclass of `LoxNode`
+
+- File `README.md` added an explanation on how to run `LoxLox`interpreter.
+
+### Fixed
+- Method `Ast::LoxClassStmt#initialize` fixed inconsistencies in its Yard/RDoc documentation.
+- Method `Ast::LoxFunStmt#initialize` fixed inconsistencies in its Yard/RDoc documentation.
+- Method `BackEnd::Engine#native_getc` now returns -1 when its reaches EOF.
+- Method `BackEnd::Resolver#after_logical_expr` was missing and this caused the lack of resultation in the second operand.
+
+## [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.
+
+### New
+- Added the new subfolder `extra` under `test_suite`. It will contain tests for non-standard features or tests not covered in standard test suite.
+
+### Fixed
+- Class `FrontEnd::Scanner`: Couldn't correctly recognize a plus preceding directly a number literal
+
+## [0.3.00] - 2021-05-07
+- Milestone: `Loxxy` passes all reference test suite.
+
+### Fixed
+- Method `BackEnd::Resolver#before_variable_expr`: Standard `Lox` allows re-declaration of a variable at top-level scope 
+
+ 
 ## [0.2.06] - 2021-05-04
 - Nearly passing the 'official' test suite, fixing non-compliant behavior, specialized exceptions for errors
 

data/README.md

@@ -19,11 +19,18 @@ Although __Lox__ is fairly simple, it is far from being a toy language:
 ### Loxxy gem features
 - Complete tree-walking interpreter including lexer, parser and resolver
 - 100% pure Ruby with clean design (not a port from some other language)
+- Passes the `jox` (THE reference `Lox` implementation) test suite
+- Can run a Lox imterpreter implemented in ... `Lox` [LoxLox](https://github.com/benhoyt/loxlox),
 - Minimal runtime dependency (Rley gem). Won't drag a bunch of gems...  
 - Ruby API for integrating a Lox interpreter with your code.
 - A command-line interpreter `loxxy`
 - Open for your language extensions...
 
+### Why `Loxxy` ?
+- If programming languages are one of your subject interest...
+- ... and you wanted learn how to implement one in Ruby...
+- ... then `Loxxy` can help to understand and experiment in this rewarding craft.
+
 ## How to start in 1, 2, 3...?
 ... in less than 3 minutes...
 
@@ -47,6 +54,7 @@ And then execute:
 ### 2. Your first `Lox`  program
 Create a text file and enter the following lines:
 ```javascript
+// hello.lox
 // Your firs Lox program
 print "Hello, world.";
 ```
@@ -69,6 +77,7 @@ Let's admit it, the hello world example was unimpressive.
 To a get a taste of `Lox` object-oriented capabilities, let's try another `Hello world` variant:
 
 ```javascript
+// oo_hello.lox
 // Object-oriented hello world
 class Greeter {
   // in Lox, initializers/constructors are named `init`
@@ -92,6 +101,7 @@ Our next assignment: compute the first 20 elements of the Fibbonacci sequence.
 Here's an answer using the `while` loop construct:
 
 ```javascript
+// fibbonacci.lox
 // Compute the first 20 elements from the Fibbonacci sequence
 
 var a = 0;  // Use the var keyword to declare a new variable
@@ -121,6 +131,7 @@ Fans of `for` loops will be pleased to find their favorite looping construct.
 Here again, the Fibbonacci sequence refactored with a `for` loop:
 
 ```javascript
+// fibbonacci_v2.lox
 // Fibbonacci sequence - version 2
 var a = 0;
 var b = 1;
@@ -163,13 +174,69 @@ for (var i = 0; i < count; i = i + 1) {
 }
 ```
 
+### Loxxy goes meta...
+The `Loxxy` is able to run the `LoxLox` interpreter.
+[LoxLox](https://github.com/benhoyt/loxlox) is a Lox interpreter written in Lox by Ben Hoyt.  
+This interpreter with over 1900 lines long is (one of) the longest Lox pragram.
+As such, it is a good testbed for any Lox interpreter.
+
+Executing a lox program with the LoxLox interpreter that is itself running on top of Loxxy.
+#### Step 1 Download `lox.lox´ file
+Download the [LoxLox](https://github.com/benhoyt/loxlox) source file in Github.
+
+#### Step 2 (alternative a): running from the command line
+
+```
+$ loxxy lox.lox
+```
+
+Once loxxy CLI starts its interpreter that, in turn, executes the LoxLox interpreter.
+This may take a couple of seconds.
+Don't be surprised, if the program seems unresponsive: it is waiting for you input.
+Enter a line like this:
+```
+  print "Hello, world!";
+```  
+Then terminate with an end of file (crtl-D on Linuxes, crtl-z on Windows) followed by an enter key.
+You should see the famous greeting.
+
+#### Step 2 (alternative b): launching the interpreter from Ruby snippet
+The following snippet executes the LoxLox interpreter and feeds to it the
+input text. That input text is made available through a StringIO that replaces
+the `$stdio` device.
+
+```ruby
+require 'stringio'
+require 'loxxy'
+
+# Place your Lox pragram within the heredoc
+program = <<-LOX_END
+  print "Hello, world!";
+LOX_END
+
+lox_filename = 'lox.lox'
+File.open(lox_filename, 'r') do |f|
+  source = f.read
+  cfg = { istream: StringIO.new(program, 'r')}
+  lox = Loxxy::Interpreter.new(cfg)
+  lox.evaluate(source)
+end
+```
+
+Save this snippet as a Ruby file, launch Ruby with this file in command line.
+After a couple of seconds, you'll see the Ruby interpreter that executes the 
+Loxxy interpreter that itself executes the LoxLox interpreter written in Lox.
+That last interpreter is the one that run the hello world line.
+
+That's definitively meta...
+
 This completes our quick tour of `Lox`, to learn more about the language,
 check the online book [Crafting Interpreters](https://craftinginterpreters.com/ )
 
 ## What's the fuss about Lox?
 ... Nothing...  
 Bob Nystrom designed a language __simple__ enough so that he could present
-two implementations (an interpreter, then a compiler) in one single book.
+two interpreter implementations (a tree-walking one, then a bytecode one) in one single book.
 
 In other words, __Lox__ contains interesting features found in most general-purpose
 languages. In addition to that, there are [numerous implementations](https://github.com/munificent/craftinginterpreters/wiki/Lox-implementations) in different languages 
@@ -196,14 +263,11 @@ There are already a number of programming languages derived from `Lox`...
 ### Purpose of this project:
 - To deliver an open source example of a programming language fully implemented in Ruby  
   (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.
   
 ### Roadmap
 - Extend the test suite
 - Improve the error handling  
 - Improve the documentation
-- Ability run the LoxLox interpreter
 
 ## Hello world example
 The next examples show how to use the interpreter directly from Ruby code.

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])
@@ -395,9 +395,10 @@ module Loxxy
       end
 
       # rule('primary' => 'IDENTIFIER')
-      def reduce_variable_expr(_production, _range, tokens, theChildren)
+      def reduce_variable_expr(_production, _range, _tokens, theChildren)
         var_name = theChildren[0].token.lexeme
-        LoxVariableExpr.new(tokens[0].position, var_name)
+        pos = theChildren[0].token.position
+        LoxVariableExpr.new(pos, var_name)
       end
 
       # rule('primary' => 'THIS')

data/lib/loxxy/ast/ast_visitor.rb

@@ -71,7 +71,6 @@ module Loxxy
       # @param aClassStmt [AST::LOXClassStmt] the for statement node to visit
       def visit_class_stmt(aClassStmt)
         broadcast(:before_class_stmt, aClassStmt)
-        traverse_subnodes(aClassStmt) # The methods are visited here...
         broadcast(:after_class_stmt, aClassStmt, self)
       end
 
@@ -126,7 +125,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_class_stmt.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
-require_relative 'lox_compound_expr'
+require_relative 'lox_node'
 
 module Loxxy
   module Ast
-    class LoxClassStmt < LoxCompoundExpr
+    # A parse tree node that represents a Lox class declaration.
+    class LoxClassStmt < LoxNode
       # @return [String] the class name
       attr_reader :name
 
@@ -14,11 +15,13 @@ module Loxxy
       # @return [Array<Ast::LoxFunStmt>] the methods
       attr_reader :body
 
+      # Constructor for a parse node that represents a Lox function declaration
       # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
-      # @param condExpr [Loxxy::Ast::LoxNode] iteration condition
-      # @param theBody [Array<Loxxy::Ast::LoxNode>]
+      # @param aName [String] the class name
+      # @param aSuperclassName [String] the super class name
+      # @param theMethods [Array<Loxxy::Ast::LoxFunStmt>] the methods
       def initialize(aPosition, aName, aSuperclassName, theMethods)
-        super(aPosition, [])
+        super(aPosition)
         @name = aName.dup
         @superclass = aSuperclassName
         @body = theMethods

data/lib/loxxy/ast/lox_fun_stmt.rb

@@ -4,17 +4,25 @@ require_relative 'lox_node'
 
 module Loxxy
   module Ast
-    # rubocop: disable Style/AccessorGrouping
+    # A parse tree node that represents a Lox function declaration.
     class LoxFunStmt < LoxNode
+      # @return [String] the function name
       attr_reader :name
+
+      # @return [Array<String>] the parameter names
       attr_reader :params
+
+      # @return [Ast::LoxBlockStmt] the parse tree representing the function's body
       attr_reader :body
+
+      # @return [Boolean] true if the function is a method
       attr_accessor :is_method
 
+      # Constructor for a parse node that represents a Lox function declaration
       # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
-      # @param aName [String]
-      # @param arguments [Array<String>]
-      # @param body [Ast::LoxBlockStmt]
+      # @param aName [String] the function name
+      # @param paramList [Array<String>] the parameter names
+      # @param aBody [Ast::LoxBlockStmt] the parse tree representing the function's body
       def initialize(aPosition, aName, paramList, aBody)
         super(aPosition)
         @name = aName.dup
@@ -25,6 +33,5 @@ module Loxxy
 
       define_accept # Add `accept` method as found in Visitor design pattern
     end # class
-    # rubocop: enable Style/AccessorGrouping
   end # module
 end # module

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)
@@ -278,14 +326,17 @@ module Loxxy
       def after_variable_expr(aVarExpr, aVisitor)
         var_name = aVarExpr.name
         var = variable_lookup(aVarExpr)
-        raise Loxxy::RuntimeError, "Undefined variable '#{var_name}'." unless var
+        unless var
+          pos = "line #{aVarExpr.position.line}:#{aVarExpr.position.column}"
+          raise Loxxy::RuntimeError, "[#{pos}] Undefined variable '#{var_name}'."
+        end
 
         var.value.accept(aVisitor) # Evaluate variable value then push on stack
       end
 
       # @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 +355,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 +392,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 +404,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 +440,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 +474,40 @@ module Loxxy
         end
       end
 
+      # Read a single character and return the character code as an integer.
+      # LoxLox requires the end of input to be a negative number
+      def native_getc
+        proc do
+          ch = @istream.getc
+          val = ch ? ch.codepoints[0] : -1
+          Datatype::Number.new(val)
+        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