loxxy 0.1.0 → 0.1.05

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 42a88690625576399255ae7fadd3ac6aee022fc8d56a8e10c1206b55eca207ab
-  data.tar.gz: 4042d268f199763405a264480765bbd5fe7aeaa998eb5e0a4353ae702c3bef2a
+  metadata.gz: c8eae41b5b093b55c02a81bbe81b08202eb4ecd64c1dd288246c0cd4af44c627
+  data.tar.gz: 208158a80e89e789d74c66f295ee4cbec6d37e6d9f3185dedfbcaa30a156fe35
 SHA512:
-  metadata.gz: 21a6a82509ead9c0d9f38c6798147dda38c436d87b8800a33ca7027553631866ce4215f2eb90c482f3c5a9b0bb42e99b7868fca888b78fcf7eca67afcd7db756
-  data.tar.gz: 71b53af0df630894c0d45639a84f427f34c7b92a5092e07cea16bc3786af666be13b0035a13c07b2910c374c76caa009c3acdbd675f430c8f6e4b7951c2b68a7
+  metadata.gz: dc1393417a3cdb013fdbcc085dcb3ba7dda45784e73a26ef44c1ee21b4322a9a18063d16c0cae7d3266be829ce31c6090773ba1631712211c388d84b21e0161d
+  data.tar.gz: 2f07cb2e882fbff31b73eee169a99849729b8f4136888335b2915a183ff32ed8aa78a66d93ea7765f0b09f0747b4b09cfae2aece5ca7478f41892b173a0ce2ab

data/CHANGELOG.md

@@ -1,3 +1,53 @@
+## [0.1.05] - 2021-03-05
+- Test for Fibbonacci recursive function is now passing.
+
+### Fixed
+- Method `BackEnd::Function#call` a call doesn't no more generate of TWO scopes
+
+## [0.1.04] - 2021-02-28
+
+### Added
+- Class `Ast::LoxReturnStmt` a node that represents a return statement
+- Method `Ast::ASTBuilder#reduce_return_stmt`
+- Method `Ast::ASTVisitor#visit_return_stmt` for visiting an `Ast::LoxReturnStmt` node
+- Method `BackEnd::Engine#after_return_stmt` to handle return statement
+- Method `BackEnd::Function#!` implementing the logical negation of a function (as value).
+- Test suite for logical operators (in project repository)
+- Test suite for block code
+- Test suite for call and function declaration (initial)
+
+### Changed
+- Method `BackEnd::Engine#after_call_expr` now generate a `catch` and `throw` events
+
+## [0.1.03] - 2021-02-26
+- Runtime argument checking for arithmetic and comparison operators
+
+### Added
+- Test suite for arithmetic and comparison operators (in project repository)
+- Class `BackEnd::UnaryOperator`:  runtime argument validation
+- Class `BackEnd::BinaryOperator`: runtime argument validation
+
+### Changed
+- File `console` renamed to `loxxy`. Very basic command-line interface.
+- Custom exception classes 
+- File `README.md` updated list of supported `Lox` keywords.
+
+
+## [0.1.02] - 2021-02-21
+- Function definition and call documented in `README.md`
+
+### Changed
+- File `README.md` updated description of function definition and function call.
+
+### Fixed
+- Method `BackEnd::Engine#after_print_stmt` now handles of empty stack or nil data.
+- Method `BackEnd::Engine#after_call_expr` was pushing one spurious item onto data stack.
+
+## [0.1.01] - 2021-02-20
+### Fixed
+- Fixed most offences for Rubocop.
+
+
 ## [0.1.00] - 2021-02-20
 - Version number bumped, `Loxxy` supports function definitions
 
@@ -192,11 +242,11 @@
 - The interpreter can evaluate substraction between two numbers.
 
 ### Added
-- Method `Datatype::Number#-` implmenting the subtraction operation
+- Method `Datatype::Number#-` implementing the subtraction operation
 
 ### Changed
 - File `README.md` minor editorial changes.
