peruby 0.1.0

data/lib/peruby/runtime/conv.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Peruby
+  # Perl scalar coercion rules used by all operators and built-ins.
+  module Conv
+    IV_MAX = (2**63) - 1
+    IV_MIN = -(2**63)
+    NUM_RE = /\A\s*([+-]?(?:(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?|Inf(?:inity)?|NaN))/i
+    MAGICAL_INCREMENT = /\A[a-zA-Z]*[0-9]*\z/
+
+    module_function
+
+    def truthy?(value)
+      if value.is_a?(Ref) && value.runtime
+        found, overloaded = value.runtime.overloaded(value, 'bool')
+        return truthy?(overloaded) if found
+      end
+      case value
+      when nil then false
+      when String then !value.empty? && value != '0'
+      when Numeric then !value.zero?
+      when Dualvar then truthy?(value.str)
+      else true
+      end
+    end
+
+    def to_num(value)
+      case value
+      when Integer, Float then value
+      when Dualvar then value.num
+      when Ref
+        found, overloaded = value.runtime&.overloaded(value, '0+')
+        found ? to_num(overloaded) : value.target.object_id
+      when String then parse_num(value)
+      else 0
+      end
+    end
+
+    def to_str(value)
+      case value
+      when nil then ''
+      when Float then format_float(value)
+      when Dualvar then value.str
+      when Ref
+        found, overloaded = value.runtime&.overloaded(value, '""')
+        found ? to_str(overloaded) : ref_to_str(value)
+      when Glob then "*#{value.full_name}"
+      else value.to_s
+      end
+    end
+
+    def norm_int(number)
+      return number.to_f if number.is_a?(Integer) && !number.between?(IV_MIN, IV_MAX)
+
+      number
+    end
+
+    def increment(value)
+      string = to_str(value)
+      return string.succ if MAGICAL_INCREMENT.match?(string) && string.match?(/[a-zA-Z0-9]/)
+
+      norm_int(to_num(value) + 1)
+    end
+
+    # perlop: classic bitwise operators use byte strings only when both operands are strings.
+    def bitwise(operator, left, right)
+      unless left.is_a?(String) && right.is_a?(String)
+        return to_num(left).to_i.public_send(operator, to_num(right).to_i)
+      end
+
+      left_bytes = left.bytes
+      right_bytes = right.bytes
+      lengths = [left_bytes.length, right_bytes.length]
+      length = operator == :& ? lengths.min : lengths.max
+      Array.new(length) { |index| (left_bytes[index] || 0).public_send(operator, right_bytes[index] || 0) }.pack('C*')
+    end
+
+    def bit_not(value)
+      return ~to_num(value).to_i unless value.is_a?(String)
+
+      value.bytes.map { |byte| byte ^ 0xff }.pack('C*')
+    end
+
+    def divide(left, right)
+      divisor = to_num(right)
+      raise PerlError, 'Illegal division by zero' if divisor.zero?
+
+      to_num(left).fdiv(divisor)
+    end
+
+    def modulo(left, right)
+      divisor = to_num(right)
+      raise PerlError, 'Illegal modulus zero' if divisor.zero?
+
+      to_num(left) % divisor
+    end
+
+    def repeat(value, count)
+      to_str(value) * [to_num(count).to_i, 0].max
+    end
+
+    def parse_num(value)
+      match = NUM_RE.match(value)
+      return 0 unless match
+
+      number = match[1]
+      return Float::NAN if number.casecmp('nan').zero?
+      return number.start_with?('-') ? -Float::INFINITY : Float::INFINITY if number.match?(/inf/i)
+
+      number.match?(/[.e]/i) ? number.to_f : number.to_i
+    end
+    private_class_method :parse_num
+
+    def format_float(value)
+      return '0' if value.zero?
+      return 'NaN' if value.nan?
+      return value.negative? ? '-Inf' : 'Inf' if value.infinite?
+
+      format('%.15g', value)
+    end
+    private_class_method :format_float
+
+    def ref_to_str(ref)
+      return regexp_to_str(ref.target) if ref.target.is_a?(Regexp)
+
+      prefix = ref.blessed ? "#{ref.blessed}=" : ''
+      "#{prefix}#{ref.kind}(0x#{ref.target.object_id.to_s(16)})"
+    end
+    private_class_method :ref_to_str
+
+    def regexp_to_str(regexp)
+      flags = +''
+      flags << 'i' if regexp.options.anybits?(Regexp::IGNORECASE)
+      flags << 's' if regexp.options.anybits?(Regexp::MULTILINE)
+      flags << 'x' if regexp.options.anybits?(Regexp::EXTENDED)
+      "(?^#{flags}:#{regexp.source})"
+    end
+    private_class_method :regexp_to_str
+  end
+end

data/lib/peruby/runtime/directory_handle.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Peruby
+  # Stateful Perl directory handle backed by Ruby's Dir.
+  class DirectoryHandle
+    def initialize(path)
+      @directory = Dir.open(path)
+    end
+
+    def read = @directory.read
+    def rewind = @directory.rewind && 1
+
+    def close
+      @directory.close
+      1
+    end
+  end
+end

data/lib/peruby/runtime/env.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Peruby
+  # Runtime lexical environment and package fallback.
+  class Env
+    attr_reader :runtime, :want, :package, :generation, :state_owner
+
+    def initialize(runtime, scopes: nil, want: :void, package: 'main', state_owner: nil, strict: nil) # rubocop:disable Metrics/ParameterLists
+      @runtime = runtime
+      @scopes = scopes || [{}]
+      @want = want
+      @package = package
+      @state_owner = state_owner
+      @strict = strict || Set.new
+      @generation = 0
+      @lookup_cache = {}
+    end
+
+    def with_scope(&)
+      package = @package
+      strict = @strict.dup
+      @scopes << {}
+      @runtime.local_stack.within { @runtime.with_match_scope(&) }
+    ensure
+      changed_package = @package != package
+      @package = package
+      @strict = strict
+      invalidate if changed_package || !@scopes.pop.empty?
+    end
+
+    def with_package(package)
+      previous = @package
+      self.package = package
+      yield
+    ensure
+      self.package = previous
+    end
+
+    def package=(package)
+      @package = package
+      invalidate
+    end
+
+    def configure_strict(categories, disable: false)
+      categories = %w[refs subs vars] if categories.empty?
+      disable ? @strict.subtract(categories) : @strict.merge(categories)
+    end
+
+    def strict_refs? = @strict.include?('refs')
+    def strict_categories = @strict.dup
+
+    def declare(sigil, name)
+      invalidate
+      @scopes.last[[sigil, name]] = empty_value(sigil)
+    end
+
+    def bind(sigil, name, value)
+      invalidate
+      @scopes.last[[sigil, name]] = value
+    end
+
+    def fork(want: :void, package: @package, state_owner: nil)
+      self.class.new(@runtime, scopes: @scopes.dup << {}, want:, package:, state_owner:, strict: @strict.dup)
+    end
+
+    def call_frame(arguments, want:, package:, state_owner:)
+      arguments_scope = { [:array, '_'].freeze => PerlArray.new(arguments) }
+      self.class.new(@runtime, scopes: @scopes.dup << arguments_scope, want:, package:, state_owner:,
+                               strict: @strict.dup)
+    end
+
+    def capture
+      self.class.new(@runtime, scopes: @scopes.map(&:dup), want: @want, package: @package, state_owner: @state_owner,
+                               strict: @strict.dup)
+    end
+
+    def fetch(sigil, name)
+      fetch_key([sigil, name])
+    end
+
+    def fetch_key(key)
+      sigil, name = key
+      match_value = @runtime.match_state.fetch(sigil, name)
+      return match_value if match_value
+
+      cached = @lookup_cache[key]
+      return cached if cached
+
+      scope = @scopes.reverse_each.find { |candidate| candidate.key?(key) }
+      return @lookup_cache[key] = scope[key] if scope
+
+      @lookup_cache[key] = glob_value(sigil, name)
+    end
+
+    private
+
+    def invalidate
+      @generation += 1
+      @lookup_cache.clear
+    end
+
+    def empty_value(sigil)
+      case sigil
+      when :scalar then Scalar.new
+      when :array then PerlArray.new
+      when :hash then PerlHash.new
+      else raise ArgumentError, "unknown sigil: #{sigil}"
+      end
+    end
+
+    def glob_value(sigil, name)
+      name = "#{@package}::#{name}" if package_variable?(name)
+      glob = @runtime.stash.glob(name)
+      case sigil
+      when :scalar then glob.scalar
+      when :array then glob.array
+      when :hash then glob.hash
+      when :code then glob.code
+      when :glob then glob
+      else raise ArgumentError, "unknown sigil: #{sigil}"
+      end
+    end
+
+    def package_variable?(name)
+      !name.include?('::') && !name.include?("'") && !name.match?(/\A(?:\d+|\W|\^.)\z/) &&
+        !%w[_ ARGV ENV INC SIG].include?(name)
+    end
+  end
+end

data/lib/peruby/runtime/glob.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Peruby
+  # Five independent value slots associated with one Perl symbol name.
+  class Glob
+    SLOTS = %i[scalar array hash code io].freeze
+
+    attr_reader :full_name
+    attr_accessor(*SLOTS)
+
+    def initialize(full_name)
+      @full_name = full_name
+      @scalar = Scalar.new
+      @array = PerlArray.new
+      @hash = PerlHash.new
+    end
+
+    def replace(slot, value)
+      raise ArgumentError, "unknown glob slot: #{slot}" unless SLOTS.include?(slot)
+
+      public_send("#{slot}=", value)
+    end
+  end
+end

data/lib/peruby/runtime/interpolation.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+module Peruby
+  # Expands the escape and variable forms needed by interpolating strings.
+  module Interpolation
+    ESCAPED_DOLLAR = "\u0000DOLLAR\u0000"
+    ESCAPED_ARRAY = "\u0000ARRAY\u0000"
+    ESCAPED_BACKSLASH = "\u0000BACKSLASH\u0000"
+    NAME = /[A-Za-z_]\w*(?:(?:::|')[A-Za-z_]\w*)*/
+    ESCAPES = { 'n' => "\n", 't' => "\t", 'r' => "\r", 'f' => "\f", 'b' => "\b",
+                'a' => "\a", 'e' => "\e", '\\' => '\\', '"' => '"', '$' => '$', '@' => '@' }.freeze
+
+    module_function
+
+    def expand(quote, env)
+      raw = quote.parts.first
+      return escapes(raw) unless quote.interpolate
+
+      text = interpolate_expressions(raw, env)
+      cases(escapes(text)).gsub(ESCAPED_DOLLAR, '$').gsub(ESCAPED_ARRAY, '@').gsub(ESCAPED_BACKSLASH, '\\')
+    end
+
+    def pattern(quote, env)
+      raw = quote.parts.first.gsub('\\$', ESCAPED_DOLLAR).gsub('\\@', ESCAPED_ARRAY)
+      text = raw.gsub(variable_pattern) do
+        sigil = Regexp.last_match(1) == '$' ? :scalar : :array
+        name = Regexp.last_match(2) || Regexp.last_match(3)
+        interpolate(env.fetch(sigil, name), sigil, env)
+      end
+      text.gsub(ESCAPED_DOLLAR, '\\$').gsub(ESCAPED_ARRAY, '\\@')
+    end
+
+    def variable_pattern
+      /([$@])(?:\{(#{NAME.source})\}|(#{NAME.source}|\d+|[&`'+]))/
+    end
+
+    def escapes(text)
+      text.gsub(/\\(?:x\{([0-9a-fA-F]+)\}|x([0-9a-fA-F]{1,2})|0([0-7]{0,2})|c(.)|N\{U\+([0-9a-fA-F]+)\}|(.))/) do
+        escape_match(Regexp.last_match)
+      end
+    end
+
+    def escape_match(match)
+      return match[1].to_i(16).chr(Encoding::UTF_8) if match[1]
+      return match[2].to_i(16).chr(Encoding::UTF_8) if match[2]
+      return match[3].to_i(8).chr if match[3]
+      return (match[4].ord & 31).chr if match[4]
+      return match[5].to_i(16).chr(Encoding::UTF_8) if match[5]
+
+      return "\\#{match[6]}" if %w[U L Q u l E].include?(match[6])
+
+      ESCAPES.fetch(match[6], match[6])
+    end
+
+    def interpolate(value, sigil, env)
+      return Conv.to_str(value.get) if sigil == :scalar
+
+      value.list.map { |cell| Conv.to_str(cell.get) }.join(Conv.to_str(env.fetch(:scalar, '"').get))
+    end
+
+    def interpolate_expressions(source, env)
+      output = +''
+      index = 0
+      while index < source.length
+        if source[index] == '\\'
+          output << source[index, 2]
+          index += 2
+          next
+        end
+        unless '$@'.include?(source[index])
+          output << source[index]
+          index += 1
+          next
+        end
+
+        length, value = interpolation_at(source, index, env)
+        unless length
+          output << source[index]
+          index += 1
+          next
+        end
+        output << protect(value)
+        index += length
+      end
+      output
+    end
+
+    # rubocop:disable-next Metrics/AbcSize
+    def interpolation_at(source, index, env)
+      marker = source[index]
+      return array_last(source, index, env) if marker == '$' && source[index + 1] == '#'
+      return scalar_dereference(source, index, env) if marker == '$' && source[index + 1] == '$'
+      return braced_interpolation(source, index, env) if source[index + 1] == '{'
+
+      name = source[(index + 1)..].match(/\A(#{NAME.source}|\d+|[&`'+])/)&.[](1)
+      return [nil, nil] unless name
+
+      finish = consume_access_chain(source, index + 1 + name.length)
+      expression = source[index...finish]
+      value = if finish == index + 1 + name.length
+                interpolate(env.fetch(marker == '$' ? :scalar : :array, name), marker == '$' ? :scalar : :array, env)
+              else
+                evaluate(expression, env, marker == '$' ? :scalar : :list)
+              end
+      [finish - index, stringify(value, marker, env)]
+    end
+
+    def braced_interpolation(source, index, env)
+      finish = balanced_finish(source, index + 1)
+      return [nil, nil] unless finish
+
+      body = source[(index + 2)...(finish - 1)].strip
+      marker = source[index]
+      value = if marker == '$' && body.match?(/\A#{NAME.source}\z/)
+                env.fetch(:scalar, body).get
+              else
+                dereferenced(evaluate(body, env, :scalar), marker)
+              end
+      [finish - index, stringify(value, marker, env)]
+    end
+
+    def array_last(source, index, env)
+      name = source[(index + 2)..].match(/\A(#{NAME.source})/)&.[](1)
+      return [nil, nil] unless name
+
+      [name.length + 2, (env.fetch(:array, name).size - 1).to_s]
+    end
+
+    def scalar_dereference(source, index, env)
+      name = source[(index + 2)..].match(/\A(#{NAME.source})/)&.[](1)
+      return [nil, nil] unless name
+
+      [name.length + 2, Conv.to_str(dereferenced(env.fetch(:scalar, name).get, '$'))]
+    end
+
+    def consume_access_chain(source, index)
+      loop do
+        start = if source[index, 2] == '->' && source[index + 2] && '[{'.include?(source[index + 2])
+                  index + 2
+                elsif source[index] && '[{'.include?(source[index])
+                  index
+                end
+        break unless start
+
+        index = balanced_finish(source, start) || index
+      end
+      index
+    end
+
+    def balanced_finish(source, start)
+      pairs = { '{' => '}', '[' => ']' }
+      close = pairs[source[start]]
+      return unless close
+
+      depth = 1
+      index = start + 1
+      while index < source.length
+        depth += 1 if source[index] == source[start]
+        depth -= 1 if source[index] == close
+        return index + 1 if depth.zero?
+
+        index += source[index] == '\\' ? 2 : 1
+      end
+    end
+
+    def evaluate(source, env, context)
+      tree = Parser.parse("#{source};", file: env.runtime.current_file, package: env.package)
+      Compiler.new.compile(tree).run(env, context)
+    end
+
+    def dereferenced(value, marker)
+      return value unless value.is_a?(Ref)
+      return value.target.get if marker == '$' && value.target.is_a?(Scalar)
+      return value.target.list if marker == '@' && value.target.is_a?(PerlArray)
+
+      value
+    end
+
+    def stringify(value, marker, env)
+      if marker == '@'
+        return Array(value).map { |item| Conv.to_str(item.respond_to?(:get) ? item.get : item) }
+                           .join(Conv.to_str(env.fetch(:scalar, '"').get))
+      end
+
+      Conv.to_str(value.respond_to?(:get) ? value.get : value)
+    end
+
+    def protect(value)
+      value.gsub('\\', ESCAPED_BACKSLASH).gsub('$', ESCAPED_DOLLAR).gsub('@', ESCAPED_ARRAY)
+    end
+
+    def cases(text)
+      output = +''
+      mode = nil
+      quote = false
+      once = nil
+      index = 0
+      while index < text.length
+        control = text[index, 2]
+        if control.match?(/\A\\[ULQulE]\z/)
+          command = control[1]
+          mode = command if %w[U L].include?(command)
+          quote = true if command == 'Q'
+          once = command if %w[u l].include?(command)
+          if command == 'E'
+            mode = once = nil
+            quote = false
+          end
+          index += 2
+          next
+        end
+
+        character = text[index]
+        character = mode == 'U' ? character.upcase : character.downcase if mode
+        character = once == 'u' ? character.upcase : character.downcase if once
+        once = nil
+        output << (quote ? Regexp.escape(character) : character)
+        index += 1
+      end
+      output
+    end
+  end
+end

data/lib/peruby/runtime/io_handle.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Peruby
+  # Perl filehandle state over a Ruby IO object.
+  class IOHandle
+    attr_accessor :io, :lineno, :eof_flag, :layers
+
+    def initialize(io, layers: [])
+      @io = io
+      @lineno = 0
+      @eof_flag = false
+      @layers = layers
+    end
+
+    def read_record(separator)
+      value = if separator.nil?
+                @io.read
+              elsif separator == ''
+                @io.gets("\n\n")
+              elsif separator.is_a?(Ref) && separator.target.is_a?(Scalar)
+                @io.read(Conv.to_num(separator.target.get).to_i)
+              else
+                @io.gets(Conv.to_str(separator))
+              end
+      @eof_flag = value.nil?
+      @lineno += 1 if value
+      value
+    end
+
+    def close
+      @io.close unless @io.closed?
+      1
+    rescue IOError, SystemCallError
+      ''
+    end
+  end
+end

data/lib/peruby/runtime/local_stack.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Peruby
+  # Restores dynamically localized values in reverse order.
+  class LocalStack
+    def initialize
+      @restorers = []
+    end
+
+    def mark
+      @restorers.size
+    end
+
+    def localize_glob(glob, slot, replacement = nil)
+      old = glob.public_send(slot)
+      @restorers << -> { glob.replace(slot, old) }
+      glob.replace(slot, replacement || default_for(slot))
+    end
+
+    def localize_hash(hash, key)
+      key = key.to_s
+      old = hash.cells[key]
+      @restorers << -> { hash.replace_cell(key, old) }
+      hash.replace_cell(key, Scalar.new)
+    end
+
+    def localize_array(array, index)
+      index += array.size if index.negative?
+      old = array.cells[index]
+      @restorers << -> { array.replace_cell(index, old) }
+      array.replace_cell(index, Scalar.new)
+    end
+
+    def localize_scalar(scalar)
+      old = scalar.get
+      @restorers << -> { scalar.set(old) }
+      scalar.set(nil)
+    end
+
+    def localize_array_value(array)
+      old = array.cells.dup
+      @restorers << -> { array.cells.replace(old) }
+      array.cells.clear
+      array
+    end
+
+    def localize_hash_value(hash)
+      old = hash.cells.dup
+      @restorers << -> { hash.cells.replace(old) }
+      hash.cells.clear
+      hash
+    end
+
+    def localize_entire_glob(glob) # rubocop:disable Metrics/AbcSize
+      scalar = glob.scalar
+      array = glob.array
+      hash = glob.hash
+      old = [scalar.get, array.cells.dup, hash.cells.dup, glob.code, glob.io]
+      @restorers << lambda do
+        scalar.set(old[0])
+        array.cells.replace(old[1])
+        hash.cells.replace(old[2])
+        glob.code = old[3]
+        glob.io = old[4]
+      end
+      scalar.set(nil)
+      array.cells.clear
+      hash.cells.clear
+      glob.code = glob.io = nil
+      glob
+    end
+
+    def unwind_to(mark)
+      @restorers.pop.call while @restorers.size > mark
+    end
+
+    def within
+      saved = mark
+      yield
+    ensure
+      unwind_to(saved)
+    end
+
+    private
+
+    def default_for(slot)
+      { scalar: Scalar.new, array: PerlArray.new, hash: PerlHash.new }[slot]
+    end
+  end
+end