loxxy 0.2.05 → 0.2.06

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ce7eeb0247e67176d1dc4c67066eff4398ffaa8b75755b289eb3e53932d3006b
-  data.tar.gz: 84f7c781c10b0f6f07cfb5bab98d2ab9d78340cf5b20426822226cbe5c266a94
+  metadata.gz: cbb2f24e245891baabf20458e5b663784ba7f82ff902ab7892007d9b53d99347
+  data.tar.gz: eab4ede6f48470449f731e3074b2ac2fe72b53449c9471231ea64d0007a873ae
 SHA512:
-  metadata.gz: ad3cce2c2f3bcf8c0c3ae30b1dc050764c654e276a2d482934c2efd7ad6120b0db7e415003bd8d2f887ed118f723eee7c882f231ceadea773236d1d01e478db9
-  data.tar.gz: d5e25c250ac629d76e01468fbb59a2fcb287b2a112fda9f2432e83df48a889581ecbe38723ab7371ba6ae3cdd94367051249907994caa78bfa852e7b328a0811
+  metadata.gz: 8037d3c239e39d47554c4e7f7698e5908cdaa5e460c8972fe8dc5b58ee5fd59647c413db95250ff739c08f9ca891c8f576eb8d78aa63cf40039e8d1b3328e9a2
+  data.tar.gz: 795face50a76140ba2f6be2e6e6c44e671992baaea2ecade980acf1baed173dc59cbe7cd2ce419b509e8593068ffc3e637e0678dab2db72a96250d4e53ef0338

data/CHANGELOG.md

@@ -1,3 +1,19 @@
+## [0.2.06] - 2021-05-04
+- Nearly passing the 'official' test suite, fixing non-compliant behavior, specialized exceptions for errors
+
+### New
+- Module `LoxFileTester` module that hosts methods that simplify the tests of `Lox` source file. 
+
+### Changed
+- Folder `test_suite` vastly reorganized. Sub-folder `baseline` contains spec files testing the `Lox` files from official implementation
+- Class `BackEnd::Engine` replaced most `StandardError` by `Loxxy::RuntimeError` exception.
+- Class `BackEnd::Resolver` replaced most `StandardError` by `Loxxy::RuntimeError` exception.
+- Method `Datatype::Number#/` now handles correctly expression like `0/0` (integer divide)
+
+### Fixed
+- `0/0` expression results in a ZeroDivisionError exception, in Lox this result to a NaN (Not a Number). Now, `Loxxy` is aligned to standard `Lox`
+- `FrontEnd::Scanner` now always treats expression like `-123` as the unary or binary minus operator applied to a positive number. 
+
 ## [0.2.05] - 2021-04-26
 - `Loxxy` now transforms for loops into while loops (desugaring), fix in Scanner class
 

data/lib/loxxy/back_end/engine.rb

@@ -218,7 +218,8 @@ module Loxxy
         operator = binary_operators[op]
         operator.validate_operands(operand1, operand2)
         if operand1.respond_to?(op)
-          stack.push operand1.send(op, operand2)
+          result = operand1.send(op, operand2)
+          stack.push convert2lox_datatype(result)
         else
           msg1 = "`#{op}': Unimplemented operator for a #{operand1.class}."
           raise StandardError, msg1
@@ -231,7 +232,8 @@ module Loxxy
         operator = unary_operators[op]
         operator.validate_operand(operand)
         if operand.respond_to?(op)
-          stack.push operand.send(op)
+          result = operand.send(op)
+          stack.push convert2lox_datatype(result)
         else
           msg1 = "`#{op}': Unimplemented operator for a #{operand.class}."
           raise StandardError, msg1
@@ -299,7 +301,7 @@ module Loxxy
         superklass = variable_lookup(aSuperExpr).value.superclass
         method = superklass.find_method(aSuperExpr.property)
         unless method
-          raise StandardError, "Undefined property '#{aSuperExpr.property}'."
+          raise Loxxy::RuntimeError, "Undefined property '#{aSuperExpr.property}'."
         end
 
         stack.push method.bind(instance)
@@ -354,7 +356,7 @@ module Loxxy
         unary_operators[:-@] = negate_op
 
         negation_op = UnaryOperator.new('!', [Datatype::BuiltinDatatype,
-          BackEnd::LoxFunction])
+          BackEnd::LoxInstance, BackEnd::LoxFunction, BackEnd::LoxClass])
         unary_operators[:!] = negation_op
       end
 