-- File `lx_string_spec.rb` Added test for string concatentation
+- File `lx_string_spec.rb` Added test for string concatenation
 - File `number_spec.rb` Added tests for addition and subtraction operations
 - File `interpreter_spec.rb` Added tests for subtraction operation
 

data/README.md

@@ -14,14 +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 all allowed __Lox__ expressions and statement except:
-- Functions and closures,  
+Currently it can execute all allowed __Lox__ expressions and statements except:
+- Closures,  
 - Classes and objects.
 
 These will be implemented soon.
 
 
-
 ## What's the fuss about Lox?
 ... Nothing...  
 Bob Nystrom designed a language __simple__ enough so that he could present 
@@ -36,11 +35,11 @@ Although __Lox__ is fairly simple, it is far from a toy language:
 - Functions and closures
 - Object-orientation (classes, methods, inheritance).
 
-In other words, __Lox__ contains interesting features expected from most general-purpose 
+In other words, __Lox__ contains interesting features found in most general-purpose 
 languages.
 
 ### What's missing in Lox?
-__Lox__ was constrained by design and therefore was not aimed to be a language used in real-world applications.
+__Lox__ was constrained by design and was therefore not aimed to be a language used in real-world applications.
 Here are some missing parts to make it a _practical_ language:
 - Collections (arrays, maps, ...)
 - Modules (importing stuff from other packages/files)
@@ -70,6 +69,23 @@ lox = Loxxy::Interpreter.new
 lox.evaluate(lox_program) # Output: Hello, world!
 ```
 
+## A function definition example
+```ruby
+require 'loxxy'
+
+lox_program = <<LOX_END
+  fun add4(n) {
+    n + 4;
+  }
+
+  print add4(6); // Output: 10
+LOX_END
+
+lox = Loxxy::Interpreter.new
+lox.evaluate(lox_program) # Output 10
+```
+
+
 ## Retrieving the result from a Lox program
 The __Loxxy__ interpreter returns the value of the last evaluated expression. 
 
@@ -151,6 +167,7 @@ Here are the language features currently supported by the interpreter:
 - [Print Statement](#print-statement)
 - [While Statement](#while-statement)  
 - [Block Statement](#block-statement)
+- [Function declaration](#func-statement)
 
 ### Comments
 
@@ -163,7 +180,8 @@ Loxxy supports single line C-style comments.
 ### Keywords
 Loxxy implements the following __Lox__ reserved keywords:
 ```lang-none
-and, false, nil, or, print, true
+and, else, false, for, fun, if,
+nil, or, print, true, var, while
 ```
 
 ### Datatypes
@@ -177,19 +195,21 @@ loxxy supports  all the standard __Lox__ datatypes:
 ### Statements
 
 Loxxy supports the following statements:  
-- [Expressions](#expressions)  
+- [Expressions](#expressions)
   -[Arithmetic expressions](#arithmetic-expressions)  
   -[String concatenation](#string-concatenation)  
   -[Comparison expressions](#comparison-expressions)  
   -[Logical expressions](#logical-expressions)  
   -[Grouping expressions](#grouping-expressions)  
-  -[Variable expressions and assignments](#variable-expressions)
-  
+  -[Variable expressions and assignments](#variable-expressions)  
+  -[Function call](#function-call)
+
 -[Variable declarations](#var-statement)  
 -[If Statement](#if-statement)  
 -[Print Statement](#print-statement)  
--[While Statement](#while-statement)
--[Block Statement](#block-statement)
+-[While Statement](#while-statement)  
+-[Block Statement](#block-statement)  
+-[Function Declaration](#function-declaration)
 
 #### Expressions
 
@@ -284,6 +304,15 @@ var iAmNil; // __Lox__ initializes variables to nil by default;
 print iAmNil; // output: nil
 ```
 
+#### Function call
+``` javascript
+// Calling a function without argument
+print clock();
+
+// Assumption: there exists a function `add` that takes two arguments
+print add(2, 3);
+```
+
 #### For statement
 
 Similar to the `for` statement in `C` language
