peruby 0.1.0

data/lib/peruby/op/element.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Peruby
+  module Op
+    # Array/hash access over package aggregates or references, with autovivification.
+    class Element < Base
+      def initialize(container, key, kind, dereference, **options)
+        @container = container
+        @key = key
+        @kind = kind
+        @dereference = dereference
+        @slice = options.fetch(:slice, false)
+        @key_value = options.fetch(:key_value, false)
+      end
+
+      def run(env, context)
+        if @key_value && context == :list
+          container = aggregate(env)
+          return keys(env).flat_map { |key| [Scalar.new(Conv.to_str(key)), slot(container, key)] }
+        end
+
+        cells = lvalue(env, @slice ? :list : :scalar)
+        return cells if context == :list && cells.is_a?(Array)
+
+        cell = cells.is_a?(Array) ? cells.last : cells
+        context == :list ? [cell] : cell&.get
+      end
+
+      def to_callable
+        return super if @slice || @key_value
+
+        key = @key.to_callable
+        lvalue = lvalue_callable
+        lambda do |env, context|
+          cell = lvalue.call(env, key.call(env, :scalar))
+          context == :list ? [cell] : cell&.value
+        end
+      end
+
+      def scalar_callable
+        return unless !@slice && !@key_value
+
+        key = @key.scalar_callable if @key.respond_to?(:scalar_callable)
+        key ||= ->(env) { @key.run(env, :scalar) }
+        lvalue = lvalue_callable
+        ->(env) { lvalue.call(env, key.call(env))&.value }
+      end
+
+      def lvalue_callable
+        return ->(env, _key = nil) { lvalue(env, :list) } if @slice
+
+        container = aggregate_callable
+        kind = @kind
+        lambda do |env, supplied_key = nil|
+          key = supplied_key || @key.run(env, :scalar)
+          key = key.value if key.respond_to?(:value)
+          aggregate = container.call(env)
+          kind == :array ? aggregate.slot(Conv.to_num(key).to_i) : aggregate.slot(Conv.to_str(key))
+        end
+      end
+
+      def lvalue(env, context)
+        container = aggregate(env)
+        unless @slice
+          key = @key.run(env, :scalar)
+          cell = slot(container, key.respond_to?(:get) ? key.get : key)
+          return context == :list ? [cell] : cell
+        end
+
+        keys = @key.run(env, @slice ? :list : :scalar)
+        keys = Array(keys).map { |key| key.respond_to?(:get) ? key.get : key }
+        cells = keys.map { |key| slot(container, key) }
+        context == :list ? cells : cells.last
+      end
+
+      def exists?(env)
+        container = aggregate(env)
+        keys(env).all? { |key| container.exists?(key) }
+      end
+
+      def delete(env)
+        container = aggregate(env)
+        keys(env).map { |key| container.delete(key) }
+      end
+
+      def localize(env, stack)
+        raise PerlError, "Can't localize slice" if @slice
+
+        container = aggregate(env)
+        key = @key.run(env, :scalar)
+        key = key.get if key.respond_to?(:get)
+        if @kind == :array
+          stack.localize_array(container, Conv.to_num(key).to_i)
+        else
+          stack.localize_hash(container, Conv.to_str(key))
+        end
+      end
+
+      private
+
+      def aggregate_callable
+        return ->(env) { aggregate(env) } unless @container.respond_to?(:aggregate_callable)
+
+        @container.aggregate_callable(@kind, dereference: @dereference)
+      end
+
+      def aggregate(env)
+        return @container.aggregate(env, @kind, dereference: @dereference) if @container.respond_to?(:aggregate)
+
+        dereference(@container.lvalue(env, :scalar))
+      end
+
+      def keys(env)
+        values = @key.run(env, @slice ? :list : :scalar)
+        Array(values).map { |key| key.respond_to?(:get) ? key.get : key }
+      end
+
+      def dereference(cell)
+        value = cell.get
+        if value.nil?
+          target = @kind == :array ? PerlArray.new : PerlHash.new
+          value = Ref.new(target)
+          cell.set(value)
+        end
+        expected = @kind == :array ? PerlArray : PerlHash
+        raise PerlError, "Not a #{@kind.to_s.upcase} reference" unless value.is_a?(Ref) && value.target.is_a?(expected)
+
+        value.target
+      end
+
+      def slot(container, key)
+        @kind == :array ? container.slot(Conv.to_num(key).to_i) : container.slot(Conv.to_str(key))
+      end
+    end
+  end
+end

