peruby 0.1.0

data/lib/peruby/op/literal.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Peruby
+  module Op
+    # Constant scalar or quote-like value.
+    class Literal < Base
+      def initialize(value)
+        @value = value
+      end
+
+      def run(env, context)
+        value = if @value.is_a?(Lexer::Quote) && @value.operator == :backtick
+                  command = Interpolation.expand(@value, env)
+                  output = IO.popen(command, &:read)
+                  env.fetch(:scalar, '?').set($?.to_i) # rubocop:disable Style/SpecialGlobalVars
+                  output
+                elsif @value.is_a?(Lexer::Heredoc)
+                  quote = Lexer::Quote.new(operator: :heredoc, parts: [@value.body], modifiers: '',
+                                           interpolate: @value.interpolate)
+                  Interpolation.expand(quote, env)
+                elsif @value.is_a?(Lexer::Quote)
+                  Interpolation.expand(@value, env)
+                else
+                  @value
+                end
+        context == :list ? [Scalar.new(value)] : value
+      end
+
+      def to_callable
+        return super if @value.is_a?(Lexer::Quote) && @value.operator == :backtick
+        return super if @value.is_a?(Lexer::Heredoc)
+        return interpolated_callable if @value.is_a?(Lexer::Quote) && simple_interpolation?
+        return super if @value.is_a?(Lexer::Quote)
+
+        value = @value
+        ->(_env, context) { context == :list ? [Scalar.new(value)] : value }
+      end
+
+      def scalar_callable
+        return ->(_env) { @value } unless @value.is_a?(Lexer::Quote) || @value.is_a?(Lexer::Heredoc)
+        return if @value.is_a?(Lexer::Heredoc) || @value.operator == :backtick
+        return unless @value.is_a?(Lexer::Quote) && simple_interpolation?
+
+        callable = interpolated_callable
+        ->(env) { callable.call(env, :scalar) }
+      end
+
+      private
+
+      def simple_interpolation?
+        source = @value.parts.first
+        complex = source.include?('$$') || source.include?('$#') || source.match?(/[$@](?:\{|\w+(?:->)?[\[{])/)
+        @value.interpolate && !source.include?('\\') && !complex
+      end
+
+      def interpolated_callable
+        parts = interpolation_parts(@value.parts.first)
+        lambda do |env, context|
+          value = parts.each_with_object(+'') do |part, output|
+            if part.is_a?(String)
+              output << part
+            else
+              sigil, name = part
+              output << Interpolation.interpolate(env.fetch(sigil, name), sigil, env)
+            end
+          end
+          context == :list ? [Scalar.new(value)] : value
+        end
+      end
+
+      def interpolation_parts(source)
+        parts = []
+        offset = 0
+        while (match = Interpolation.variable_pattern.match(source, offset))
+          parts << source[offset...match.begin(0)] unless match.begin(0) == offset
+          parts << [match[1] == '$' ? :scalar : :array, match[2] || match[3]]
+          offset = match.end(0)
+        end
+        parts << source[offset..] if offset < source.length
+        parts
+      end
+    end
+  end
+end

data/lib/peruby/op/loop.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module Peruby
+  module Op
+    # Non-local loop control, optionally targeting a label.
+    class LoopJump < Base
+      def initialize(kind, label)
+        @kind = kind
+        @label = label
+      end
+
+      def run(_env, _context) = raise LoopControl.new(@kind, @label)
+    end
+
+    # C-style for loop.
+    class CFor < Base
+      include LoopExecution
+
+      def initialize(initializer, condition, step, body, continuation, label) # rubocop:disable Metrics/ParameterLists
+        @initializer = initializer
+        @condition = condition
+        @step = step
+        @body = body
+        @continue = continuation
+        @label = label
+      end
+
+      def run(env, _context)
+        env.with_scope do
+          @initializer&.run(env, :void)
+          while @condition.nil? || Conv.truthy?(@condition.run(env, :scalar))
+            break unless run_iteration?(env)
+
+            @step&.run(env, :void)
+          end
+        end
+        nil
+      end
+    end
+
+    # Stable Perl sort with optional block or named comparator.
+    class Sort < Base
+      def initialize(comparator, list, package)
+        @comparator = comparator
+        @list = list
+        @package = package
+      end
+
+      def run(env, context)
+        values = @list.run(env, :list)
+        sorted = values.each_with_index.sort do |(left, left_index), (right, right_index)|
+          comparison = compare(left, right, env)
+          comparison.zero? ? left_index <=> right_index : comparison
+        end.map(&:first)
+        context == :list ? sorted : nil
+      end
+
+      private
+
+      # rubocop:disable-next Metrics/AbcSize
+      def compare(left, right, env)
+        return Conv.to_str(left.get) <=> Conv.to_str(right.get) unless @comparator
+
+        a = env.runtime.stash.glob("#{@package}::a").scalar
+        b = env.runtime.stash.glob("#{@package}::b").scalar
+        previous = [a.get, b.get]
+        a.set(left.get)
+        b.set(right.get)
+        result = if @comparator.is_a?(String)
+                   code = env.runtime.stash.glob(@comparator).code
+                   raise PerlError, "Undefined sort subroutine #{@comparator}" unless code
+
+                   env.runtime.call(code, [], :scalar)
+                 else
+                   @comparator.run(env, :scalar)
+                 end
+        Conv.to_num(result).to_i
+      ensure
+        a&.set(previous&.first)
+        b&.set(previous&.last)
+      end
+    end
+
+    # Foreach loop with a fresh aliased lexical scalar each iteration.
+    class ForEach < Base
+      include LoopExecution
+
+      def initialize(sigil, name, list, body, continuation = nil, label = nil) # rubocop:disable Metrics/ParameterLists
+        @sigil = sigil
+        @name = name
+        @list = list
+        @body = body
+        @continue = continuation
+        @label = label
+      end
+
+      def run(env, _context)
+        @list.run(env, :list).each do |cell|
+          keep_going = true
+          env.with_scope do
+            env.bind(@sigil, @name, cell)
+            keep_going = run_iteration?(env)
+          end
+          break unless keep_going
+        end
+        nil
+      end
+    end
+
+    # Statement modifier: EXPR for LIST, with $_ aliased to each source cell.
+    class ModifierFor < Base
+      include LoopExecution
+
+      def initialize(expression, list)
+        @expression = expression
+        @body = expression
+        @list = list
+        @label = nil
+      end
+
+      def run(env, _context)
+        @list.run(env, :list).each do |cell|
+          keep_going = true
+          env.with_scope do
+            env.bind(:scalar, '_', cell)
+            keep_going = run_iteration?(env)
+          end
+          break unless keep_going
+        end
+        nil
+      end
+    end
+
+    # map/grep block with $_ aliasing.
+    class Map < Base
+      def initialize(body, list, grep)
+        @body = body
+        @list = list
+        @grep = grep
+      end
+
+      def run(env, context)
+        values = @list.run(env, :list).flat_map do |cell|
+          result = env.with_scope do
+            env.bind(:scalar, '_', cell)
+            @body.run(env, @grep ? :scalar : :list)
+          end
+          if @grep
+            Conv.truthy?(result) ? [cell] : []
+          else
+            Array(result)
+          end
+        end
+        context == :list ? values : values.length
+      end
+    end
+  end
+end

data/lib/peruby/op/regexp.rb

@@ -0,0 +1,288 @@
+# frozen_string_literal: true
+
+module Peruby
+  module Op
+    # Regexp match, using $_ when no explicit binding subject exists.
+    class Match < Base
+      def initialize(quote)
+        @quote = quote
+        return unless quote
+
+        source = quote.parts.first
+        @regexp = RegexpCompiler.compile(source, quote.modifiers) unless source.match?(Interpolation.variable_pattern)
+      end
+
+      def run(env, context)
+        match_on(env.fetch(:scalar, '_'), env, context)
+      end
+
+      def match_on(cell, env, context)
+        regexp = @regexp || RegexpCompiler.compile(Interpolation.pattern(@quote, env), @quote.modifiers)
+        match_regexp(regexp, cell, env, context, global: @quote.modifiers.include?('g'))
+      end
+
+      def match_regexp(regexp, cell, env, context, global: false)
+        return global(regexp, cell, env, context) if global
+
+        match = regexp.match(Conv.to_str(cell.get))
+        env.runtime.match!(match, Conv.to_str(cell.get)) if match
+        result(match, context)
+      end
+
+      def match_callable
+        return if !@regexp || @quote.modifiers.include?('g')
+
+        regexp = @regexp
+        lambda do |value, env, context|
+          subject = value
+          subject = Conv.to_str(subject) unless subject.is_a?(String)
+          match = regexp.match(subject)
+          env.runtime.match!(match, subject) if match
+          next match ? 1 : '' unless context == :list
+
+          values = if match
+                     match.captures.empty? ? [1] : match.captures
+                   else
+                     []
+                   end
+          values.map { |value| Scalar.new(value) }
+        end
+      end
+
+      private
+
+      def global(regexp, cell, env, context)
+        return global_list(regexp, cell, env) if context == :list
+
+        subject = Conv.to_str(cell.get)
+        match = regexp.match(subject, cell.pos || 0)
+        unless match
+          cell.pos = nil
+          return ''
+        end
+        env.runtime.match!(match, subject)
+        cell.pos = next_position(match, subject)
+        1
+      end
+
+      def global_list(regexp, cell, env)
+        subject = Conv.to_str(cell.get)
+        matches = []
+        position = 0
+        while (match = regexp.match(subject, position))
+          env.runtime.match!(match, subject)
+          values = match.captures.empty? ? [match[0]] : match.captures
+          matches.concat(values.map { |value| Scalar.new(value) })
+          position = next_position(match, subject)
+        end
+        matches
+      end
+
+      def next_position(match, subject)
+        return match.end(0) unless match.begin(0) == match.end(0)
+
+        [match.end(0) + 1, subject.length + 1].min
+      end
+
+      def result(match, context)
+        return match ? 1 : '' unless context == :list
+        return [] unless match
+
+        values = match.captures.empty? ? [1] : match.captures
+        values.map { |value| Scalar.new(value) }
+      end
+    end
+
+    # Explicit =~ or !~ binding.
+    class Bind < Base
+      def initialize(subject, pattern, negated)
+        @subject = subject
+        @pattern = pattern
+        @negated = negated
+      end
+
+      def run(env, context)
+        bind(env, context) { @subject.run(env, :scalar) }
+      end
+
+      def to_callable
+        subject = @subject.to_callable
+        scalar_subject = @subject.scalar_callable if @subject.respond_to?(:scalar_callable)
+        lvalue = @subject.lvalue_callable if @subject.respond_to?(:lvalue_callable)
+        match = @pattern.match_callable if !@negated && @pattern.respond_to?(:match_callable)
+        lambda do |env, context|
+          value = scalar_subject ? scalar_subject.call(env) : subject.call(env, :scalar)
+          cell = lvalue&.call(env)
+          next match.call(cell ? cell.value : value, env, context) if match
+
+          apply_bound(cell || Scalar.new(value), env, context)
+        end
+      end
+
+      private
+
+      def apply_bound(cell, env, context)
+        result = apply(cell, env, @negated ? :scalar : context)
+        return result unless @negated
+
+        value = Conv.truthy?(result) ? '' : 1
+        context == :list ? [Scalar.new(value)] : value
+      end
+
+      def bind(env, context)
+        cell = begin
+          @subject.lvalue(env, :scalar)
+        rescue PerlError
+          raise if @pattern.respond_to?(:lvalue_required?) && @pattern.lvalue_required?
+
+          Scalar.new(yield)
+        end
+        result = apply(cell, env, @negated ? :scalar : context)
+        return result unless @negated
+
+        value = Conv.truthy?(result) ? '' : 1
+        context == :list ? [Scalar.new(value)] : value
+      end
+
+      def apply(cell, env, context)
+        return @pattern.apply_to(cell, env, context) if @pattern.respond_to?(:apply_to)
+        return @pattern.match_on(cell, env, context) if @pattern.respond_to?(:match_on)
+
+        value = @pattern.run(env, :scalar)
+        regexp = value.is_a?(Ref) ? value.target : value
+        raise PerlError, 'Not a Regexp reference' unless regexp.is_a?(::Regexp)
+
+        Match.new(nil).match_regexp(regexp, cell, env, context)
+      end
+    end
+
+    # Compiled qr// value.
+    class RegexpLiteral < Base
+      def initialize(quote)
+        @quote = quote
+      end
+
+      def run(env, context)
+        value = Ref.new(RegexpCompiler.compile(Interpolation.pattern(@quote, env), @quote.modifiers))
+        context == :list ? [Scalar.new(value)] : value
+      end
+
+      def match_on(cell, env, context)
+        Match.new(@quote).match_on(cell, env, context)
+      end
+    end
+
+    # Perl s/// substitution, destructive unless /r is present.
+    class Substitute < Base
+      def initialize(quote)
+        @quote = quote
+      end
+
+      def run(env, context)
+        apply_to(env.fetch(:scalar, '_'), env, context)
+      end
+
+      def lvalue_required? = !@quote.modifiers.include?('r')
+
+      def apply_to(cell, env, context)
+        subject = Conv.to_str(cell.get)
+        regexp = RegexpCompiler.compile(Interpolation.pattern(@quote, env), @quote.modifiers)
+        count = 0
+        replace = @quote.modifiers.include?('g') ? :gsub : :sub
+        result = subject.public_send(replace, regexp) do
+          count += 1
+          env.runtime.match!(Regexp.last_match, subject)
+          replacement(env)
+        end
+        value = if @quote.modifiers.include?('r')
+                  result
+                else
+                  cell.set(result)
+                  count.zero? ? '' : count
+                end
+        context == :list ? [Scalar.new(value)] : value
+      end
+
+      private
+
+      def replacement(env)
+        source = @quote.parts[1]
+        return evaluate(source, env) if @quote.modifiers.include?('e')
+
+        quote = Lexer::Quote.new(operator: :qq, parts: [source], modifiers: '', interpolate: true)
+        Interpolation.expand(quote, env)
+      end
+
+      def evaluate(source, env)
+        value = Compiler.new.compile(Parser.parse("#{source};", package: env.package)).run(env, :scalar)
+        return Conv.to_str(value) unless @quote.modifiers.scan('e').length > 1
+
+        tree = Parser.parse("#{Conv.to_str(value)};", package: env.package)
+        Conv.to_str(Compiler.new.compile(tree).run(env, :scalar))
+      end
+    end
+
+    # Perl tr/// and y/// character translation.
+    class Transliterate < Base
+      def initialize(quote)
+        @quote = quote
+      end
+
+      def run(env, context)
+        apply_to(env.fetch(:scalar, '_'), env, context)
+      end
+
+      def lvalue_required? = !@quote.modifiers.include?('r')
+
+      def apply_to(cell, _env, context)
+        source, replacement = @quote.parts
+        subject = Conv.to_str(cell.get)
+        search = @quote.modifiers.include?('c') ? "^#{source}" : source
+        count = subject.count(search)
+        result = translate(subject, search, replacement)
+        value = @quote.modifiers.include?('r') ? result : (cell.set(result) && count)
+        context == :list ? [Scalar.new(value)] : value
+      end
+
+      private
+
+      def translate(subject, search, replacement)
+        return subject if replacement.empty? && !@quote.modifiers.include?('d')
+        return subject.delete(search) if replacement.empty?
+
+        @quote.modifiers.include?('s') ? subject.tr_s(search, replacement) : subject.tr(search, replacement)
+      end
+    end
+
+    # Perl split, including its special single-space pattern.
+    class Split < Base
+      def initialize(arguments)
+        @arguments = arguments
+      end
+
+      def run(env, context)
+        pattern = @arguments[0]&.run(env, :scalar) || ' '
+        subject = @arguments[1]&.run(env, :scalar) || env.fetch(:scalar, '_').get
+        limit = @arguments[2]&.run(env, :scalar)
+        values = split(Conv.to_str(subject), pattern, limit)
+        return values.length unless context == :list
+
+        values.map { |value| Scalar.new(value) }
+      end
+
+      private
+
+      def split(subject, pattern, limit)
+        pattern = pattern.target if pattern.is_a?(Ref)
+        return subject.strip.split(/\s+/, split_limit(limit)) if pattern == ' '
+        return subject.split('', split_limit(limit)) if pattern == ''
+
+        subject.split(pattern, split_limit(limit))
+      end
+
+      def split_limit(limit)
+        limit.nil? ? 0 : Conv.to_num(limit).to_i
+      end
+    end
+  end
+end