@@ -362,6 +391,19 @@ var a = "outer";
 print a; // output: outer
 ```
 
+#### Function Declaration
+The keyword `fun` is used to begin a function declaration.
+In __Lox__ a function has a name and a body (which may be empty).
+
+``` javascript
+fun add4(n) // `add4` will be the name of the function
+{
+  n + 4;
+}
+
+print add4(6); // output: 10
+```
+
 ## Installation
 
 Add this line to your application's Gemfile:

data/bin/loxxy

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'loxxy'
+
+if ARGV[0]
+lox = Loxxy::Interpreter.new
+File.open(ARGV[0], 'r') do |f|
+lox.evaluate(f.read)
+end
+end

data/lib/loxxy.rb

@@ -6,8 +6,6 @@ require_relative 'loxxy/front_end/raw_parser'
 
 # Namespace for all classes and constants of __loxxy__ gem.
 module Loxxy
-  class Error < StandardError; end
-
   # Shorthand method. Returns the sole object that represents
   # a Lox false literal.
   # @return [Loxxy::Datatype::False]

data/lib/loxxy/ast/all_lox_nodes.rb

@@ -12,6 +12,7 @@ require_relative 'lox_logical_expr'
 require_relative 'lox_assign_expr'
 require_relative 'lox_block_stmt'
 require_relative 'lox_while_stmt'
+require_relative 'lox_return_stmt'
 require_relative 'lox_print_stmt'
 require_relative 'lox_if_stmt'
 require_relative 'lox_for_stmt'

data/lib/loxxy/ast/ast_builder.rb

@@ -221,6 +221,11 @@ module Loxxy
         Ast::LoxPrintStmt.new(tokens[1].position, theChildren[1])
       end
 
+      # rule('returnStmt' => 'RETURN expression_opt SEMICOLON')
+      def reduce_return_stmt(_production, _range, tokens, theChildren)
+        Ast::LoxReturnStmt.new(tokens[1].position, theChildren[1])
+      end
+
       # rule('whileStmt' => 'WHILE LEFT_PAREN expression RIGHT_PAREN statement').as ''
       def reduce_while_stmt(_production, _range, tokens, theChildren)
         Ast::LoxWhileStmt.new(tokens[1].position, theChildren[2], theChildren[4])
@@ -233,7 +238,7 @@ module Loxxy
       end
 
       # rule('block' => 'LEFT_BRACE RIGHT_BRACE').as 'block_empty'
-      def reduce_block_empty(_production, _range, tokens, theChildren)
+      def reduce_block_empty(_production, _range, tokens, _children)
         Ast::LoxBlockStmt.new(tokens[0].position, nil)
       end
 
@@ -298,7 +303,7 @@ module Loxxy
       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])
+        LoxFunStmt.new(pos, first_child.token.lexeme, theChildren[2], theChildren[4])
       end
 
       # rule('parameters' => 'parameters COMMA IDENTIFIER')

data/lib/loxxy/ast/ast_visitor.rb

@@ -91,6 +91,14 @@ module Loxxy
         broadcast(:after_print_stmt, aPrintStmt)
       end
 
+      # Visit event. The visitor is about to visit a return statement.
+      # @param aReturnStmt [AST::LOXReturnStmt] the return statement node to visit
+      def visit_return_stmt(aReturnStmt)
+        broadcast(:before_return_stmt, aReturnStmt)
+        traverse_subnodes(aReturnStmt)
+        broadcast(:after_return_stmt, aReturnStmt, self)
+      end
+
       # Visit event. The visitor is about to visit a while statement node.
       # @param aWhileStmt [AST::LOXWhileStmt] the while statement node to visit
       def visit_while_stmt(aWhileStmt)

data/lib/loxxy/ast/lox_fun_stmt.rb

@@ -4,6 +4,7 @@ require_relative 'lox_compound_expr'
 
 module Loxxy
   module Ast
+    # rubocop: disable Style/AccessorGrouping
     class LoxFunStmt < LoxCompoundExpr
       attr_reader :name
       attr_reader :params
@@ -28,5 +29,6 @@ module Loxxy
 
       alias operands subnodes
     end # class
+    # rubocop: enable Style/AccessorGrouping
   end # module
 end # module

data/lib/loxxy/ast/lox_return_stmt.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'lox_compound_expr'
+
+module Loxxy
+  module Ast
+    class LoxReturnStmt < LoxCompoundExpr
+      # @param aPosition [Rley::Lexical::Position] Position of the entry in the input stream.
+      # @param anExpression [Ast::LoxNode] expression to return
+      def initialize(aPosition, anExpression)
+        super(aPosition, [anExpression])
+      end
+
+      # Part of the 'visitee' role in Visitor design pattern.
+      # @param visitor [Ast::ASTVisitor] the visitor
+      def accept(visitor)
+        visitor.visit_return_stmt(self)
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/back_end/binary_operator.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative '../error'
+
+module Loxxy
+  module BackEnd
+    Signature = Struct.new(:parameter_types)
+
+    # A Lox binary operator
+    class BinaryOperator
+      # @return [String] text representation of the operator
+      attr_reader :name
+
+      # @return [Array<Class>]
+      attr_reader :signatures
+
+      # @param aName [String] "name" of operator
+      # @param theSignatures [Array<Signature>] allowed signatures
+      def initialize(aName, theSignatures)
+        @name = aName
+        @signatures = theSignatures
+      end
+
+      # rubocop: disable Style/ClassEqualityComparison
+      def validate_operands(operand1, operand2)
+        compliant = signatures.find do |(type1, type2)|
+          next unless operand1.kind_of?(type1)
+
+          if type2 == :idem
+            (operand2.class == operand1.class)
+          else
+            operand2.kind_of?(type2)
+          end
+        end
+        # rubocop: enable Style/ClassEqualityComparison
+
+        unless compliant
+          err = Loxxy::RuntimeError
+          if signatures.size == 1 && signatures[0].last == :idem
+            raise err, "Operands must be #{datatype_name(signatures[0].first)}s."
+          elsif signatures.size == 2 && signatures.all? { |(_, second)| second == :idem }
+            type1 = datatype_name(signatures[0].first)
+            type2 = datatype_name(signatures[1].first)
+            raise err, "Operands must be two #{type1}s or two #{type2}s."
+          end
+        end
+      end
+
+      private
+
+      def datatype_name(aClass)
+        # (?:(?:[^:](?!:|(?<=LX))))+$
+        aClass.name.sub(/^.+(?=::)::(?:LX)?/, '').downcase
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/back_end/engine.rb

@@ -2,8 +2,10 @@
 
 # Load all the classes implementing AST nodes
 require_relative '../ast/all_lox_nodes'
+require_relative 'binary_operator'
 require_relative 'function'
 require_relative 'symbol_table'
+require_relative 'unary_operator'
 
 module Loxxy
   module BackEnd
@@ -17,16 +19,26 @@ module Loxxy
       # @return [BackEnd::SymbolTable]
       attr_reader :symbol_table
 
-      # @return [Array<Datatype::BuiltinDatatyp>] Stack for the values of expr
+      # @return [Array<Datatype::BuiltinDatatype>] Data stack for the expression results
       attr_reader :stack
 
+     # @return [Hash { Symbol => UnaryOperator}]
+      attr_reader :unary_operators
+
+      # @return [Hash { Symbol => BinaryOperator}]
+      attr_reader :binary_operators
+
       # @param theOptions [Hash]
       def initialize(theOptions)
         @config = theOptions
         @ostream = config.include?(:ostream) ? config[:ostream] : $stdout
         @symbol_table = SymbolTable.new
         @stack = []
+        @unary_operators = {}
+        @binary_operators = {}
 
+        init_unary_operators
+        init_binary_operators
         init_globals
       end
 
@@ -83,7 +95,11 @@ module Loxxy
 
       def after_print_stmt(_printStmt)
         tos = stack.pop
-        @ostream.print tos.to_str
+        @ostream.print tos ? tos.to_str : 'nil'
+      end
+
+      def after_return_stmt(_returnStmt, _aVisitor)
+        throw(:return)
       end
 
       def after_while_stmt(aWhileStmt, aVisitor)
@@ -148,9 +164,11 @@ module Loxxy
       end
 
       def after_binary_expr(aBinaryExpr)
-        op = aBinaryExpr.operator
         operand2 = stack.pop
         operand1 = stack.pop
+        op = aBinaryExpr.operator
+        operator = binary_operators[op]
+        operator.validate_operands(operand1, operand2)
         if operand1.respond_to?(op)
           stack.push operand1.send(op, operand2)
         else
@@ -160,12 +178,14 @@ module Loxxy
       end
 
       def after_unary_expr(anUnaryExpr)
-        op = anUnaryExpr.operator
         operand = stack.pop
+        op = anUnaryExpr.operator
+        operator = unary_operators[op]
+        operator.validate_operand(operand)
         if operand.respond_to?(op)
           stack.push operand.send(op)
         else
-          msg1 = "`#{op}': Unimplemented operator for a #{operand1.class}."
+          msg1 = "`#{op}': Unimplemented operator for a #{operand.class}."
           raise StandardError, msg1
         end
       end
