peruby 0.1.0

data/lib/peruby/op/call.rb

@@ -0,0 +1,378 @@
+# frozen_string_literal: true
+
+module Peruby
+  module Op
+    # Runtime subroutine definition.
+    class SubDef < Base
+      def initialize(name, prototype, body)
+        @name = name
+        @prototype = prototype
+        @body = body
+      end
+
+      def run(env, _context)
+        install(env, @body)
+      end
+
+      def to_callable
+        body = Compiled.new(@body.to_callable, @body.to_subroutine_callable)
+        ->(env, _context) { install(env, body) }
+      end
+
+      private
+
+      def install(env, body)
+        package = @name.include?('::') ? @name.rpartition('::').first : env.package
+        env.runtime.warning('redefine', "Subroutine #{@name} redefined") if env.runtime.stash.fetch(@name)&.code
+        code = Code.new(@name, body, env.capture, package, @prototype)
+        env.runtime.stash.glob(@name).code = code
+        env.runtime.stash.touch
+        code
+      end
+    end
+
+    # Constant subroutine installed by use constant.
+    class ConstantDef < Base
+      def initialize(name, value)
+        @name = name
+        @value = value
+      end
+
+      def run(env, _context)
+        package = @name.include?('::') ? @name.rpartition('::').first : env.package
+        env.runtime.stash.glob(@name).code = Code.new(@name, @value, env.capture, package, '')
+        env.runtime.stash.touch
+      end
+    end
+
+    # Anonymous closure creation.
+    class AnonSub < Base
+      def initialize(prototype, body)
+        @prototype = prototype
+        @body = body
+      end
+
+      def run(env, context)
+        reference(env, context, @body)
+      end
+
+      def to_callable
+        body = Compiled.new(@body.to_callable, @body.to_subroutine_callable)
+        ->(env, context) { reference(env, context, body) }
+      end
+
+      private
+
+      def reference(env, context, body)
+        code = Code.new(nil, body, env.capture, env.package, @prototype)
+        value = Ref.new(code)
+        context == :list ? [Scalar.new(value)] : value
+      end
+    end
+
+    # User subroutine invocation.
+    class Call < Base
+      def initialize(name, arguments)
+        @name = name
+        @arguments = arguments
+      end
+
+      def run(env, context)
+        code = resolve(env)
+        env.runtime.call(code, @arguments.argument_cells(env, code.prototype), context)
+      end
+
+      def to_callable
+        arguments = @arguments.argument_callable
+        lambda do |env, context|
+          code = resolve(env)
+          env.runtime.call(code, arguments.call(env, code.prototype), context)
+        end
+      end
+
+      def scalar_callable
+        arguments = @arguments.argument_callable
+        lambda do |env|
+          code = resolve(env)
+          env.runtime.call(code, arguments.call(env, code.prototype), :scalar)
+        end
+      end
+
+      private
+
+      def resolve(env)
+        stash = env.runtime.stash
+        unless @cached_generation == stash.generation
+          @cached_code = stash.glob(@name).code
+          @cached_generation = stash.generation
+        end
+        raise PerlError, "Undefined subroutine &#{@name} called" unless @cached_code
+
+        @cached_code
+      end
+    end
+
+    # Invocation through a code reference.
+    class CodeCall < Base
+      def initialize(receiver, arguments, inherit: false)
+        @receiver = receiver
+        @arguments = arguments
+        @inherit = inherit
+      end
+
+      def run(env, context)
+        code = @receiver.run(env, :scalar)
+        code = code.target if code.is_a?(Ref) && code.kind == 'CODE'
+        raise PerlError, 'Not a CODE reference' unless code.is_a?(Code)
+
+        arguments = @inherit ? env.fetch(:array, '_').cells.dup : @arguments.argument_cells(env)
+        env.runtime.call(code, arguments, context)
+      end
+    end
+
+    # Non-local subroutine return.
+    class Return < Base
+      def initialize(expression)
+        @expression = expression
+      end
+
+      def run(env, _context)
+        throw :peruby_return, @expression&.run(env, env.want)
+      end
+
+      def return_value(env, context)
+        @expression&.run(env, context)
+      end
+
+      def return_callable
+        expression = @expression&.to_callable
+        ->(env, context) { expression&.call(env, context) }
+      end
+    end
+
+    # Perl ref() result.
+    class RefKind < Base
+      def initialize(expression)
+        @expression = expression
+      end
+
+      def run(env, context)
+        value = @expression.run(env, :scalar)
+        result = value.is_a?(Ref) ? value.ref_string : ''
+        context == :list ? [Scalar.new(result)] : result
+      end
+    end
+
+    # Array push with autovivifying dereference support.
+    class Push < Base
+      def initialize(array, values)
+        @array = array
+        @values = values
+      end
+
+      def run(env, context)
+        array = @array.lvalue(env, :scalar)
+        raise PerlError, 'Type of arg 1 to push must be array' unless array.is_a?(PerlArray)
+
+        values = @values.flat_map { |value| value.argument_cells(env) }.map(&:copy)
+        array.cells.concat(values)
+        result = array.size
+        context == :list ? [Scalar.new(result)] : result
+      end
+    end
+
+    # Perl exists() over array/hash elements and slices.
+    class Exists < Base
+      def initialize(expression)
+        @expression = expression
+      end
+
+      def run(env, context)
+        result = @expression.respond_to?(:exists?) && @expression.exists?(env) ? 1 : ''
+        context == :list ? [Scalar.new(result)] : result
+      end
+    end
+
+    # Perl delete() over array/hash elements and slices.
+    class Delete < Base
+      def initialize(expression)
+        @expression = expression
+      end
+
+      def run(env, context)
+        values = @expression.respond_to?(:delete) ? @expression.delete(env) : []
+        return values.map { |value| Scalar.new(value) } if context == :list
+
+        values.last
+      end
+    end
+
+    # Blesses an existing reference into a package.
+    class Bless < Base
+      def initialize(arguments)
+        @arguments = arguments
+      end
+
+      def run(env, context)
+        reference = @arguments.first&.run(env, :scalar)
+        raise PerlError, 'Blessing non-reference value' unless reference.is_a?(Ref)
+
+        package = @arguments[1] ? Conv.to_str(@arguments[1].run(env, :scalar)) : env.package
+        reference.blessed = package
+        reference.runtime = env.runtime
+        env.runtime.register_object(reference)
+        context == :list ? [Scalar.new(reference)] : reference
+      end
+    end
+
+    # Object or class method invocation through Perl's package MRO.
+    class MethodCall < Base
+      def initialize(receiver, name, arguments)
+        @receiver = receiver
+        @name = name
+        @arguments = arguments
+      end
+
+      def run(env, context)
+        invoke(@receiver.run(env, :scalar), env, context)
+      end
+
+      def to_callable
+        receiver = @receiver.to_callable
+        scalar_receiver = @receiver.scalar_callable if @receiver.respond_to?(:scalar_callable)
+        arguments = @arguments.argument_callable
+        return static_callable(receiver, scalar_receiver, arguments, @arguments.empty?) unless @name.respond_to?(:run)
+
+        lambda do |env, context|
+          value = scalar_receiver ? scalar_receiver.call(env) : receiver.call(env, :scalar)
+          invoke(value, env, context, arguments.call(env))
+        end
+      end
+
+      private
+
+      # rubocop:disable-next Metrics/AbcSize
+      def static_callable(receiver, scalar_receiver, arguments, no_arguments)
+        method = @name
+        cached_package = cached_name = cached_super = cached_generation = cached_code = nil
+        lambda do |env, context|
+          value = scalar_receiver ? scalar_receiver.call(env) : receiver.call(env, :scalar)
+          next invoke(value, env, context, arguments.call(env)) if %w[isa DOES can VERSION].include?(method)
+
+          package = value.is_a?(Ref) ? value.blessed : Conv.to_str(value)
+          raise PerlError, "Can't call method #{method} on unblessed reference" if package.nil?
+
+          super_from = method.start_with?('SUPER::') ? env.package : nil
+          resolved_name = method.delete_prefix('SUPER::')
+          generation = env.runtime.stash.generation
+          unless cached_package == package && cached_name == resolved_name && cached_super == super_from &&
+                 cached_generation == generation
+            cached_package = package
+            cached_name = resolved_name
+            cached_super = super_from
+            cached_generation = generation
+            cached_code = env.runtime.mro.resolve(package, resolved_name, super_from:)&.last
+          end
+          raise PerlError, "Can't locate object method #{resolved_name} via package #{package}" unless cached_code
+
+          cells = no_arguments ? [] : arguments.call(env)
+          env.runtime.call(cached_code, [Scalar.new(value), *cells], context)
+        end
+      end
+
+      def invoke(receiver, env, context, argument_cells = @arguments.argument_cells(env))
+        method = method_name(env)
+        if method.is_a?(Code)
+          arguments = [Scalar.new(receiver), *argument_cells]
+          return env.runtime.call(method, arguments, context)
+        end
+        return universal(receiver, method, env, context) if %w[isa DOES can VERSION].include?(method)
+
+        package = receiver.is_a?(Ref) ? receiver.blessed : Conv.to_str(receiver)
+        raise PerlError, "Can't call method #{method} on unblessed reference" if package.nil?
+
+        super_from = method.start_with?('SUPER::') ? env.package : nil
+        method = method.delete_prefix('SUPER::')
+        code = resolved_method(env, package, method, super_from)
+        raise PerlError, "Can't locate object method #{method} via package #{package}" unless code
+
+        arguments = [Scalar.new(receiver), *argument_cells]
+        env.runtime.call(code, arguments, context)
+      end
+
+      def resolved_method(env, package, method, super_from)
+        stash = env.runtime.stash
+        key = [package, method, super_from]
+        unless @cached_method_key == key && @cached_method_generation == stash.generation
+          @cached_method_key = key
+          @cached_method_generation = stash.generation
+          @cached_method = env.runtime.mro.resolve(package, method, super_from:)&.last
+        end
+        @cached_method
+      end
+
+      def method_name(env)
+        return @name unless @name.respond_to?(:run)
+
+        value = @name.run(env, :scalar)
+        return value.target if value.is_a?(Ref) && value.kind == 'CODE'
+
+        Conv.to_str(value)
+      end
+
+      def universal(receiver, method, env, context)
+        package = receiver.is_a?(Ref) ? receiver.blessed : Conv.to_str(receiver)
+        argument = @arguments.run(env, :scalar)
+        value = case method
+                when 'isa', 'DOES' then env.runtime.mro.isa?(package, Conv.to_str(argument)) ? 1 : ''
+                when 'can' then can(package, Conv.to_str(argument), env)
+                when 'VERSION' then version(package, argument, env)
+                end
+        context == :list ? [Scalar.new(value)] : value
+      end
+
+      def can(package, method, env)
+        entry = env.runtime.mro.resolve(package, method, autoload: false)
+        entry && Ref.new(entry.last)
+      end
+
+      def version(package, required, env)
+        version = env.fetch(:scalar, "#{package}::VERSION").get
+        if !required.nil? && Conv.to_num(version) < Conv.to_num(required)
+          message = "#{package} version #{Conv.to_str(required)} required--this is only version #{Conv.to_str(version)}"
+          raise PerlError, message
+        end
+
+        version
+      end
+    end
+
+    # Tail-call style goto &sub preserving the current @_ cells.
+    class Goto < Base
+      def initialize(name)
+        @name = name
+      end
+
+      def run(env, _context)
+        code = env.runtime.stash.glob(@name).code || env.runtime.stash.glob("#{env.package}::#{@name}").code
+        raise PerlError, "Undefined subroutine &#{@name} called" unless code
+
+        throw :peruby_return, GotoRequest.new(code)
+      end
+    end
+
+    # undef with optional deterministic blessed-reference release.
+    class Undef < Base
+      def initialize(expression)
+        @expression = expression
+      end
+
+      def run(env, _context)
+        cell = @expression.lvalue(env, :scalar)
+        env.runtime.release(cell.get)
+        cell.set(nil)
+        nil
+      end
+    end
+  end
+end