@@ -408,6 +410,15 @@ module Loxxy
           Datatype::Number.new(now)
         end
       end
+
+      def convert2lox_datatype(item)
+        case item
+        when TrueClass then Datatype::True.instance
+        when FalseClass then Datatype::False.instance
+        else
+          item
+        end
+      end
     end # class
   end # module
 end # module

data/lib/loxxy/back_end/resolver.rb

@@ -69,7 +69,7 @@ module Loxxy
         define(aClassStmt.name)
         if aClassStmt.superclass
           if aClassStmt.name == aClassStmt.superclass.name
-            raise StandardError, "'A class can't inherit from itself."
+            raise Loxxy::RuntimeError, "'A class can't inherit from itself."
           end
 
           @current_class = :subclass
@@ -96,17 +96,17 @@ module Loxxy
       def before_return_stmt(returnStmt)
         if scopes.size < 2
           msg = "Error at 'return': Can't return from top-level code."
-          raise StandardError, msg
+          raise Loxxy::RuntimeError, msg
         end
 
         if current_function == :none
           msg = "Error at 'return': Can't return from outside a function."
-          raise StandardError, msg
+          raise Loxxy::RuntimeError, msg
         end
 
         if current_function == :initializer
           msg = "Error at 'return': Can't return a value from an initializer."
-          raise StandardError, msg unless returnStmt.subnodes[0].kind_of?(Datatype::Nil)
+          raise Loxxy::RuntimeError, msg unless returnStmt.subnodes[0].kind_of?(Datatype::Nil)
         end
       end
 
@@ -160,7 +160,7 @@ module Loxxy
       def before_this_expr(_thisExpr)
         if current_class == :none
           msg = "Error at 'this': Can't use 'this' outside of a class."
-          raise StandardError, msg
+          raise Loxxy::RuntimeError, msg
         end
       end
 
@@ -175,11 +175,11 @@ module Loxxy
         msg_prefix = "Error at 'super': Can't use 'super' "
         if current_class == :none
           err_msg = msg_prefix + 'outside of a class.'
-          raise StandardError, err_msg
+          raise Loxxy::RuntimeError, err_msg
 
         elsif current_class == :class
           err_msg = msg_prefix + 'in a class without superclass.'
-          raise StandardError, err_msg
+          raise Loxxy::RuntimeError, err_msg
 
         end
         # 'super' behaves closely to a local variable
@@ -205,14 +205,19 @@ module Loxxy
         scopes.pop
       end
 
+      # rubocop: disable Style/SoleNestedConditional
       def declare(aVarName)
         return if scopes.empty?
 
         curr_scope = scopes.last
-        if curr_scope.include?(aVarName)
-          msg = "Error at '#{aVarName}': Already variable with this name in this scope."
-          raise StandardError, msg
+        if scopes.size > 1 # Not at top-level?
+          # Oddly enough, Lox allows variable re-declaration at top-level
+          if curr_scope.include?(aVarName)
+            msg = "Error at '#{aVarName}': Already variable with this name in this scope."
+            raise Loxxy::RuntimeError, msg
+          end
         end
+        # rubocop: enable Style/SoleNestedConditional
 
         # The initializer is not yet processed.
         # Mark the variable as 'not yet ready' = exists but may not be referenced yet

data/lib/loxxy/datatype/number.rb

@@ -7,6 +7,10 @@ module Loxxy
   module Datatype
     # Class for representing a Lox numeric value.
     class Number < BuiltinDatatype
+      def zero?
+        value.zero?
+      end
+
       # Perform the addition of two Lox numbers or
       # one Lox number and a Ruby Numeric
       # @param other [Loxxy::Datatype::Number, Numeric]
@@ -59,17 +63,28 @@ module Loxxy
       # one Lox number and a Ruby Numeric
       # @param other [Loxxy::Datatype::Number, Numeric]
       # @return [Loxxy::Datatype::Number]
+      # rubocop: disable Lint/BinaryOperatorWithIdenticalOperands
       def /(other)
         case other
-        when Number
-          self.class.new(value / other.value)
-        when Numeric
-          self.class.new(value / other)
+        when Number, Numeric
+          if other.zero?
+            if zero?
+              # NaN case detected
+              self.class.new(0.0 / 0.0)
+            else
+              raise ZeroDivisionError
+            end
+          elsif other.kind_of?(Number)
+            self.class.new(value / other.value)
+          else
+            self.class.new(value / other)
+          end
         else
           err_msg = "'/': Operands must be numbers."
           raise TypeError, err_msg
         end
       end