@@ -176,21 +196,21 @@ module Loxxy
         callee = stack.pop
         aCallExpr.arguments.reverse_each { |arg| arg.accept(aVisitor) }
 
-        if callee.kind_of?(NativeFunction)
+        case callee
+        when NativeFunction
           stack.push callee.call # Pass arguments
+        when Function
+          callee.call(self, aVisitor)
         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
+          raise Loxxy::RuntimeError, 'Can only call functions and classes.'
         end
       end
 
+      def complete_call
+        callee = ret_stack.pop
+        symbol_table.leave_environment if callee.kind_of?(Function)
+      end
+
       def after_grouping_expr(_groupingExpr)
         # Do nothing: work was already done by visiting /evaluating the subexpression
       end
@@ -213,7 +233,7 @@ module Loxxy
         stack.push(aValue)
       end
 
-      def after_fun_stmt(aFunStmt, aVisitor)
+      def after_fun_stmt(aFunStmt, _visitor)
         function = Function.new(aFunStmt.name, aFunStmt.params, aFunStmt.body, stack)
         new_var = Variable.new(aFunStmt.name, function)
         symbol_table.insert(new_var)
@@ -235,6 +255,48 @@ module Loxxy
         end
       end
 
+      def init_unary_operators
+        negate_op = UnaryOperator.new('-', [Datatype::Number])
+        unary_operators[:-@] = negate_op
+
+        negation_op = UnaryOperator.new('!', [Datatype::BuiltinDatatype,
+          BackEnd::Function])
+        unary_operators[:!] = negation_op
+      end
+
+      def init_binary_operators
+        plus_op = BinaryOperator.new('+', [[Datatype::Number, :idem],
+          [Datatype::LXString, :idem]])
+        binary_operators[:+] = plus_op
+
+        minus_op = BinaryOperator.new('-', [[Datatype::Number, :idem]])
+        binary_operators[:-] = minus_op
+
+        star_op = BinaryOperator.new('*', [[Datatype::Number, :idem]])
+        binary_operators[:*] = star_op
+
+        slash_op = BinaryOperator.new('/', [[Datatype::Number, :idem]])
+        binary_operators[:/] = slash_op
+
+        equal_equal_op = BinaryOperator.new('==', [[Datatype::BuiltinDatatype, Datatype::BuiltinDatatype]])
+        binary_operators[:==] = equal_equal_op
+
+        not_equal_op = BinaryOperator.new('!=', [[Datatype::BuiltinDatatype, Datatype::BuiltinDatatype]])
+        binary_operators[:!=] = not_equal_op
+
+        less_op = BinaryOperator.new('<', [[Datatype::Number, :idem]])
+        binary_operators[:<] = less_op
+
+        less_equal_op = BinaryOperator.new('<=', [[Datatype::Number, :idem]])
+        binary_operators[:<=] = less_equal_op
+
+        greater_op = BinaryOperator.new('>', [[Datatype::Number, :idem]])
+        binary_operators[:>] = greater_op
+
+        greater_equal_op = BinaryOperator.new('>=', [[Datatype::Number, :idem]])
+        binary_operators[:>=] = greater_equal_op
+      end
+
       def init_globals
         add_native_fun('clock', native_clock)
       end