data/lib/peruby/op/expression.rb

@@ -0,0 +1,342 @@
+# frozen_string_literal: true
+
+module Peruby
+  module Op
+    # Unary scalar expression.
+    class Unary < Base
+      def initialize(operator, expression)
+        @operator = operator
+        @expression = expression
+      end
+
+      def run(env, context)
+        return reference(env, context) if @operator == :reference
+
+        value = @expression.run(env, :scalar)
+        if @operator == :negate && value.is_a?(Ref)
+          found, overloaded = env.runtime.overloaded(value, 'neg')
+          return context == :list ? [Scalar.new(overloaded)] : overloaded if found
+        end
+        operations = { negate: -> { -Conv.to_num(value) }, positive: -> { Conv.to_num(value) },
+                       not: -> { Conv.truthy?(value) ? '' : 1 }, bit_not: -> { Conv.bit_not(value) } }
+        result = operations.fetch(@operator).call
+        context == :list ? [Scalar.new(result)] : result
+      end
+
+      def reference(env, context)
+        return @expression.references(env, context) if @expression.respond_to?(:references)
+
+        target = begin
+          @expression.lvalue(env, :scalar)
+        rescue PerlError
+          Scalar.new(@expression.run(env, :scalar))
+        end
+        value = Ref.new(target)
+        context == :list ? [Scalar.new(value)] : value
+      end
+    end
+
+    # Parenthesized expression, retained for Perl's \(LIST) reference semantics.
+    class Group < Base
+      def initialize(expression)
+        @expression = expression
+      end
+
+      def run(env, context) = @expression.run(env, context)
+      def lvalue(env, context) = @expression.lvalue(env, context)
+      def argument_cells(env) = @expression.argument_cells(env)
+      def aggregate(env, kind) = @expression.aggregate(env, kind)
+
+      def references(env, context)
+        values = @expression.argument_cells(env).map { |cell| Scalar.new(Ref.new(cell)) }
+        context == :list ? values : values.last&.get
+      end
+    end
+
+    # Post-increment/decrement preserving the old expression value.
+    class Postfix < Base
+      def initialize(operator, expression)
+        @operator = operator
+        @expression = expression
+      end
+
+      def run(env, context)
+        cell = @expression.lvalue(env, :scalar)
+        old = cell.get
+        value = @operator == :increment ? Conv.increment(old) : Conv.to_num(old) - 1
+        cell.set(value)
+        context == :list ? [Scalar.new(old)] : old
+      end
+    end
+
+    # Pre-increment/decrement returning the updated value.
+    class Prefix < Base
+      def initialize(operator, expression)
+        @operator = operator
+        @expression = expression
+      end
+
+      def run(env, context)
+        cell = @expression.lvalue(env, :scalar)
+        value = @operator == :increment ? Conv.increment(cell.get) : Conv.to_num(cell.get) - 1
+        cell.set(value)
+        context == :list ? [cell] : value
+      end
+    end
+
+    # Arithmetic, comparison, and short-circuit binary expression.
+    class Binary < Base
+      OVERLOAD_OPERATORS = {
+        :+ => '+', :- => '-', :* => '*', divide: '/', modulo: '%', concat: '.',
+        num_eq: '==', num_ne: '==', num_lt: '<=>', num_gt: '<=>', num_le: '<=>', num_ge: '<=>', num_cmp: '<=>',
+        str_eq: 'eq', str_ne: 'eq', str_lt: 'cmp', str_gt: 'cmp', str_le: 'cmp', str_ge: 'cmp', str_cmp: 'cmp'
+      }.freeze
+      NO_OVERLOAD = Object.new.freeze
+      OPERATIONS = {
+        :+ => ->(left, right) { Conv.norm_int(Conv.to_num(left) + Conv.to_num(right)) },
+        :- => ->(left, right) { Conv.norm_int(Conv.to_num(left) - Conv.to_num(right)) },
+        :* => ->(left, right) { Conv.norm_int(Conv.to_num(left) * Conv.to_num(right)) },
+        divide: ->(left, right) { Conv.divide(left, right) },
+        modulo: ->(left, right) { Conv.modulo(left, right) },
+        pow: ->(left, right) { Conv.norm_int(Conv.to_num(left)**Conv.to_num(right)) },
+        concat: ->(left, right) { Conv.to_str(left) + Conv.to_str(right) },
+        repeat: ->(left, right) { Conv.repeat(left, right) },
+        left_shift: ->(left, right) { Conv.to_num(left).to_i << Conv.to_num(right).to_i },
+        right_shift: ->(left, right) { Conv.to_num(left).to_i >> Conv.to_num(right).to_i },
+        bit_and: ->(left, right) { Conv.bitwise(:&, left, right) },
+        bit_or: ->(left, right) { Conv.bitwise(:|, left, right) },
+        bit_xor: ->(left, right) { Conv.bitwise(:^, left, right) }
+      }.freeze
+
+      def initialize(operator, left, right)
+        @operator = operator
+        @left = left
+        @right = right
+        @flip_flops = ObjectSpace::WeakMap.new if range?
+      end
+
+      def run(env, context)
+        return run_range(env, context) if range?
+
+        result = if %i[and or defined_or].include?(@operator)
+                   short_circuit(env)
+                 elsif @operator == :xor
+                   Conv.truthy?(@left.run(env, :scalar)) ^ Conv.truthy?(@right.run(env, :scalar)) ? 1 : ''
+                 else
+                   calculate(@left.run(env, :scalar), @right.run(env, :scalar), env)
+                 end
+        context == :list ? Array(result).map { |value| Scalar.new(value) } : result
+      end
+
+      def to_callable
+        return super if range?
+
+        scalar = scalar_callable
+        lambda do |env, context|
+          result = scalar.call(env)
+          context == :list ? Array(result).map { |value| Scalar.new(value) } : result
+        end
+      end
+
+      def scalar_callable
+        return ->(env) { scalar_range(env) } if range?
+
+        left = child_scalar(@left)
+        right = child_scalar(@right)
+        return ->(env) { compiled_scalar_short_circuit(env, left, right) } if %i[and or defined_or].include?(@operator)
+
+        ->(env) { compiled_calculate(left.call(env), right.call(env), env) }
+      end
+
+      private
+
+      def child_scalar(operation)
+        callable = operation.scalar_callable if operation.respond_to?(:scalar_callable)
+        callable || ->(env) { operation.run(env, :scalar) }
+      end
+
+      def compiled_scalar_short_circuit(env, left_operation, right_operation)
+        left = left_operation.call(env)
+        return Conv.truthy?(left) ? right_operation.call(env) : left if @operator == :and
+        return Conv.truthy?(left) ? left : right_operation.call(env) if @operator == :or
+
+        left.nil? ? right_operation.call(env) : left
+      end
+
+      def compiled_calculate(left, right, env)
+        return calculate(left, right, env) if env.runtime.overloads?
+
+        if left.is_a?(Numeric) && right.is_a?(Numeric)
+          return Conv.norm_int(left + right) if @operator == :+
+          return Conv.norm_int(left - right) if @operator == :-
+          return Conv.norm_int(left * right) if @operator == :*
+          return Conv.divide(left, right) if @operator == :divide
+          return Conv.modulo(left, right) if @operator == :modulo
+          return Conv.norm_int(left**right) if @operator == :pow
+          return compiled_numeric_comparison(left, right) if @operator.to_s.start_with?('num_')
+        end
+        calculate(left, right, env)
+      end
+
+      def compiled_numeric_comparison(left, right)
+        comparison = left <=> right
+        case @operator
+        when :num_eq then comparison.zero? ? 1 : ''
+        when :num_ne then comparison.zero? ? '' : 1
+        when :num_lt then comparison.negative? ? 1 : ''
+        when :num_gt then comparison.positive? ? 1 : ''
+        when :num_le then comparison <= 0 ? 1 : ''
+        when :num_ge then comparison >= 0 ? 1 : ''
+        else comparison
+        end
+      end
+
+      def short_circuit(env)
+        left = @left.run(env, :scalar)
+        return Conv.truthy?(left) ? @right.run(env, :scalar) : left if @operator == :and
+        return Conv.truthy?(left) ? left : @right.run(env, :scalar) if @operator == :or
+
+        left.nil? ? @right.run(env, :scalar) : left
+      end
+
+      def compiled_short_circuit(env, left_operation, right_operation)
+        left = left_operation.call(env, :scalar)
+        return Conv.truthy?(left) ? right_operation.call(env, :scalar) : left if @operator == :and
+        return Conv.truthy?(left) ? left : right_operation.call(env, :scalar) if @operator == :or
+
+        left.nil? ? right_operation.call(env, :scalar) : left
+      end
+
+      def calculate(left, right, env = nil)
+        overloaded = overload(left, right, env)
+        return overloaded unless overloaded.equal?(NO_OVERLOAD)
+
+        if OPERATIONS.key?(@operator)
+          operation = OPERATIONS.fetch(@operator)
+          warnable = !left.is_a?(Numeric) || !right.is_a?(Numeric)
+          if numeric_operator? && warnable && env&.runtime&.warnings_active?
+            return operation.call(env.runtime.number(left), env.runtime.number(right))
+          end
+
+          return operation.call(left, right)
+        end
+        return compare(left, right, env) if @operator.to_s.start_with?('num_', 'str_')
+        return Conv.truthy?(left) ^ Conv.truthy?(right) ? 1 : '' if @operator == :xor
+
+        raise PerlError, "Unsupported binary operator #{@operator}"
+      end
+
+      def overload(left, right, env)
+        operator = OVERLOAD_OPERATORS[@operator]
+        return NO_OVERLOAD unless env && operator && env.runtime.overloads?
+
+        found, value = env.runtime.overloaded(left, operator, right)
+        found, value = env.runtime.overloaded(right, operator, left, swapped: true) unless found
+        return NO_OVERLOAD unless found
+
+        return Conv.truthy?(value) ? '' : 1 if %i[num_ne str_ne].include?(@operator)
+
+        if @operator.to_s.match?(/_(?:lt|gt|le|ge)\z/)
+          relation = @operator.to_s.split('_').last
+          comparison = Conv.to_num(value)
+          matches = { 'lt' => comparison.negative?, 'gt' => comparison.positive?,
+                      'le' => comparison <= 0, 'ge' => comparison >= 0 }
+          return matches.fetch(relation) ? 1 : ''
+        end
+
+        value
+      end
+
+      def compare(left, right, env)
+        string = @operator.to_s.start_with?('str_')
+        comparison = string ? Conv.to_str(left) <=> Conv.to_str(right) : number(left, env) <=> number(right, env)
+        relation = @operator.to_s.delete_prefix('num_').delete_prefix('str_')
+        relations = { eq: comparison.zero?, ne: !comparison.zero?, lt: comparison.negative?, gt: comparison.positive?,
+                      le: comparison <= 0, ge: comparison >= 0, cmp: comparison }
+        perl_boolean(relations.fetch(relation.to_sym))
+      end
+
+      def numeric_operator?
+        !%i[concat repeat].include?(@operator)
+      end
+
+      def number(value, env)
+        env&.runtime&.warnings_active? ? env.runtime.number(value) : Conv.to_num(value)
+      end
+
+      def perl_boolean(value)
+        return 1 if value == true
+        return '' if value == false
+
+        value
+      end
+
+      def range? = %i[range range_exclusive].include?(@operator)
+
+      def run_range(env, context)
+        result = if context == :list
+                   range_values(@left.run(env, :scalar), @right.run(env, :scalar))
+                 else
+                   scalar_range(env)
+                 end
+        context == :list ? result.map { |value| Scalar.new(value) } : result
+      end
+
+      # perlop: in scalar context .. and ... are stateful flip-flops, not list constructors.
+      def scalar_range(env)
+        owner = env.state_owner || env.runtime
+        count = @flip_flops[owner]
+        unless count
+          return '' unless Conv.truthy?(@left.run(env, :scalar))
+
+          count = 1
+          return finish_flip_flop(owner, count) if @operator == :range && Conv.truthy?(@right.run(env, :scalar))
+
+          @flip_flops[owner] = count
+          return count
+        end
+
+        count += 1
+        return finish_flip_flop(owner, count) if Conv.truthy?(@right.run(env, :scalar))
+
+        @flip_flops[owner] = count
+        count
+      end
+
+      def finish_flip_flop(owner, count)
+        @flip_flops[owner] = nil
+        "#{count}E0"
+      end
+
+      def range_values(left, right)
+        return (Conv.to_str(left)..Conv.to_str(right)).to_a if left.is_a?(String) || right.is_a?(String)
+
+        (Conv.to_num(left).to_i..Conv.to_num(right).to_i).to_a
+      end
+    end
+
+    # Lazy conditional expression.
+    class Ternary < Base
+      def initialize(condition, true_expression, false_expression)
+        @condition = condition
+        @true_expression = true_expression
+        @false_expression = false_expression
+      end
+
+      def run(env, context)
+        branch = Conv.truthy?(@condition.run(env, :scalar)) ? @true_expression : @false_expression
+        branch.run(env, context)
+      end
+
+      def to_callable
+        condition = @condition.to_callable
+        true_expression = @true_expression.to_callable
+        false_expression = @false_expression.to_callable
+        lambda do |env, context|
+          branch = Conv.truthy?(condition.call(env, :scalar)) ? true_expression : false_expression
+          branch.call(env, context)
+        end
+      end
+    end
+  end
+end

