peruby 0.1.0

data/lib/peruby/op/variable.rb

@@ -0,0 +1,534 @@
+# frozen_string_literal: true
+
+module Peruby
+  module Op
+    # Variable read and lvalue lookup.
+    class Variable < Base
+      def initialize(sigil, name)
+        @sigil = sigil
+        @name = name
+        @key = [sigil, name].freeze
+        @dynamic_match = (sigil == :scalar && name.match?(/\A(?:\d+|[&`'+])\z/)) ||
+                         (%i[array hash].include?(sigil) && %w[- +].include?(name))
+      end
+
+      def run(env, context)
+        value = lookup(env)
+        result(value, context)
+      end
+
+      def to_callable
+        lookup = lookup_callable
+        lambda do |env, context|
+          value = lookup.call(env)
+          return value.list if context == :list && value.is_a?(PerlHash)
+          return value.list if context == :list && value.is_a?(PerlArray)
+          return value.cells.dup if context == :list && value.respond_to?(:cells)
+          return [value] if context == :list
+          return value.size if @sigil == :array
+          return value.cells.size if @sigil == :hash
+
+          value.value
+        end
+      end
+
+      def scalar_callable
+        lookup = lookup_callable
+        sigil = @sigil
+        lambda do |env|
+          value = lookup.call(env)
+          next value.size if sigil == :array
+          next value.cells.size if sigil == :hash
+
+          value.value
+        end
+      end
+
+      def lvalue_callable = lookup_callable
+
+      def first_cell_callable
+        lookup = lookup_callable
+        ->(env) { (value = lookup.call(env)).respond_to?(:cells) ? value.cells.first : value }
+      end
+
+      def result(value, context)
+        return value.list if context == :list && value.is_a?(PerlHash)
+        return value.list if context == :list && value.is_a?(PerlArray)
+        return value.cells.dup if context == :list && value.respond_to?(:cells)
+        return [value] if context == :list
+        return value.size if @sigil == :array
+        return value.cells.size if @sigil == :hash
+
+        value.get
+      end
+
+      def lvalue(env, context)
+        value = lookup(env)
+        context == :list && value.respond_to?(:cells) ? value.cells : value
+      end
+
+      def argument_cells(env)
+        value = lookup(env)
+        return value.list if value.is_a?(PerlHash)
+
+        return value.list if value.is_a?(PerlArray)
+
+        value.respond_to?(:cells) ? value.cells.dup : [value]
+      end
+
+      def first_cell(env)
+        value = lookup(env)
+        value.respond_to?(:cells) ? value.cells.first : value
+      end
+
+      def aggregate_assignment? = %i[array hash].include?(@sigil)
+
+      def localize(env, stack)
+        value = lookup(env)
+        return stack.localize_scalar(value) if @sigil == :scalar
+        return stack.localize_array_value(value) if @sigil == :array
+        return stack.localize_hash_value(value) if @sigil == :hash
+        return stack.localize_entire_glob(value) if @sigil == :glob
+
+        raise PerlError, "Can't localize #{@sigil} variable"
+      end
+
+      def assign_values(env, values)
+        target = lookup(env)
+        if @sigil == :array
+          target.cells.replace(values.map { |value| Scalar.new(value) })
+        else
+          target.cells.clear
+          values.each_slice(2) { |key, value| target.slot(Conv.to_str(key)).set(value) }
+        end
+        target
+      end
+
+      def aggregate(env, kind, dereference: false)
+        return dereference_aggregate(env, kind) if dereference
+
+        kind == @sigil ? lookup(env) : env.fetch(kind, @name)
+      end
+
+      def aggregate_callable(kind, dereference: false)
+        return ->(env) { aggregate(env, kind, dereference:) } if dereference || kind != @sigil
+
+        lookup_callable
+      end
+
+      private
+
+      def lookup_callable
+        key = @key
+        return ->(env) { env.fetch_key(key) } if @dynamic_match
+
+        cached_env = cached_generation = cached_value = nil
+        lambda do |env|
+          generation = env.generation
+          unless cached_env.equal?(env) && cached_generation == generation
+            cached_env = env
+            cached_generation = generation
+            cached_value = env.fetch_key(key)
+          end
+          cached_value
+        end
+      end
+
+      def lookup(env)
+        return env.fetch_key(@key) if @dynamic_match
+        return @cached_value if @cached_env.equal?(env) && @cached_generation == env.generation
+
+        @cached_env = env
+        @cached_generation = env.generation
+        @cached_value = env.fetch_key(@key)
+      end
+
+      def dereference_aggregate(env, kind)
+        expected = kind == :array ? PerlArray : PerlHash
+        cell = lookup(env)
+        cell.set(Ref.new(expected.new)) if cell.is_a?(Scalar) && cell.get.nil?
+        value = cell.is_a?(Scalar) ? cell.get : cell
+        raise PerlError, "Not a #{kind.to_s.upcase} reference" unless value.is_a?(Ref) && value.target.is_a?(expected)
+
+        value.target
+      end
+    end
+
+    # Explicit scalar/array/hash/code dereference.
+    class Dereference < Base
+      def initialize(kind, name)
+        @kind = kind
+        @name = name
+      end
+
+      def run(env, context)
+        value = target(env)
+        return value.get if @kind == :scalar && context != :list
+        return [value] if @kind == :scalar
+        return value.list if context == :list && value.is_a?(PerlHash)
+        return value.list if context == :list && value.is_a?(PerlArray)
+        return value.cells.dup if context == :list && value.respond_to?(:cells)
+        return value.size if value.respond_to?(:size)
+
+        value
+      end
+
+      def lvalue(env, _context)
+        target(env)
+      end
+
+      def aggregate(env, kind, dereference: false)
+        raise PerlError, 'Invalid nested dereference' if dereference
+
+        value = @kind == :scalar ? referenced_target(env) : target(env)
+        expected = kind == :array ? PerlArray : PerlHash
+        raise PerlError, "Not a #{kind.to_s.upcase} reference" unless value.is_a?(expected)
+
+        value
+      end
+
+      private
+
+      def target(env)
+        target = referenced_target(env)
+        expected = { scalar: Scalar, array: PerlArray, hash: PerlHash, code: Code }.fetch(@kind)
+        raise PerlError, "Not a #{@kind.to_s.upcase} reference" unless target.is_a?(expected)
+
+        target
+      end
+
+      def referenced_target(env)
+        value = env.fetch(:scalar, @name).get
+        return value.target if value.is_a?(Ref)
+        return symbolic_target(env, value) if value.is_a?(String)
+
+        raise PerlError, 'Not a reference'
+      end
+
+      def symbolic_target(env, name)
+        raise PerlError, "Can't use string (#{name}) as a reference while strict refs in use" if env.strict_refs?
+
+        env.fetch(@kind, name)
+      end
+    end
+
+    # Dereference whose operand is an arbitrary expression, such as @{$h{list}}.
+    class DereferenceExpression < Base
+      def initialize(kind, expression)
+        @kind = kind
+        @expression = expression
+      end
+
+      def run(env, context)
+        value = target(env)
+        return value.get if @kind == :scalar && context != :list
+        return [value] if @kind == :scalar
+        return value.list if context == :list && value.is_a?(PerlHash)
+        return value.list if context == :list && value.is_a?(PerlArray)
+        return value.cells.dup if context == :list && value.respond_to?(:cells)
+        return value.size if value.respond_to?(:size)
+
+        value
+      end
+
+      def lvalue(env, _context)
+        target(env)
+      end
+
+      def aggregate(env, kind, dereference: false)
+        raise PerlError, 'Invalid nested dereference' if dereference
+
+        value = target(env)
+        expected = kind == :array ? PerlArray : PerlHash
+        raise PerlError, "Not a #{kind.to_s.upcase} reference" unless value.is_a?(expected)
+
+        value
+      end
+
+      private
+
+      def target(env)
+        expected = { scalar: Scalar, array: PerlArray, hash: PerlHash, code: Code }.fetch(@kind)
+        cell = begin
+          @expression.lvalue(env, :scalar)
+        rescue PerlError
+          nil
+        end
+        cell.set(Ref.new(expected.new)) if cell && cell.get.nil? && %i[array hash].include?(@kind)
+        value = cell ? cell.get : @expression.run(env, :scalar)
+
+        resolve_target(env, value, expected)
+      end
+
+      def resolve_target(env, value, expected)
+        target = value.target if value.is_a?(Ref)
+        if value.is_a?(String)
+          raise PerlError, "Can't use string (#{value}) as a reference while strict refs in use" if env.strict_refs?
+
+          target = env.fetch(@kind, value)
+        end
+        raise PerlError, 'Not a reference' unless target.is_a?(expected)
+
+        target
+      end
+    end
+
+    # Lexical variable declaration.
+    class Declare < Base
+      def initialize(sigil, name, initializer, predeclared = nil)
+        @sigil = sigil
+        @name = name
+        @initializer = initializer
+        @predeclared = predeclared
+      end
+
+      def run(env, context)
+        values = @initializer&.run(env, @sigil == :scalar ? :scalar : :list)
+        target = declaration_target(env)
+        assign(target, values) if @initializer
+        return Array(target.respond_to?(:cells) ? target.cells : target) if context == :list
+
+        declaration_value(target)
+      end
+
+      def to_callable
+        initializer = @initializer&.to_callable
+        scalar_initializer = @initializer.scalar_callable if @initializer.respond_to?(:scalar_callable)
+        lambda do |env, context|
+          values = if @sigil == :scalar && scalar_initializer
+                     scalar_initializer.call(env)
+                   else
+                     initializer&.call(env, @sigil == :scalar ? :scalar : :list)
+                   end
+          target = declaration_target(env)
+          assign(target, values) if initializer
+          next Array(target.respond_to?(:cells) ? target.cells : target) if context == :list
+
+          declaration_value(target)
+        end
+      end
+
+      def lvalue(env, _context)
+        env.fetch(@sigil, @name)
+      end
+
+      private
+
+      def declaration_target(env)
+        return env.declare(@sigil, @name) unless @predeclared
+
+        env.bind(@sigil, @name, @predeclared).tap { @predeclared = nil }
+      end
+
+      def assign(target, values)
+        return target.set(values) if target.is_a?(Scalar)
+        return target.cells.replace(values.map(&:copy)) if target.is_a?(PerlArray)
+
+        target.cells.clear
+        values.each_slice(2) { |key, value| target.slot(Conv.to_str(key&.get)).set(value&.get) }
+      end
+
+      def declaration_value(target)
+        target.is_a?(Scalar) ? target.get : target.cells.size
+      end
+    end
+
+    # Persistent lexical declaration, scoped independently for each closure.
+    class State < Base
+      def initialize(sigil, name, initializer, predeclared = nil)
+        @sigil = sigil
+        @name = name
+        @initializer = initializer
+        @predeclared = predeclared
+        @values = ObjectSpace::WeakMap.new
+      end
+
+      def run(env, context)
+        owner = env.state_owner || env.runtime
+        value = @values[owner]
+        unless value
+          value = initial_value(owner)
+          initialize_value(value, env)
+          @values[owner] = value
+        end
+        env.bind(@sigil, @name, value)
+        return Array(value.respond_to?(:cells) ? value.cells : value) if context == :list
+
+        scalar_value(value)
+      end
+
+      private
+
+      def initial_value(owner)
+        value = @predeclared
+        @predeclared = nil
+        # perlsub: cloned anonymous closures do not retain the compile-time state pad.
+        return value if value && (!owner.is_a?(Code) || owner.name)
+
+        empty_value
+      end
+
+      def empty_value
+        { scalar: -> { Scalar.new }, array: -> { PerlArray.new }, hash: -> { PerlHash.new } }.fetch(@sigil).call
+      end
+
+      def initialize_value(target, env)
+        return unless @initializer
+
+        values = @initializer.run(env, @sigil == :scalar ? :scalar : :list)
+        return target.set(values) if target.is_a?(Scalar)
+        return target.cells.replace(values.map(&:copy)) if target.is_a?(PerlArray)
+
+        target.cells.clear
+        values.each_slice(2) { |key, value| target.slot(Conv.to_str(key&.get)).set(value&.get) }
+      end
+
+      def scalar_value(value)
+        value.is_a?(Scalar) ? value.get : value.cells.size
+      end
+    end
+
+    # Destructuring lexical declaration.
+    class DeclareList < Base
+      def initialize(variables, initializer, predeclared = nil)
+        @variables = variables
+        @initializer = initializer
+        @predeclared = predeclared
+      end
+
+      # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def run(env, context)
+        return declare_scalar(env, context) if @variables.length == 1 && @variables.first.first == :scalar &&
+                                               @initializer.respond_to?(:first_cell)
+
+        values = @initializer&.run(env, :list) || []
+        targets = declaration_targets(env)
+        return context == :list ? targets : 0 unless @initializer
+
+        index = 0
+        targets.each do |target|
+          if target.is_a?(Scalar)
+            target.set(values[index]&.get)
+            index += 1
+          elsif target.is_a?(PerlArray)
+            target.cells.replace(values.drop(index).map(&:copy))
+            index = values.length
+          else
+            target.cells.clear
+            values.drop(index).each_slice(2) do |key, value|
+              target.slot(Conv.to_str(key&.get)).set(value&.get)
+            end
+            index = values.length
+          end
+        end
+        context == :list ? targets : values.size
+      end
+
+      def to_callable
+        return scalar_declaration_callable if @variables.length == 1 && @variables.first.first == :scalar &&
+                                              @initializer.respond_to?(:first_cell_callable)
+
+        initializer = @initializer&.to_callable
+        lambda do |env, context|
+          values = initializer ? initializer.call(env, :list) : []
+          declare_values(env, context, values)
+        end
+      end
+
+      private
+
+      def scalar_declaration_callable
+        source = @initializer.first_cell_callable
+        lambda do |env, context|
+          target = declaration_targets(env).first
+          target.set(source.call(env)&.value)
+          context == :list ? [target] : 1
+        end
+      end
+
+      def declare_values(env, context, values)
+        targets = declaration_targets(env)
+        return context == :list ? targets : 0 unless @initializer
+
+        index = 0
+        targets.each do |target|
+          if target.is_a?(Scalar)
+            target.set(values[index]&.value)
+            index += 1
+          elsif target.is_a?(PerlArray)
+            target.cells.replace(values.drop(index).map(&:copy))
+            index = values.length
+          else
+            target.cells.clear
+            values.drop(index).each_slice(2) { |key, value| target.slot(Conv.to_str(key&.value)).set(value&.value) }
+            index = values.length
+          end
+        end
+        context == :list ? targets : values.size
+      end
+
+      def declare_scalar(env, context)
+        source = @initializer.first_cell(env)
+        target = declaration_targets(env).first
+        target.set(source&.get)
+        context == :list ? [target] : 1
+      end
+
+      def declaration_targets(env)
+        return @variables.map { |sigil, name| env.declare(sigil, name) } unless @predeclared
+
+        targets = @variables.zip(@predeclared).map { |(sigil, name), value| env.bind(sigil, name, value) }
+        @predeclared = nil
+        targets
+      end
+    end
+
+    # Package variable declaration through our.
+    class GlobalDeclare < Base
+      def initialize(sigil, name, initializer)
+        @sigil = sigil
+        @name = name
+        @initializer = initializer
+      end
+
+      def run(env, context)
+        target = env.fetch(@sigil, @name)
+        bind_alias(env, target)
+        return target.get unless @initializer
+
+        values = @initializer.run(env, @sigil == :scalar ? :scalar : :list)
+        if target.is_a?(Scalar)
+          target.set(values)
+        elsif target.is_a?(PerlArray)
+          target.cells.replace(values.map(&:copy))
+        else
+          target.cells.clear
+          values.each_slice(2) { |key, value| target.slot(Conv.to_str(key&.get)).set(value&.get) }
+        end
+        context == :list && target.respond_to?(:list) ? target.list : values
+      end
+
+      private
+
+      def bind_alias(env, target)
+        name = @name.rpartition('::').last
+        env.bind(@sigil, name, target) unless name == @name
+      end
+    end
+
+    # Dynamically localizes a package variable or aggregate element.
+    class Local < Base
+      def initialize(target, assignment)
+        @target = target
+        @assignment = assignment
+      end
+
+      def run(env, context)
+        @target.localize(env, env.runtime.local_stack)
+        return @assignment.run(env, context) if @assignment
+
+        nil
+      end
+    end
+  end
+end

data/lib/peruby/op.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Peruby
+  # Executable operation tree.
+  module Op
+    # Base evaluation protocol. Context is one of :scalar, :list, or :void.
+    class Base
+      def run(_env, _context)
+        raise NotImplementedError
+      end
+
+      def lvalue(_env, _context)
+        raise PerlError, "Can't modify #{self.class} in assignment"
+      end
+
+      def local_slot(_env)
+        raise PerlError, "Can't localize #{self.class}"
+      end
+
+      def argument_cells(env)
+        run(env, :list)
+      end
+
+      def to_callable
+        ->(env, context) { run(env, context) }
+      end
+
+      def run_subroutine(env, context)
+        catch(:peruby_return) { run(env, context) }
+      end
+
+      def warning_directive? = false
+    end
+
+    # Lambda-composed executable with the original tree retained for fallback.
+    class Compiled < Base
+      def initialize(callable, subroutine = nil)
+        super()
+        @callable = callable
+        @subroutine = subroutine || ->(env, context) { catch(:peruby_return) { @callable.call(env, context) } }
+      end
+
+      def run(env, context) = @callable.call(env, context)
+      def run_subroutine(env, context) = @subroutine.call(env, context)
+    end
+  end
+end