data/lib/loxxy/back_end/function.rb

@@ -4,18 +4,16 @@ require_relative '../datatype/all_datatypes'
 
 module Loxxy
   module BackEnd
+    # rubocop: disable Style/AccessorGrouping
     # 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
@@ -24,7 +22,7 @@ module Loxxy
       def initialize(aName, parameterList, aBody, aStack)
         @name = aName.dup
         @parameters = parameterList
-        @body = aBody
+        @body = aBody.kind_of?(Ast::LoxNoopExpr) ? aBody : aBody.subnodes[0]
         @stack = aStack
       end
 
@@ -32,8 +30,28 @@ module Loxxy
         stack.push self
       end
 
-      def call(aVisitor)
-        body.empty? ? Datatype::Nil.instance : body.accept(aVisitor)
+      def call(engine, aVisitor)
+        new_env = Environment.new(engine.symbol_table.current_env)
+        engine.symbol_table.enter_environment(new_env)
+
+        parameters&.each do |param_name|
+          local = Variable.new(param_name, 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)
+        end
+
+        engine.symbol_table.leave_environment
+      end
+
+      # Logical negation.
+      # As a function is a truthy thing, its negation is thus false.
+      # @return [Datatype::False]
+      def !
+        Datatype::False.instance
       end
 
       # Text representation of a Lox function
