peruby 0.1.0

data/lib/peruby/op/builtin.rb

@@ -0,0 +1,903 @@
+# frozen_string_literal: true
+
+require 'English'
+require 'stringio'
+
+module Peruby
+  module Op
+    # Standard-library-backed Perl built-ins that do not need custom syntax.
+    class Builtin < Base # rubocop:disable Metrics/ClassLength
+      NAMES = %w[
+        open close binmode seek tell fileno eof select opendir readdir closedir rewinddir stat lstat chmod chown utime
+        flock
+        glob
+        length substr index rindex uc lc ucfirst lcfirst reverse join sprintf
+        chomp chop chr ord quotemeta pop shift unshift splice keys values each sort defined scalar wantarray
+        abs int sqrt sin
+        cos atan2 exp log hex oct rand srand time localtime gmtime sleep times pack unpack mkdir rmdir unlink rename
+        link
+        symlink readlink truncate system exec fork wait waitpid kill exit getppid warn die first sum sum0 min max
+        minstr maxstr reduce any all none shuffle uniq pairs encode decode gettimeofday tempfile tempdir GetOptions
+        INT_MAX O_RDONLY O_WRONLY O_RDWR O_CREAT O_TRUNC SEEK_SET SEEK_CUR SEEK_END EACCES ENOENT
+        plan ok is isnt like is_deeply pass fail subtest done_testing diag
+        blessed reftype refaddr weaken dualvar looks_like_number floor ceil fmod strftime Dumper
+        basename dirname catfile catdir rel2abs getcwd abs_path mkpath rmtree encode_json decode_json
+        md5_hex sha1_hex sha256_hex dclone carp croak confess cluck
+      ].freeze
+      MODULE_NAMES = %w[
+        first sum sum0 min max minstr maxstr reduce any all none shuffle uniq pairs encode decode gettimeofday
+        tempfile tempdir GetOptions INT_MAX O_RDONLY O_WRONLY O_RDWR O_CREAT O_TRUNC SEEK_SET SEEK_CUR SEEK_END
+        EACCES ENOENT
+      ].freeze
+
+      def self.supports?(name) = NAMES.include?(name)
+
+      def initialize(name, arguments, file: '-e', line: 1)
+        @name = name
+        @arguments = arguments
+        @file = file
+        @line = line
+      end
+
+      def run(env, context)
+        code = env.runtime.stash.fetch(@name)&.code if MODULE_NAMES.include?(@name)
+        return env.runtime.call(code, @arguments.flat_map { |argument| argument.argument_cells(env) }, context) if code
+
+        result = dispatch(env, context)
+        return result if result.is_a?(Array) && result.all?(Scalar)
+
+        context == :list ? Array(result).map { |value| Scalar.new(value) } : result
+      end
+
+      def lvalue(env, context)
+        return super unless @name == 'substr'
+
+        cell = @arguments.first.lvalue(env, :scalar)
+        offset = Conv.to_num(@arguments[1].run(env, :scalar)).to_i
+        length = @arguments[2] && Conv.to_num(@arguments[2].run(env, :scalar)).to_i
+        SubstringCell.new(cell, offset, length)
+      end
+
+      private
+
+      # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      def dispatch(env, context)
+        args = scalar_values(env)
+        case @name
+        when 'length' then Conv.to_str(args[0]).length
+        when 'uc' then Conv.to_str(args[0]).upcase
+        when 'lc' then Conv.to_str(args[0]).downcase
+        when 'ucfirst' then Conv.to_str(args[0]).sub(/./, &:upcase)
+        when 'lcfirst' then Conv.to_str(args[0]).sub(/./, &:downcase)
+        when 'chr' then Conv.to_num(args[0]).to_i.chr(Encoding::UTF_8)
+        when 'ord' then Conv.to_str(args[0]).codepoints.first || 0
+        when 'quotemeta' then Regexp.escape(Conv.to_str(args[0]))
+        when 'index', 'rindex' then string_index(args)
+        when 'substr' then substring(env, args)
+        when 'join' then list_values(env).drop(1).map { |value| Conv.to_str(value) }.join(Conv.to_str(args[0]))
+        when 'sprintf' then Sprintf.format(Conv.to_str(args[0]), list_values(env).drop(1))
+        when 'reverse' then reverse(env, context)
+        when 'defined' then args[0].nil? ? '' : 1
+        when 'scalar' then @arguments.first&.run(env, :scalar)
+        when 'wantarray' then { list: 1, scalar: '', void: nil }.fetch(env.want)
+        when 'abs' then overloaded_abs(env, args[0])
+        when 'int' then Conv.to_num(args[0]).to_i
+        when 'sqrt' then Math.sqrt(Conv.to_num(args[0]))
+        when 'sin', 'cos', 'exp', 'log' then Math.public_send(@name, Conv.to_num(args[0]))
+        when 'atan2' then Math.atan2(Conv.to_num(args[0]), Conv.to_num(args[1]))
+        when 'first', 'reduce', 'any', 'all', 'none' then list_utility_block(env, context)
+        when 'sum', 'sum0' then list_sum(env)
+        when 'min' then list_values(env).min_by { |value| Conv.to_num(value) }
+        when 'max' then list_values(env).max_by { |value| Conv.to_num(value) }
+        when 'minstr' then list_values(env).min_by { |value| Conv.to_str(value) }
+        when 'maxstr' then list_values(env).max_by { |value| Conv.to_str(value) }
+        when 'shuffle' then list_values(env).shuffle
+        when 'uniq'
+          seen = {}
+          list_values(env).select { |value| !seen.key?(Conv.to_str(value)) && (seen[Conv.to_str(value)] = true) }
+        when 'pairs' then list_values(env).each_slice(2).map { |pair| pair_reference(pair) }
+        when 'plan' then env.runtime.test_builder.plan(Conv.to_num(args.last).to_i)
+        when 'ok' then env.runtime.test_builder.ok(Conv.truthy?(args[0]), Conv.to_str(args[1]))
+        when 'pass' then env.runtime.test_builder.ok(true, Conv.to_str(args[0]))
+        when 'fail' then env.runtime.test_builder.ok(false, Conv.to_str(args[0]))
+        when 'is' then env.runtime.test_builder.ok(equal?(args[0], args[1]), Conv.to_str(args[2]))
+        when 'isnt' then env.runtime.test_builder.ok(!equal?(args[0], args[1]), Conv.to_str(args[2]))
+        when 'like' then env.runtime.test_builder.ok(like?(args[0], args[1]), Conv.to_str(args[2]))
+        when 'is_deeply'
+          env.runtime.test_builder.ok(deep_value(args[0]) == deep_value(args[1]), Conv.to_str(args[2]))
+        when 'done_testing' then env.runtime.test_builder.done_testing
+        when 'subtest' then subtest(env, args)
+        when 'diag' then env.runtime.stderr.puts("# #{Conv.to_str(args[0])}") && 1
+        when 'blessed' then args[0].is_a?(Ref) ? args[0].blessed.to_s : ''
+        when 'reftype' then args[0].is_a?(Ref) ? args[0].kind : ''
+        when 'refaddr' then args[0].is_a?(Ref) ? args[0].target.object_id : nil
+        when 'weaken' then args[0].is_a?(Ref) ? args[0].weaken! : nil
+        when 'dualvar' then Dualvar.new(Conv.to_num(args[0]), Conv.to_str(args[1]))
+        when 'looks_like_number' then Conv::NUM_RE.match?(Conv.to_str(args[0])) ? 1 : ''
+        when 'floor', 'ceil' then Conv.to_num(args[0]).public_send(@name)
+        when 'fmod' then Conv.to_num(args[0]) % Conv.to_num(args[1])
+        when 'strftime' then posix_strftime(args)
+        when 'INT_MAX' then (2**31) - 1
+        when 'Dumper' then data_dumper(env, list_values(env))
+        when 'basename' then File.basename(Conv.to_str(args[0]))
+        when 'dirname' then File.dirname(Conv.to_str(args[0]))
+        when 'catfile', 'catdir' then File.join(*args.map { |value| Conv.to_str(value) })
+        when 'rel2abs' then File.expand_path(Conv.to_str(args[0]), Conv.to_str(args[1] || Dir.pwd))
+        when 'getcwd' then Dir.pwd
+        when 'abs_path' then File.realpath(Conv.to_str(args[0]))
+        when 'tempfile', 'tempdir' then temporary_value(args, context)
+        when 'mkpath' then file_utils.mkdir_p(Conv.to_str(args[0])).last
+        when 'rmtree' then file_utils.rm_rf(Conv.to_str(args[0])).length
+        when 'encode_json' then json.generate(deep_value(args[0]))
+        when 'decode_json' then ruby_value(json.parse(Conv.to_str(args[0])))
+        when 'encode' then Conv.to_str(args[1]).encode(Conv.to_str(args[0]))
+        when 'decode'
+          Conv.to_str(args[1]).dup.force_encoding(Conv.to_str(args[0])).encode(Encoding::UTF_8)
+        when 'md5_hex' then digest::MD5.hexdigest(Conv.to_str(args[0]))
+        when 'sha1_hex' then digest::SHA1.hexdigest(Conv.to_str(args[0]))
+        when 'sha256_hex' then digest::SHA256.hexdigest(Conv.to_str(args[0]))
+        when 'dclone' then ruby_value(deep_value(args[0]))
+        when 'carp', 'cluck'
+          env.runtime.emit_warning(Conv.to_str(args[0]), file: @file, line: @line)
+          1
+        when 'croak', 'confess', 'die' then env.runtime.die(list_values(env), file: @file, line: @line)
+        when 'hex' then Conv.to_str(args[0]).to_i(16)
+        when 'oct' then Conv.to_str(args[0]).to_i(8)
+        when 'rand' then rand(args[0] ? Conv.to_num(args[0]) : 1.0)
+        when 'srand' then seed_random(args[0])
+        when 'time' then Time.now.to_i
+        when 'gettimeofday' then high_resolution_time(context)
+        when 'localtime', 'gmtime' then time_parts(args[0], utc: @name == 'gmtime', context:)
+        when 'sleep' then sleep(Conv.to_num(args[0] || 0))
+        when 'times' then process_times(context)
+        when 'pack' then list_values(env).drop(1).pack(Conv.to_str(args[0]))
+        when 'unpack' then unpack_values(args, context)
+        when 'keys', 'values' then hash_values(env, @name, context)
+        when 'each' then hash_each(env, context)
+        when 'sort' then list_values(env).sort_by { |value| Conv.to_str(value) }
+        when 'pop', 'shift' then array_remove(env, @name)
+        when 'unshift' then array_unshift(env)
+        when 'splice' then array_splice(env, context)
+        when 'chomp', 'chop' then trim(env, @name)
+        when 'open' then open_handle(env, args)
+        when 'close' then handle(env, @arguments.first, args[0])&.close || ''
+        when 'binmode' then binmode(env, args)
+        when 'seek'
+          handle(env, @arguments.first, args[0]).io.seek(Conv.to_num(args[1]), Conv.to_num(args[2]).to_i) && 1
+        when 'tell' then handle(env, @arguments.first, args[0]).io.tell
+        when 'fileno' then handle(env, @arguments.first, args[0]).io.fileno
+        when 'eof' then eof_value(env, args)
+        when 'select' then select_output(env, args)
+        when 'opendir' then open_directory(env, args)
+        when 'readdir' then read_directory(env, args, context)
+        when 'closedir' then directory_handle(env, args).close
+        when 'rewinddir' then directory_handle(env, args).rewind
+        when 'stat', 'lstat' then stat_values(env, args, context)
+        when 'chmod' then File.chmod(Conv.to_num(args.shift).to_i, *args.map { |value| Conv.to_str(value) })
+        when 'chown' then File.chown(Conv.to_num(args.shift).to_i, Conv.to_num(args.shift).to_i, *args.map(&:to_s))
+        when 'utime' then file_utime(args)
+        when 'flock' then handle(env, @arguments.first, args[0]).io.flock(Conv.to_num(args[1]).to_i) ? 1 : ''
+        when 'glob' then glob_values(args, context)
+        when 'mkdir', 'rmdir', 'unlink', 'truncate' then file_operation(args)
+        when 'rename', 'link', 'symlink' then File.public_send(@name, *args.map { |value| Conv.to_str(value) }) && 1
+        when 'readlink' then File.readlink(Conv.to_str(args[0]))
+        when 'system' then run_system(env)
+        when 'exec' then Process.exec(*list_values(env).map { |value| Conv.to_str(value) })
+        when 'fork' then fork_process(env)
+        when 'wait', 'waitpid' then wait_process(env, args)
+        when 'kill' then Process.kill(args.shift, *args.map { |value| Conv.to_num(value).to_i })
+        when 'exit'
+          status = Conv.to_num(args[0] || 0).to_i
+          env.fetch(:scalar, '?').set(status)
+          raise PerlExit, status
+        when 'getppid' then Process.ppid
+        when 'GetOptions' then get_options(env)
+        when 'O_RDONLY', 'O_WRONLY', 'O_RDWR', 'O_CREAT', 'O_TRUNC' then file_constant(@name)
+        when 'SEEK_SET', 'SEEK_CUR', 'SEEK_END' then IO.const_get(@name)
+        when 'EACCES', 'ENOENT' then Errno.const_get(@name)::Errno
+        when 'warn' then warn_message(env)
+        end
+      rescue SystemCallError, IOError => e
+        env.fetch(:scalar, '!').set(Dualvar.new(e.errno || 0, e.message))
+        ''
+      end
+
+      def scalar_values(env) = @arguments.map { |argument| argument.run(env, :scalar) }
+      def list_values(env) = @arguments.flat_map { |argument| argument.run(env, :list) }.map(&:get)
+
+      def file_utils
+        require 'fileutils'
+        FileUtils
+      end
+
+      def json
+        require 'json'
+        JSON
+      end
+
+      def digest
+        require 'digest'
+        Digest
+      end
+
+      def equal?(left, right)
+        return Conv.to_num(left) == Conv.to_num(right) if left.is_a?(Numeric) || right.is_a?(Numeric)
+
+        Conv.to_str(left) == Conv.to_str(right)
+      end
+
+      def list_sum(env)
+        values = list_values(env)
+        return nil if values.empty? && @name == 'sum'
+
+        values.sum { |value| Conv.to_num(value) }
+      end
+
+      def overloaded_abs(env, value)
+        found, overloaded = env.runtime.overloaded(value, 'abs')
+        found ? overloaded : Conv.to_num(value).abs
+      end
+
+      def list_utility_block(env, context)
+        code = @arguments.first&.run(env, :scalar)
+        code = code.target if code.is_a?(Ref) && code.kind == 'CODE'
+        raise PerlError, "#{@name} requires a code reference" unless code.is_a?(Code)
+
+        cells = @arguments.drop(1).flat_map { |argument| argument.argument_cells(env) }
+        return reduce_cells(env, code, cells) if @name == 'reduce'
+
+        matches = cells.select { |cell| predicate(env, code, cell) }
+        return matches.first&.get if @name == 'first'
+
+        results = { 'any' => !matches.empty?, 'all' => matches.length == cells.length, 'none' => matches.empty? }
+        result = results.fetch(@name)
+        value = result ? 1 : ''
+        context == :list ? [Scalar.new(value)] : value
+      end
+
+      def predicate(env, code, cell)
+        code.environment.with_scope do
+          code.environment.bind(:scalar, '_', cell)
+          Conv.truthy?(env.runtime.call(code, [], :scalar))
+        end
+      end
+
+      def reduce_cells(env, code, cells)
+        return nil if cells.empty?
+
+        a = env.runtime.stash.glob("#{env.package}::a").scalar
+        b = env.runtime.stash.glob("#{env.package}::b").scalar
+        previous = [a.get, b.get]
+        result = cells.first.get
+        cells.drop(1).each do |cell|
+          a.set(result)
+          b.set(cell.get)
+          result = env.runtime.call(code, [], :scalar)
+        end
+        result
+      ensure
+        a&.set(previous&.first)
+        b&.set(previous&.last)
+      end
+
+      def pair_reference(pair)
+        Ref.new(PerlArray.new(pair.map { |value| Scalar.new(value) }))
+      end
+
+      def high_resolution_time(context)
+        now = Time.now
+        context == :list ? [now.to_i, now.usec] : now.to_f
+      end
+
+      def temporary_value(args, context)
+        if @name == 'tempdir'
+          require 'tmpdir'
+          return Dir.mktmpdir(Conv.to_str(args[0] || 'peruby'))
+        end
+
+        require 'tempfile'
+        file = Tempfile.new(Conv.to_str(args[0] || 'peruby'))
+        values = [IOHandle.new(file), file.path]
+        context == :list ? values : values.first
+      end
+
+      def file_constant(name)
+        require 'fcntl'
+        Fcntl.const_get(name)
+      end
+
+      def get_options(env)
+        specifications = list_values(env).each_slice(2).to_h
+        cells = env.fetch(:array, 'ARGV').cells
+        index = 0
+        while index < cells.length
+          consumed = consume_option(cells, index, specifications)
+          consumed ? cells.slice!(index, consumed) : index += 1
+        end
+        1
+      end
+
+      # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def consume_option(cells, index, specifications)
+        argument = Conv.to_str(cells[index].get)
+        return unless argument.start_with?('--')
+
+        option, inline = argument.delete_prefix('--').split('=', 2)
+        spec, target = specifications.find do |name, _value|
+          name.to_s.sub(/[=!:].*\z/, '').split('|').include?(option.delete_prefix('no-'))
+        end
+        return unless spec && target.is_a?(Ref) && target.target.is_a?(Scalar)
+
+        takes_value = spec.to_s.match?(/[=:][sif]\z/)
+        following = cells[index + 1]&.get if takes_value && inline.nil?
+        return if takes_value && inline.nil? && following.nil?
+
+        value = inline || following || (option.start_with?('no-') ? '' : 1)
+        value = Conv.to_num(value).to_i if spec.to_s.end_with?('=i', ':i')
+        value = Conv.to_num(value) if spec.to_s.end_with?('=f', ':f')
+        target.target.set(value)
+        takes_value && inline.nil? ? 2 : 1
+      end
+
+      def posix_strftime(args)
+        format = Conv.to_str(args[0])
+        return Time.at(Conv.to_num(args[1] || Time.now.to_i)).strftime(format) if args.length < 7
+
+        second, minute, hour, day, month, year = args.drop(1).first(6).map { |value| Conv.to_num(value).to_i }
+        Time.local(year + 1900, month + 1, day, hour, minute, second).strftime(format)
+      end
+
+      def data_dumper(env, values)
+        terse = Conv.truthy?(env.fetch(:scalar, 'Data::Dumper::Terse').get)
+        seen = {}.compare_by_identity
+        values.each_with_index.map do |value, index|
+          label = "$VAR#{index + 1}"
+          prefix = terse ? '' : "$VAR#{index + 1} = "
+          suffix = terse ? "\n" : ";\n"
+          "#{prefix}#{dump_value(value, prefix.length, seen, label)}#{suffix}"
+        end.join
+      end
+
+      def dump_value(value, indent, seen, label)
+        target = value.is_a?(Ref) ? value.target : value
+        if target.is_a?(PerlArray) || target.is_a?(PerlHash)
+          return seen[target] if seen.key?(target)
+
+          seen[target] = label
+        end
+        dumped = if target.is_a?(PerlArray)
+                   dump_array(target, indent, seen, label)
+                 elsif target.is_a?(PerlHash)
+                   dump_hash(target, indent, seen, label)
+                 else
+                   dump_scalar(target)
+                 end
+        value.is_a?(Ref) && value.blessed ? "bless( #{dumped}, '#{value.blessed}' )" : dumped
+      end
+
+      def dump_array(array, indent, seen, label)
+        values = array.cells.each_with_index.map do |cell, index|
+          dump_value(cell&.value, indent + 2, seen, "#{label}->[#{index}]")
+        end
+        return '[]' if values.empty?
+
+        "[\n#{values.map { |value| "#{' ' * (indent + 2)}#{value}" }.join(",\n")}\n#{' ' * indent}]"
+      end
+
+      def dump_hash(hash, indent, seen, label)
+        values = hash.cells.map do |key, cell|
+          quoted = dump_scalar(key)
+          value = dump_value(cell.value, indent + quoted.length + 6, seen, "#{label}->{#{quoted}}")
+          "#{' ' * (indent + 2)}#{quoted} => #{value}"
+        end
+        return '{}' if values.empty?
+
+        "{\n#{values.join(",\n")}\n#{' ' * indent}}"
+      end
+
+      def dump_scalar(value)
+        return 'undef' if value.nil?
+        return Conv.to_str(value) if value.is_a?(Numeric)
+
+        "'#{Conv.to_str(value).gsub('\\', '\\\\').gsub("'", "\\\\'")}'"
+      end
+
+      def like?(value, pattern)
+        regexp = pattern.is_a?(Ref) ? pattern.target : pattern
+        regexp.is_a?(Regexp) && regexp.match?(Conv.to_str(value))
+      end
+
+      def deep_value(value)
+        if value.is_a?(Ref) && value.target.is_a?(PerlArray)
+          return value.target.cells.map { |cell| deep_value(cell.get) }
+        end
+        if value.is_a?(Ref) && value.target.is_a?(PerlHash)
+          return value.target.cells.to_h { |key, cell| [key, deep_value(cell.get)] }
+        end
+
+        value
+      end
+
+      def subtest(env, args)
+        code = args[1]
+        code = code.target if code.is_a?(Ref) && code.kind == 'CODE'
+        raise PerlError, 'subtest requires a code reference' unless code.is_a?(Code)
+
+        env.runtime.test_builder.subtest(Conv.to_str(args[0])) { env.runtime.call(code, [], :void) }
+      end
+
+      def ruby_value(value)
+        case value
+        when Array then Ref.new(PerlArray.new(value.map { |item| Scalar.new(ruby_value(item)) }))
+        when Hash
+          hash = PerlHash.new
+          value.each { |key, item| hash.slot(key).set(ruby_value(item)) }
+          Ref.new(hash)
+        else value
+        end
+      end
+
+      def substring(env, args)
+        string = Conv.to_str(args[0])
+        offset = Conv.to_num(args[1]).to_i
+        length = args[2] && Conv.to_num(args[2]).to_i
+        value = length ? string.slice(offset, length) : string.slice(offset..)
+        return value unless args.length > 3
+
+        cell = @arguments.first.lvalue(env, :scalar)
+        string = string.dup
+        string[offset, length] = Conv.to_str(args[3])
+        cell.set(string)
+        value
+      end
+
+      def string_index(args)
+        string = Conv.to_str(args[0])
+        needle = Conv.to_str(args[1])
+        offset = args[2] && Conv.to_num(args[2]).to_i
+        (offset ? string.public_send(@name, needle, offset) : string.public_send(@name, needle)) || -1
+      end
+
+      def warn_message(env)
+        message = list_values(env).map { |value| Conv.to_str(value) }.join
+        env.runtime.stderr.print(env.runtime.error_message(message))
+        1
+      end
+
+      def reverse(env, context)
+        values = list_values(env)
+        return values.reverse.map { |value| Scalar.new(value) } if context == :list
+
+        values.map { |value| Conv.to_str(value) }.join.reverse
+      end
+
+      def time_parts(value, utc:, context:)
+        time = Time.at(Conv.to_num(value || Time.now.to_i))
+        time = time.utc if utc
+        return time.strftime('%a %b %e %H:%M:%S %Y') unless context == :list
+
+        daylight = time.dst? ? 1 : 0
+        [time.sec, time.min, time.hour, time.day, time.month - 1, time.year - 1900,
+         time.wday, time.yday - 1, daylight]
+      end
+
+      def seed_random(value)
+        seed = value.nil? ? Random.new_seed : Conv.to_num(value).to_i
+        Kernel.srand(seed)
+        seed
+      end
+
+      def process_times(context)
+        times = Process.times
+        values = [times.utime, times.stime, times.cutime, times.cstime]
+        context == :list ? values : values.first
+      end
+
+      def unpack_values(args, context)
+        values = Conv.to_str(args[1]).unpack(Conv.to_str(args[0]))
+        context == :list ? values : values.first
+      end
+
+      def run_system(env)
+        result = Kernel.system(*list_values(env).map { |value| Conv.to_str(value) })
+        status = result.nil? ? -1 : $CHILD_STATUS.to_i
+        env.fetch(:scalar, '?').set(status)
+        status
+      end
+
+      def fork_process(env)
+        pid = Process.fork
+        env.fetch(:scalar, '$').set(Process.pid) unless pid
+        pid || 0
+      end
+
+      def wait_process(env, args)
+        pid = if @name == 'wait'
+                Process.wait
+              else
+                Process.waitpid(Conv.to_num(args[0]).to_i, Conv.to_num(args[1] || 0).to_i)
+              end
+        env.fetch(:scalar, '?').set($CHILD_STATUS.to_i)
+        pid
+      rescue Errno::ECHILD
+        -1
+      end
+
+      def hash_values(env, name, context)
+        hash = @arguments.first.lvalue(env, :scalar)
+        raise PerlError, "Type of arg 1 to #{name} must be hash" unless hash.is_a?(PerlHash)
+
+        values = name == 'keys' ? hash.keys : hash.keys.map { |key| hash.fetch(key) }
+        context == :list ? values : values.length
+      end
+
+      def hash_each(env, context)
+        hash = @arguments.first.lvalue(env, :scalar)
+        raise PerlError, 'Type of arg 1 to each must be hash' unless hash.is_a?(PerlHash)
+
+        pair = hash.each_pair
+        return context == :list ? [] : nil unless pair
+
+        key, cell = pair
+        context == :list ? [Scalar.new(key), cell] : key
+      end
+
+      def array_remove(env, name)
+        array = if @arguments.empty?
+                  env.fetch(:array, env.state_owner ? '_' : 'ARGV')
+                else
+                  @arguments.first.lvalue(env, :scalar)
+                end
+        cell = name == 'pop' ? array.cells.pop : array.cells.shift
+        cell&.get
+      end
+
+      def array_unshift(env)
+        array = @arguments.first.lvalue(env, :scalar)
+        array.cells.unshift(*@arguments.drop(1).flat_map { |arg| arg.argument_cells(env) }.map(&:copy))
+        array.size
+      end
+
+      # rubocop:disable-next Metrics/AbcSize
+      def array_splice(env, context)
+        array = @arguments.first.lvalue(env, :scalar)
+        args = scalar_values(env)
+        offset = Conv.to_num(args[1] || 0).to_i
+        offset += array.size if offset.negative?
+        length = args[2] ? Conv.to_num(args[2]).to_i : array.size - offset
+        length = array.size - offset + length if length.negative?
+        replacement = @arguments.drop(3).flat_map { |arg| arg.argument_cells(env) }.map(&:copy)
+        removed = array.cells.slice!(offset, length) || []
+        array.cells.insert(offset, *replacement)
+        context == :list ? removed : removed.last&.get
+      end
+
+      def trim(env, name)
+        cell = @arguments.first.lvalue(env, :scalar)
+        string = Conv.to_str(cell.get)
+        removed = if name == 'chomp'
+                    string.sub!(/\R\z/, '') ? 1 : 0
+                  else
+                    string.slice!(-1).to_s.length
+                  end
+        cell.set(string)
+        removed
+      end
+
+      def open_handle(env, args)
+        target = @arguments.first
+        values = @arguments.drop(1).flat_map { |argument| argument.run(env, :list) }.map(&:get)
+        marker, layers, source = open_spec(values)
+        io = open_io(marker, source, values.drop(2))
+        apply_layers(io, layers)
+        assign_handle(env, target, args[0], IOHandle.new(io, layers:))
+        1
+      end
+
+      def open_spec(values)
+        if values.length == 1
+          source = Conv.to_str(values[0])
+          marker = source.slice!(/\A(?:\+?[<>]{1,2}|-\||\|-)/) || '<'
+          marker, layers = marker.split(':', 2)
+          return [marker, layers, source]
+        end
+        marker, layers = Conv.to_str(values[0]).split(':', 2)
+        [marker, layers, values[1]]
+      end
+
+      def ruby_mode(marker)
+        { '<' => 'r', '>' => 'w', '>>' => 'a', '+<' => 'r+', '+>' => 'w+', '+>>' => 'a+' }.fetch(marker, marker)
+      end
+
+      def open_io(marker, source, command_tail)
+        if %w[-| |-].include?(marker)
+          command = [Conv.to_str(source), *command_tail.map { |item| Conv.to_str(item) }]
+          return IO.popen(command, marker == '-|' ? 'r' : 'w')
+        end
+
+        if source.is_a?(Ref) && source.target.is_a?(Scalar)
+          return StringIO.new(Conv.to_str(source.target.get), ruby_mode(marker))
+        end
+
+        File.open(Conv.to_str(source), ruby_mode(marker))
+      end
+
+      def apply_layers(io, layers)
+        return unless layers
+
+        encoding = layers[/encoding\(([^)]+)\)/, 1] || ('UTF-8' if layers == 'utf8')
+        io.set_encoding(encoding) if encoding && io.respond_to?(:set_encoding)
+        io.binmode if layers == 'raw'
+      end
+
+      def assign_handle(env, operation, value, io_handle)
+        if operation.respond_to?(:lvalue)
+          operation.lvalue(env, :scalar).set(io_handle)
+        else
+          env.runtime.stash.glob(Conv.to_str(value)).io = io_handle
+        end
+      rescue PerlError
+        env.runtime.stash.glob(Conv.to_str(value)).io = io_handle
+      end
+
+      def handle(env, operation, value)
+        candidate = operation&.run(env, :scalar)
+        return candidate if candidate.is_a?(IOHandle)
+
+        env.runtime.stash.glob(Conv.to_str(value)).io
+      end
+
+      def binmode(env, args)
+        io_handle = handle(env, @arguments.first, args[0])
+        layer = Conv.to_str(args[1] || ':raw')
+        apply_layers(io_handle.io, layer.delete_prefix(':'))
+        io_handle.layers << layer
+        1
+      end
+
+      def eof_value(env, args)
+        io_handle = args.empty? ? env.runtime.last_input_handle : handle(env, @arguments.first, args[0])
+        io_handle ||= env.runtime.stash.glob('STDIN').io
+        io_handle.io.eof? ? 1 : ''
+      end
+
+      def select_output(env, args)
+        io_handle = args.empty? ? nil : handle(env, @arguments.first, args[0])
+        env.runtime.select_output(io_handle)
+      end
+
+      def open_directory(env, args)
+        assign_handle(env, @arguments.first, args[0], DirectoryHandle.new(Conv.to_str(args[1])))
+        1
+      end
+
+      def directory_handle(env, args)
+        value = @arguments.first&.run(env, :scalar)
+        return value if value.is_a?(DirectoryHandle)
+
+        handle = env.runtime.stash.glob(Conv.to_str(args[0])).io
+        raise PerlError, 'readdir() attempted on invalid dirhandle' unless handle.is_a?(DirectoryHandle)
+
+        handle
+      end
+
+      def read_directory(env, args, context)
+        directory = directory_handle(env, args)
+        return directory.read if context != :list
+
+        entries = []
+        loop do
+          entry = directory.read
+          break unless entry
+
+          entries << entry
+        end
+        entries
+      end
+
+      def stat_values(env, args, context)
+        stat = env.runtime.file_stat(Conv.to_str(args[0]), lstat: @name == 'lstat')
+        return 1 unless context == :list
+
+        [stat.dev, stat.ino, stat.mode, stat.nlink, stat.uid, stat.gid, stat.rdev, stat.size,
+         stat.atime.to_i, stat.mtime.to_i, stat.ctime.to_i, stat.blksize, stat.blocks]
+      end
+
+      def file_utime(args)
+        access = Time.at(Conv.to_num(args.shift))
+        modify = Time.at(Conv.to_num(args.shift))
+        File.utime(access, modify, *args.map { |value| Conv.to_str(value) })
+      end
+
+      def glob_values(args, context)
+        return args.flat_map { |pattern| Dir.glob(Conv.to_str(pattern)) } if context == :list
+
+        @glob_values = Dir.glob(Conv.to_str(args[0])) if @glob_values.nil? || @glob_values.empty?
+        @glob_values.shift
+      end
+
+      def file_operation(args)
+        case @name
+        when 'mkdir' then Dir.mkdir(Conv.to_str(args[0]), Conv.to_num(args[1] || 0o777).to_i)
+        when 'rmdir' then Dir.rmdir(Conv.to_str(args[0]))
+        when 'unlink' then File.unlink(*args.map { |value| Conv.to_str(value) })
+        when 'truncate' then File.truncate(Conv.to_str(args[0]), Conv.to_num(args[1]).to_i)
+        end
+      end
+
+      # Mutable view used when substr appears on the left of an assignment.
+      class SubstringCell
+        def initialize(cell, offset, length)
+          @cell = cell
+          @offset = offset
+          @length = length
+        end
+
+        def get
+          string = Conv.to_str(@cell.get)
+          @length ? string.slice(@offset, @length) : string.slice(@offset..)
+        end
+
+        def set(value)
+          string = Conv.to_str(@cell.get).dup
+          @length ? string[@offset, @length] = Conv.to_str(value) : string[@offset..] = Conv.to_str(value)
+          @cell.set(string)
+          self
+        end
+      end
+    end
+
+    # Perl file-test operators backed by File::Stat predicates.
+    class FileTest < Base
+      def initialize(operator, expression)
+        @operator = operator.delete_prefix('-')
+        @expression = expression
+      end
+
+      def run(env, context)
+        path = Conv.to_str(@expression.run(env, :scalar))
+        result = test(path, env)
+        context == :list ? [Scalar.new(result)] : result
+      rescue SystemCallError
+        context == :list ? [Scalar.new('')] : ''
+      end
+
+      private
+
+      # rubocop:disable-next Metrics/AbcSize
+      def test(path, env)
+        return tty(path, env) if @operator == 't'
+
+        stat = env.runtime.file_stat(path, lstat: @operator == 'l')
+        actual_path = path == '_' ? env.runtime.file_stat_path : path
+        predicates = { 'e' => true, 'f' => stat.file?, 'd' => stat.directory?, 'l' => stat.symlink?,
+                       'r' => File.readable?(actual_path), 'w' => File.writable?(actual_path),
+                       'x' => File.executable?(actual_path), 'z' => stat.zero?, 'p' => stat.pipe?, 'S' => stat.socket?,
+                       'b' => stat.blockdev?, 'c' => stat.chardev?, 'u' => stat.setuid?, 'g' => stat.setgid?,
+                       'k' => stat.sticky? }
+        return stat.size if @operator == 's'
+        return text_file?(actual_path) == (@operator == 'T') ? 1 : '' if %w[T B].include?(@operator)
+        return predicates.fetch(@operator) ? 1 : '' if predicates.key?(@operator)
+
+        return (Time.now - stat.mtime) / 86_400 if @operator == 'M'
+        return (Time.now - stat.atime) / 86_400 if @operator == 'A'
+        return (Time.now - stat.ctime) / 86_400 if @operator == 'C'
+
+        ''
+      end
+
+      def tty(path, env)
+        handle = env.runtime.stash.glob(path).io
+        io = handle&.io
+        io&.tty? ? 1 : ''
+      end
+
+      def text_file?(path)
+        bytes = File.binread(path, 1024).bytes
+        return true if bytes.empty?
+        return false if bytes.include?(0)
+
+        controls = bytes.count { |byte| byte < 32 && ![9, 10, 12, 13].include?(byte) }
+        controls.fdiv(bytes.length) < 0.3
+      end
+    end
+
+    # Compile-time pragmas and registered core modules; loading expands in P12.
+    class Use < Base
+      CORE = ModuleLoader::INTERNAL_MODULES
+
+      def initialize(module_name, imports, disable, package)
+        @module_name = module_name
+        @imports = imports
+        @disable = disable
+        @package = package
+      end
+
+      def run(env, context) # rubocop:disable Metrics/AbcSize
+        imports, version, suppress = options
+        env.configure_strict(imports, disable: @disable) if @module_name == 'strict'
+        env.runtime.configure_warnings(imports, disable: @disable) if @module_name == 'warnings'
+        configure_inc(env, imports) if @module_name == 'lib' && !@disable
+        env.runtime.module_loader.require_module(@module_name) unless @disable
+        configure_inheritance(env, imports) if %w[parent base].include?(@module_name) && !@disable
+        configure_overload(env, imports) if @module_name == 'overload'
+        check_version(env, version) if version
+        invoke_import(env, imports, suppress)
+        alias_imports(env, imports) unless @disable || suppress
+        if %w[Test::More Test::Simple].include?(@module_name) && imports.first == 'tests'
+          env.runtime.test_builder.plan(imports.last)
+        end
+        context == :list ? [Scalar.new(1)] : 1
+      end
+
+      def warning_directive? = @module_name == 'warnings'
+
+      private
+
+      def options
+        imports = @imports.dup
+        suppress = imports.delete('__NO_IMPORT__')
+        version = imports.shift(2).last if imports.first == '__VERSION__'
+        [imports, version, suppress]
+      end
+
+      def check_version(env, required)
+        actual = env.runtime.stash.glob("#{@module_name}::VERSION").scalar.get
+        return if actual && Conv.to_num(actual) >= Conv.to_num(required)
+
+        raise PerlError, "#{@module_name} version #{required} required"
+      end
+
+      def invoke_import(env, imports, suppress)
+        return if suppress
+
+        method = @disable ? 'unimport' : 'import'
+        code = env.runtime.stash.fetch("#{@module_name}::#{method}")&.code
+        return unless code
+
+        arguments = [Scalar.new(@module_name), *imports.map { |name| Scalar.new(name) }]
+        env.runtime.call(code, arguments, :void)
+      end
+
+      def alias_imports(env, imports)
+        names = if imports.empty?
+                  env.runtime.stash.glob("#{@module_name}::EXPORT").array.cells.map(&:get)
+                else
+                  imports
+                end
+        names.each do |name|
+          code = env.runtime.stash.fetch("#{@module_name}::#{name}")&.code
+          env.runtime.stash.glob("#{@package}::#{name}").code = code if code
+        end
+        env.runtime.stash.touch unless names.empty?
+      end
+
+      def configure_inc(env, imports)
+        imports.reverse_each { |path| env.fetch(:array, 'INC').cells.unshift(Scalar.new(path)) }
+      end
+
+      def configure_inheritance(env, imports)
+        parents = imports.reject { |name| name == '-norequire' }
+        parents.each { |parent| env.runtime.module_loader.require_module(parent) } unless imports.include?('-norequire')
+        env.runtime.stash.glob("#{@package}::ISA").array.cells.concat(parents.map { |name| Scalar.new(name) })
+        env.runtime.stash.touch
+      end
+
+      def configure_overload(env, imports)
+        env.runtime.register_overload(@package, imports.each_slice(2).to_h, disable: @disable)
+      end
+    end
+
+    # Runtime require expression.
+    class Require < Base
+      def initialize(expression)
+        @expression = expression
+      end
+
+      def run(env, context)
+        result = env.runtime.module_loader.require_module(@expression.run(env, :scalar))
+        context == :list ? [Scalar.new(result)] : result
+      end
+    end
+  end
+end