data/lib/peruby/op/io.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Peruby
+  module Op
+    # Print operation with Perl output separators.
+    class Print < Base
+      def initialize(handle, arguments)
+        @handle = handle
+        @arguments = arguments
+      end
+
+      def run(env, context)
+        values = @arguments ? @arguments.run(env, :list) : [env.fetch(:scalar, '_')]
+        values.each { |cell| env.runtime.warning('uninitialized', 'Use of uninitialized value') if cell.get.nil? }
+        separator = Conv.to_str(env.fetch(:scalar, ',').get)
+        ending = Conv.to_str(env.fetch(:scalar, '\\').get)
+        env.runtime.output(@handle, env).print(values.map { |cell| Conv.to_str(cell.get) }.join(separator), ending)
+        context == :list ? [Scalar.new(1)] : 1
+      end
+    end
+
+    # Formatted output using the Perl sprintf compatibility layer.
+    class Printf < Base
+      def initialize(handle, arguments)
+        @handle = handle
+        @arguments = arguments
+      end
+
+      def run(env, context)
+        values = @arguments&.run(env, :list) || []
+        format = Conv.to_str(values.shift&.get)
+        env.runtime.output(@handle, env).print(Sprintf.format(format, values.map(&:get)))
+        context == :list ? [Scalar.new(1)] : 1
+      end
+    end
+
+    # print with an implicit trailing newline.
+    class Say < Base
+      def initialize(handle, arguments)
+        @handle = handle
+        @arguments = arguments
+      end
+
+      def run(env, context)
+        values = @arguments ? @arguments.run(env, :list) : [env.fetch(:scalar, '_')]
+        env.runtime.output(@handle, env).puts(values.map { |cell| Conv.to_str(cell.get) }.join)
+        context == :list ? [Scalar.new(1)] : 1
+      end
+    end
+
+    # Diamond/readline operation in scalar or list context.
+    class Readline < Base
+      def initialize(handle)
+        @handle = handle
+      end
+
+      def run(env, context)
+        separator = env.fetch(:scalar, '/').get
+        if context == :list
+          values = []
+          loop do
+            record = read(env, separator)
+            break unless record
+
+            values << Scalar.new(record)
+          end
+          return values
+        end
+
+        read(env, separator)
+      end
+
+      private
+
+      def read(env, separator)
+        return env.runtime.read_argv(separator) if @handle.empty?
+
+        handle = resolve(env)
+        value = handle.read_record(separator)
+        env.runtime.note_input(handle) if value
+        value
+      end
+
+      def resolve(env)
+        return env.runtime.stash.glob('STDIN').io if @handle.nil? || @handle.empty?
+
+        if @handle.start_with?('$')
+          value = env.fetch(:scalar, @handle.delete_prefix('$')).get
+          return value if value.is_a?(IOHandle)
+          return value.target.io if value.is_a?(Ref) && value.target.is_a?(Glob)
+        end
+        lexical = env.fetch(:scalar, @handle).get
+        return lexical if lexical.is_a?(IOHandle)
+
+        env.runtime.stash.glob(@handle).io || raise(PerlError, "readline() on closed filehandle #{@handle}")
+      end
+    end
+
+    # Perl's readline-in-while shorthand assigns $_ and tests definedness.
+    class ReadlineCondition < Base
+      def initialize(readline)
+        @readline = readline
+      end
+
+      def run(env, context)
+        value = @readline.run(env, :scalar)
+        env.fetch(:scalar, '_').set(value)
+        result = value.nil? ? '' : 1
+        context == :list ? [Scalar.new(result)] : result
+      end
+    end
+  end
+end