@@ -41,5 +59,6 @@ module Loxxy
         "<fn #{name}>"
       end
     end # class
+    # rubocop: enable Style/AccessorGrouping
   end # module
 end # module

data/lib/loxxy/back_end/unary_operator.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative '../error'
+
+module Loxxy
+  module BackEnd
+    # A Lox unary operator
+    class UnaryOperator
+      # @return [String] text representation of the operator
+      attr_reader :name
+
+      # @return [Array<Class>]
+      attr_reader :signatures
+
+      # @param aName [String] "name" of operator
+      # @param theSignatures [Array<Class>] allowed signatures
+      def initialize(aName, theSignatures)
+        @name = aName
+        @signatures = theSignatures
+      end
+
+      def validate_operand(operand1)
+        compliant = signatures.find { |some_type| operand1.kind_of?(some_type) }
+
+        unless compliant
+          err = Loxxy::RuntimeError
+          # if signatures.size == 1
+          raise err, "Operand must be a #{datatype_name(signatures[0])}."
+          # end
+        end
+      end
+
+      private
+
+      def datatype_name(aClass)
+        # (?:(?:[^:](?!:|(?<=LX))))+$
+        aClass.name.sub(/^.+(?=::)::(?:LX)?/, '').downcase
+      end
+    end # class
+  end # module
+end # module

data/lib/loxxy/error.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Loxxy
+  # Abstract class. Generalization of Loxxy error classes.
+  class Error < StandardError; end
+
+  # Error occurring while Loxxy executes some invalid Lox code.
+  class RuntimeError < Error; end
+end

data/lib/loxxy/front_end/grammar.rb

@@ -74,7 +74,7 @@ module Loxxy
       rule('elsePart_opt' => [])
 
       rule('printStmt' => 'PRINT expression SEMICOLON').as 'print_stmt'
-      rule('returnStmt' => 'RETURN expression_opt SEMICOLON')
+      rule('returnStmt' => 'RETURN expression_opt SEMICOLON').as 'return_stmt'
       rule('whileStmt' => 'WHILE LEFT_PAREN expression RIGHT_PAREN statement').as 'while_stmt'
       rule('block' => 'LEFT_BRACE declaration_plus RIGHT_BRACE').as 'block_stmt'
       rule('block' => 'LEFT_BRACE RIGHT_BRACE').as 'block_empty'