data/lib/peruby/op/control.rb

@@ -0,0 +1,256 @@
+# frozen_string_literal: true
+
+module Peruby
+  module Op
+    # Shared label-aware last/next/redo handling.
+    module LoopExecution
+      private
+
+      def run_iteration?(env, body = @body)
+        loop do
+          body.run(env, :void)
+          break
+        rescue LoopControl => e
+          raise unless e.label.nil? || e.label == @label
+
+          return false if e.kind == :last
+          break if e.kind == :next
+        end
+        @continue&.run(env, :void)
+        true
+      end
+    end
+
+    # Ordered statement execution, optionally in a lexical scope.
+    class Sequence < Base
+      def initialize(operations, scoped: false)
+        @operations = operations
+        @scoped = scoped
+        @warning_scope = operations.any?(&:warning_directive?)
+      end
+
+      def run(env, context)
+        execute = -> { execute_operations(env, context) }
+        scoped = -> { @scoped ? env.with_scope(&execute) : execute.call }
+        @warning_scope ? env.runtime.with_warning_scope(&scoped) : scoped.call
+      end
+
+      def run_subroutine(env, context)
+        if !@scoped && @operations.last.respond_to?(:return_value)
+          @operations[0...-1].each { |operation| operation.run(env, :void) }
+          return @operations.last.return_value(env, context)
+        end
+
+        catch(:peruby_return) { run(env, context) }
+      end
+
+      def to_callable
+        operations = @operations.map(&:to_callable)
+        execute = lambda do |env, context|
+          next nil if operations.empty?
+
+          operations[0...-1].each { |operation| operation.call(env, :void) }
+          operations.last.call(env, context)
+        end
+        callable = @scoped ? ->(env, context) { env.with_scope { execute.call(env, context) } } : execute
+        warning_callable(callable)
+      end
+
+      def to_subroutine_callable
+        operations = @operations.map(&:to_callable)
+        if !@scoped && @operations.last.respond_to?(:return_callable)
+          returning = @operations.last.return_callable
+          callable = lambda do |env, context|
+            operations[0...-1].each { |operation| operation.call(env, :void) }
+            returning.call(env, context)
+          end
+          return warning_callable(callable)
+        end
+
+        callable = to_callable
+        ->(env, context) { catch(:peruby_return) { callable.call(env, context) } }
+      end
+
+      def to_void_callable
+        operations = @operations.map do |operation|
+          next operation.to_void_callable if operation.respond_to?(:to_void_callable)
+
+          callable = operation.to_callable
+          ->(env) { callable.call(env, :void) }
+        end
+        execute = ->(env) { operations.each { |operation| operation.call(env) } }
+        callable = @scoped ? ->(env) { env.with_scope { execute.call(env) } } : execute
+        return callable unless @warning_scope
+
+        ->(env) { env.runtime.with_warning_scope { callable.call(env) } }
+      end
+
+      private
+
+      def warning_callable(callable)
+        return callable unless @warning_scope
+
+        ->(env, context) { env.runtime.with_warning_scope { callable.call(env, context) } }
+      end
+
+      def execute_operations(env, context)
+        return nil if @operations.empty?
+
+        @operations[0...-1].each { |operation| operation.run(env, :void) }
+        @operations.last.run(env, context)
+      end
+    end
+
+    # Conditional branch operation.
+    class Conditional < Base
+      def initialize(condition, then_branch, else_branch)
+        @condition = condition
+        @then_branch = then_branch
+        @else_branch = else_branch
+      end
+
+      def run(env, context)
+        branch = Conv.truthy?(@condition.run(env, :scalar)) ? @then_branch : @else_branch
+        branch&.run(env, context)
+      end
+
+      def to_callable
+        condition = @condition.to_callable
+        scalar_condition = @condition.scalar_callable if @condition.respond_to?(:scalar_callable)
+        then_branch = @then_branch.to_callable
+        else_branch = @else_branch&.to_callable
+        lambda do |env, context|
+          value = scalar_condition ? scalar_condition.call(env) : condition.call(env, :scalar)
+          branch = Conv.truthy?(value) ? then_branch : else_branch
+          branch&.call(env, context)
+        end
+      end
+    end
+
+    # Changes the package used for unqualified global names.
+    class PackageSwitch < Base
+      def initialize(name) = @name = name
+      def run(env, _context) = env.package = @name
+    end
+
+    # Temporarily changes the current package for one lexical block.
+    class PackageBlock < Base
+      def initialize(name, body)
+        @name = name
+        @body = body
+      end
+
+      def run(env, context) = env.with_package(@name) { @body.run(env, context) }
+
+      def to_callable
+        body = @body.to_callable
+        ->(env, context) { env.with_package(@name) { body.call(env, context) } }
+      end
+    end
+
+    # A standalone Perl block behaves as a one-iteration loop.
+    class BareBlock < Base
+      def initialize(body, label)
+        @body = body
+        @label = label
+      end
+
+      def run(env, context)
+        loop do
+          return @body.run(env, context)
+        rescue LoopControl => e
+          raise unless e.label.nil? || e.label == @label
+
+          return nil unless e.kind == :redo
+        end
+      end
+    end
+
+    # While or until loop operation.
+    class While < Base
+      include LoopExecution
+
+      def initialize(condition, body, until_loop, continuation = nil, label = nil)
+        @condition = condition
+        @body = body
+        @until_loop = until_loop
+        @continue = continuation
+        @label = label
+      end
+
+      def run(env, _context)
+        loop do
+          truth = Conv.truthy?(@condition.run(env, :scalar))
+          break if @until_loop ? truth : !truth
+
+          break unless run_iteration?(env)
+        end
+        nil
+      end
+
+      def to_callable
+        condition = @condition.to_callable
+        scalar_condition = @condition.scalar_callable if @condition.respond_to?(:scalar_callable)
+        body = @body.to_callable
+        void_body = @body.to_void_callable if @body.respond_to?(:to_void_callable)
+        continuation = @continue&.to_callable
+        lambda do |env, _context|
+          loop do
+            value = scalar_condition ? scalar_condition.call(env) : condition.call(env, :scalar)
+            truth = Conv.truthy?(value)
+            break if @until_loop ? truth : !truth
+
+            keep_going = compiled_iteration?(env, body, void_body, continuation)
+            break unless keep_going
+          end
+          nil
+        end
+      end
+
+      private
+
+      def compiled_iteration?(env, body, void_body, continuation)
+        loop do
+          void_body ? void_body.call(env) : body.call(env, :void)
+          break
+        rescue LoopControl => e
+          raise unless e.label.nil? || e.label == @label
+
+          return false if e.kind == :last
+          break if e.kind == :next
+        end
+        continuation&.call(env, :void)
+        true
+      end
+    end
+
+    # Block and string eval sharing the current lexical environment.
+    class Eval < Base
+      def initialize(body, string, file: '-e')
+        @body = body
+        @string = string
+        @file = file
+      end
+
+      def run(env, context)
+        env.fetch(:scalar, '@').set('')
+        result = if @string
+                   env.with_scope do
+                     source = Conv.to_str(@body.run(env, :scalar))
+                     operation = CompileUnit.new(runtime: env.runtime, file: @file).compile(source, env:)
+                     operation.run_subroutine(env, context)
+                   end
+                 else
+                   @body.run_subroutine(env, context)
+                 end
+        env.fetch(:scalar, '@').set('')
+        result
+      rescue Error => e
+        value = e.is_a?(PerlError) ? e.value : e.message
+        value = env.runtime.error_message(value) unless value.is_a?(Ref)
+        env.fetch(:scalar, '@').set(value)
+        context == :list ? [] : nil
+      end
+    end
+  end
+end