loxxy 0.1.02 → 0.1.03

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ddfc01e822c7e68c87d515649f6ef6e2c800c926ca289dfe9f65edeff24e7015
-  data.tar.gz: db5a6a8052c0c15f00920c6d76fcd8c6f9cfe380905c20b53f8e74cc7c6d4f84
+  metadata.gz: 2bf956c6e2d6736535acd1e9b0cb29df6b55a8d9002be073cb70bbf753fb06c9
+  data.tar.gz: 1f635dc69e588f01406cd988bf98d12b9ea398f36e249113a37b089788ef21cb
 SHA512:
-  metadata.gz: f5a85f8a0a4a762f43a9dd51ab972f924a95ed15ed9e864cef0c60f4815902cbfb905fef624cc100bae9283985f8f6c7f960fbd72bd8d87e9ee3ab211eb7dc24
-  data.tar.gz: 10522ab655b99e31007dccaa479b4ec59a9340160f6768c084c3b96825f4e89f9f1c46c1655117763d66f28004f5d8e2c193315c80a65dd49b733587bd25823a
+  metadata.gz: dce93451a9efc548df45683f5772a5d5509c25a57969465f3ff9f48f8b5adcc642b7bb92b25d43658869b5b62d3108796964226c35130cb1492335dc6eaf8fe1
+  data.tar.gz: 881dfd881db0d2ec3e56b91ad14bc6dd0e0b91ba3839fa1efe09c3636aac575856e3e8c4d4a64a55e913a757a4f1d275cc843734ceda3a23ef597591cb282f3f

data/CHANGELOG.md

@@ -1,8 +1,22 @@
+## [0.1.03] - 2021-02-26
+- Runtime argument chacking 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 todescribe function definition and function call.
+- 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.

data/README.md

@@ -180,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

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/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
@@ -20,13 +22,23 @@ module Loxxy
       # @return [Array<Datatype::BuiltinDatatyp>] Stack for the values of expr
       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
 
@@ -148,9 +160,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 +174,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
@@ -235,6 +251,47 @@ module Loxxy
         end
       end
 
+      def init_unary_operators
+        negate_op = UnaryOperator.new('-', [Datatype::Number])
+        unary_operators[:-@] = negate_op
+
+        negation_op = UnaryOperator.new('!', [Datatype::BuiltinDatatype])
+        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/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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Loxxy
-  VERSION = '0.1.02'
+  VERSION = '0.1.03'
 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

@@ -429,6 +429,15 @@ LOX_END
         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.02
+  version: 0.1.03
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire:
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2021-02-21 00:00:00.000000000 Z
+date: 2021-02-26 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
@@ -106,11 +108,13 @@ files:
 - 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 +124,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