data/lib/loxxy/front_end/scanner.rb

@@ -92,6 +92,7 @@ module Loxxy
 
       private
 
+      # rubocop: disable Lint/DuplicateBranch
       def _next_token
         skip_intertoken_spaces
         curr_ch = scanner.peek(1)
@@ -125,6 +126,7 @@ 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.1.0'
+  VERSION = '0.1.05'
 end

data/loxxy.gemspec

@@ -46,8 +46,8 @@ Gem::Specification.new do |spec|
   spec.license       = 'MIT'
   spec.required_ruby_version = '~> 2.4'
 
-  spec.bindir        = 'exe'
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.bindir        = 'bin'
+  spec.executables   = ['loxxy']
   spec.require_paths = ['lib']
 
   PkgExtending.pkg_files(spec)

data/spec/interpreter_spec.rb

@@ -9,6 +9,7 @@ require_relative '../lib/loxxy/interpreter'
 module Loxxy
   # This spec contains the bare bones test for the Interpreter class.
   # The execution of Lox code is tested elsewhere.
+  # rubocop: disable Metrics/BlockLength
   describe Interpreter do
     let(:sample_cfg) do
       { ostream: StringIO.new }
@@ -423,10 +424,34 @@ LOX_END
         expect(sample_cfg[:ostream].string).to eq('<fn foo><native fn>')
       end
 
+      it 'should support return statements' do
+        program = <<-LOX_END
+          fun max(a, b) {
+            if (a > b) return a;
+
+            return b;
+          }
+
+          max(3, 2);
+        LOX_END
+        result = subject.evaluate(program)
+        expect(result).to eq(3)
+      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!')
       end
     end # context
+
+    context 'Test suite:' do
+      it "should complain if one argument isn't a number" do
+        source = '1 + nil;'
+        err = Loxxy::RuntimeError
+        err_msg = 'Operands must be two numbers or two strings.'
+        expect { subject.evaluate(source) }.to raise_error(err, err_msg)
+      end
+    end # context
   end # describe
+  # rubocop: enable Metrics/BlockLength
 end # module

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: loxxy
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.05
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2021-02-20 00:00:00.000000000 Z
+date: 2021-03-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -69,7 +69,8 @@ dependencies:
 description: An implementation of the Lox programming language. WIP
 email:
 - famished.tiger@yahoo.com
-executables: []
+executables:
+- loxxy
 extensions: []
 extra_rdoc_files:
 - README.md
@@ -83,6 +84,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- bin/loxxy
 - lib/loxxy.rb
 - lib/loxxy/ast/all_lox_nodes.rb
 - lib/loxxy/ast/ast_builder.rb
@@ -101,16 +103,19 @@ files:
 - lib/loxxy/ast/lox_node.rb
 - lib/loxxy/ast/lox_noop_expr.rb
 - lib/loxxy/ast/lox_print_stmt.rb
+- lib/loxxy/ast/lox_return_stmt.rb
 - lib/loxxy/ast/lox_seq_decl.rb
 - lib/loxxy/ast/lox_unary_expr.rb
 - lib/loxxy/ast/lox_var_stmt.rb
 - lib/loxxy/ast/lox_variable_expr.rb
 - lib/loxxy/ast/lox_while_stmt.rb
+- lib/loxxy/back_end/binary_operator.rb
 - 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/unary_operator.rb
 - lib/loxxy/back_end/variable.rb
 - lib/loxxy/datatype/all_datatypes.rb
 - lib/loxxy/datatype/boolean.rb
@@ -120,6 +125,7 @@ files:
 - lib/loxxy/datatype/nil.rb
 - lib/loxxy/datatype/number.rb
 - lib/loxxy/datatype/true.rb
+- lib/loxxy/error.rb
 - lib/loxxy/front_end/grammar.rb
 - lib/loxxy/front_end/literal.rb
 - lib/loxxy/front_end/parser.rb