data/lib/peruby/op/list.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Peruby
+  module Op
+    # Perl comma list with context-dependent evaluation.
+    class List < Base
+      def initialize(items)
+        @items = items
+      end
+
+      def run(env, context)
+        return @items.flat_map { |item| item.run(env, :list) } if context == :list
+        return nil if @items.empty?
+
+        @items[0...-1].each { |item| item.run(env, :void) }
+        @items.last.run(env, context)
+      end
+
+      def argument_cells(env, prototype = nil)
+        return prototype_cells(env, prototype) unless prototype.nil?
+        return @items.first.argument_cells(env) if @items.length == 1
+
+        @items.flat_map { |item| item.argument_cells(env) }
+      end
+
+      def argument_callable
+        return ->(_env, _prototype = nil) { [] } if @items.empty?
+
+        operations = @items.map(&:to_callable)
+        lambda do |env, prototype = nil|
+          next prototype_cells(env, prototype) if prototype
+
+          operations.flat_map { |operation| operation.call(env, :list) }
+        end
+      end
+
+      def empty? = @items.empty?
+
+      def lvalue(env, _context)
+        @items.flat_map do |item|
+          value = item.lvalue(env, :scalar)
+          value.is_a?(Array) ? value : [value]
+        end
+      end
+
+      private
+
+      def prototype_cells(env, prototype)
+        specs = prototype.delete(';').scan(/\\?[$@%&*+_]/)
+        cells = []
+        @items.each_with_index do |item, index|
+          spec = specs[index]
+          if %w[@ %].include?(spec)
+            cells.concat(@items[index..].flat_map { |rest| rest.argument_cells(env) })
+            break
+          end
+
+          cells << prototype_cell(env, item, spec)
+        end
+        cells
+      end
+
+      def prototype_cell(env, item, spec)
+        return Scalar.new(Ref.new(item.aggregate(env, spec == '\\@' ? :array : :hash))) if %w[\@ \%].include?(spec)
+        return item.argument_cells(env).first if %w[& *].include?(spec)
+
+        cell = item.lvalue(env, :scalar)
+        cell.is_a?(Scalar) ? cell : Scalar.new(item.run(env, :scalar))
+      rescue PerlError
+        Scalar.new(item.run(env, :scalar))
+      end
+    end
+
+    # Anonymous array reference.
+    class ArrayLiteral < Base
+      def initialize(items)
+        @items = items
+      end
+
+      def run(env, context)
+        cells = @items.flat_map { |item| item.run(env, :list) }.map(&:copy)
+        value = Ref.new(PerlArray.new(cells))
+        context == :list ? [Scalar.new(value)] : value
+      end
+    end
+
+    # Anonymous hash reference.
+    class HashLiteral < Base
+      def initialize(items)
+        @items = items
+      end
+
+      def run(env, context)
+        values = @items.flat_map { |item| item.run(env, :list) }
+        hash = PerlHash.new
+        values.each_slice(2) { |key, value| hash.slot(Conv.to_str(key&.get)).set(value&.get) }
+        ref = Ref.new(hash)
+        context == :list ? [Scalar.new(ref)] : ref
+      end
+    end
+  end
+end