+      # rubocop: enable Lint/BinaryOperatorWithIdenticalOperands
 
       # Unary minus (return value with changed sign)
       # @return [Loxxy::Datatype::Number]

data/lib/loxxy/front_end/scanner.rb

@@ -84,7 +84,7 @@ module Loxxy
           token = _next_token
           tok_sequence << token unless token.nil?
         end
-        tok_sequence << build_token('EOF', '')
+        tok_sequence << build_token('EOF', nil)
 
         return tok_sequence
       end
@@ -99,16 +99,16 @@ module Loxxy
 
         token = nil
 
-        if '(){},.;/*'.include? curr_ch
+        if '(){},.;-/*'.include? curr_ch
           # Single delimiter or separator character
           token = build_token(@@lexeme2name[curr_ch], scanner.getch)
-        elsif (lexeme = scanner.scan(/[+\-](?!\d)/))
+        elsif (lexeme = scanner.scan(/\+(?!\d)/))
           # Minus or plus character not preceding a digit
           token = build_token(@@lexeme2name[lexeme], lexeme)
         elsif (lexeme = scanner.scan(/[!=><]=?/))
           # One or two special character tokens
           token = build_token(@@lexeme2name[lexeme], lexeme)
-        elsif (lexeme = scanner.scan(/-?\d+(?:\.\d+)?/))
+        elsif (lexeme = scanner.scan(/\d+(?:\.\d+)?/))
           token = build_token('NUMBER', lexeme)
         elsif (lexeme = scanner.scan(/"(?:\\"|[^"])*"/))
           token = build_token('STRING', lexeme)
@@ -133,7 +133,8 @@ module Loxxy
       def build_token(aSymbolName, aLexeme)
         begin
           (value, symb) = convert_to(aLexeme, aSymbolName)
-          col = scanner.pos - aLexeme.size - @line_start + 1
+          lex_length = aLexeme ? aLexeme.size : 0
+          col = scanner.pos - lex_length - @line_start + 1
           pos = Rley::Lexical::Position.new(@lineno, col)
           if value
             token = Literal.new(value, aLexeme.dup, symb, pos)

data/lib/loxxy/version.rb

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

data/spec/front_end/scanner_spec.rb

@@ -124,18 +124,15 @@ LOX_END
 
         it 'should recognize number values' do
           input = <<-LOX_END
-          123     987654
-          0       -0
-          123.456 -0.001
-LOX_END
+            123     987654
+            0       123.456
+          LOX_END
 
           expectations = [
             ['123', 123],
             ['987654', 987654],
             ['0', 0],
-            ['-0', 0],
-            ['123.456', 123.456],
-            ['-0.001', -0.001]
+            ['123.456', 123.456]
           ]
 
           subject.start_with(input)
@@ -149,6 +146,30 @@ LOX_END
           end
         end
 
+        it 'should recognize negative number values' do
+          input = <<-LOX_END
+            -0
+            -0.001
+          LOX_END
+
+          expectations = [
+            ['-', '0'],
+            ['-', '0.001']
+          ].flatten
+
+          subject.start_with(input)
+          tokens = subject.tokens
+          tokens.pop
+          i = 0
+          tokens.each_slice(2) do |(sign, lit)|
+            expect(sign.terminal).to eq('MINUS')
+            expect(sign.lexeme).to eq(expectations[i])
+            expect(lit.terminal).to eq('NUMBER')
+            expect(lit.lexeme).to eq(expectations[i + 1])
+            i += 2
+          end
+        end
+
         it 'should recognize leading and trailing dots as distinct tokens' do
           input = '.456 123.'
 

data/spec/interpreter_spec.rb

@@ -148,6 +148,19 @@ module Loxxy
         end
       end
 
+      it 'should ignore spaces surrounding minus in subtraction of two numbers' do
+        [
+          ['1 - 1;', 0],
+          ['1 -1;', 0],
+          ['1- 1;', 0],
+          ['1-1;', 0]
+        ].each do |(source, predicted)|
+          lox = Loxxy::Interpreter.new
+          result = lox.evaluate(source)
+          expect(result.value == predicted).to be_truthy
+        end
+      end
+
       it 'should evaluate the negation of an object' do
         [
           ['!true;', false],

metadata

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