peruby 0.1.0

data/lib/peruby/runtime/test_builder.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Peruby
+  # Minimal TAP producer shared by Test::More and Test::Simple.
+  class TestBuilder
+    Context = Struct.new(:tests_run, :planned, :indent)
+
+    def initialize(output)
+      @output = output
+      @contexts = [Context.new(0, nil, '')]
+    end
+
+    def plan(count)
+      current.planned = count.to_i
+      @output.puts "#{current.indent}1..#{current.planned}"
+      1
+    end
+
+    def ok(success, name = '')
+      current.tests_run += 1
+      label = name.to_s.empty? ? '' : " - #{name}"
+      @output.puts "#{current.indent}#{success ? 'ok' : 'not ok'} #{current.tests_run}#{label}"
+      success ? 1 : ''
+    end
+
+    def done_testing
+      @output.puts "#{current.indent}1..#{current.tests_run}" unless current.planned
+      1
+    end
+
+    def subtest(name)
+      @output.puts "#{current.indent}# Subtest: #{name}"
+      @contexts << Context.new(0, nil, "#{current.indent}    ")
+      yield
+      done_testing
+      @contexts.pop
+      ok(true, name)
+    rescue StandardError
+      @contexts.pop if @contexts.length > 1
+      ok(false, name)
+    end
+
+    private
+
+    def current = @contexts.last
+  end
+end

data/lib/peruby/runtime.rb

@@ -0,0 +1,325 @@
+# frozen_string_literal: true
+
+require_relative 'runtime/env'
+require_relative 'runtime/interpolation'
+require_relative 'runtime/code'
+
+module Peruby
+  # Process-wide interpreter state.
+  class Runtime # rubocop:disable Metrics/ClassLength
+    attr_reader :stash, :stdout, :stderr, :match_state, :mro, :module_loader, :test_builder, :current_file,
+                :local_stack,
+                :file_stat_path, :last_input_handle
+
+    # rubocop:disable-next Metrics/AbcSize, Metrics/MethodLength
+    def initialize(stdin: $stdin, stdout: $stdout, stderr: $stderr, refcount: false)
+      @stash = Stash.new
+      @stdout = stdout
+      @stderr = stderr
+      @match_state = MatchState.new
+      @local_stack = LocalStack.new
+      @mro = MRO.new(@stash)
+      @refcount = refcount
+      @objects = {}.compare_by_identity
+      @destroyed = {}.compare_by_identity
+      @module_loader = ModuleLoader.new(self)
+      @test_builder = TestBuilder.new(stdout)
+      @current_file = '-e'
+      @phases = Hash.new { |phases, name| phases[name] = [] }
+      @overloads = {}
+      @warnings = Set.new
+      @warning_switch = @stash.glob('^W').scalar
+      @stash.glob('$').scalar.set(Process.pid)
+      @stash.glob('SIG').hash = PerlHash.new { |name, value| install_signal(name, value) }
+      env_cells = ENV.to_h { |name, value| [name, Scalar.new(value)] }
+      @stash.glob('ENV').hash = PerlHash.new(env_cells) { |name, value| update_environment(name, value) }
+      @stash.glob('"').scalar.set(' ')
+      @stash.glob(',').scalar.set(nil)
+      @stash.glob('\\').scalar.set(nil)
+      @stash.glob('/').scalar.set("\n")
+      @stdin_handle = IOHandle.new(stdin)
+      @stash.glob('STDIN').io = @stdin_handle
+      @stash.glob('STDOUT').io = IOHandle.new(stdout)
+      @stash.glob('STDERR').io = IOHandle.new(stderr)
+      @stash.glob('ARGVOUT').io = IOHandle.new(stdout)
+      @selected_output = @stash.glob('STDOUT').io
+      @stash.glob('|').scalar = Scalar.new { |value| @selected_output.io.sync = Conv.truthy?(value) }
+      @stash.glob('INC').array.cells << Scalar.new('.')
+    end
+
+    def env
+      Env.new(self)
+    end
+
+    def output(handle, env = nil)
+      return @selected_output.io unless handle
+
+      if env && handle
+        lexical = env.fetch(:scalar, handle).get
+        return lexical.io if lexical.is_a?(IOHandle)
+      end
+      @stash.glob(handle).io&.io || (handle == 'STDERR' ? @stderr : @stdout)
+    end
+
+    def select_output(handle = nil)
+      previous = @selected_output
+      @selected_output = handle if handle
+      previous
+    end
+
+    def read_argv(separator)
+      loop do
+        open_next_argv unless @argv_handle || @argv_finished
+        return nil unless @argv_handle
+
+        value = @argv_handle.read_record(separator)
+        if value
+          @last_input_handle = @argv_handle
+          @argv_lineno = (@argv_lineno || 0) + 1
+          @stash.glob('.').scalar.set(@argv_lineno)
+          return value
+        end
+        @argv_handle.close unless @argv_handle.equal?(@stdin_handle)
+        @argv_handle = nil
+      end
+    end
+
+    def note_input(handle)
+      @last_input_handle = handle
+      @stash.glob('.').scalar.set(handle.lineno)
+    end
+
+    def match!(match, subject)
+      @match_state = MatchState.new(match, subject)
+    end
+
+    def with_match_scope
+      previous = @match_state
+      yield
+    ensure
+      @match_state = previous
+    end
+
+    def with_file(file)
+      previous = @current_file
+      @current_file = file
+      yield
+    ensure
+      @current_file = previous
+    end
+
+    def error_message(message, file: @current_file, line: 1)
+      message.end_with?("\n") ? message : "#{message} at #{file} line #{line}.\n"
+    end
+
+    def die(values, file: @current_file, line: 1)
+      object = values.one? && values.first.is_a?(Ref) ? values.first : nil
+      text = values.map { |value| Conv.to_str(value) }.join
+      message = object ? Conv.to_str(object) : error_message(text, file:, line:)
+      handler = @stash.glob('SIG').hash.fetch('__DIE__')
+      handler = handler.target if handler.is_a?(Ref) && handler.kind == 'CODE'
+      previous = @handling_die
+      @handling_die = true
+      call(handler, [Scalar.new(object || message)], :void) if handler.is_a?(Code) && !previous
+      raise PerlError.new(message, value: object || message, formatted: true)
+    ensure
+      @handling_die = previous
+    end
+
+    def call(code, arguments, context)
+      return call_compiled(code, arguments, context) if code.body.is_a?(Op::Compiled)
+
+      validate_prototype(code, arguments.length)
+      with_match_scope do
+        @local_stack.within do
+          loop do
+            env = code.environment.fork(want: context, package: code.package, state_owner: code)
+            env.bind(:array, '_', PerlArray.new(arguments))
+            result = code.body.run_subroutine(env, context)
+            if result.is_a?(GotoRequest)
+              code = result.code
+              next
+            end
+            return context == :list ? Array(result).map(&:copy) : result
+          end
+        end
+      end
+    end
+
+    def call_compiled(code, arguments, context)
+      validate_prototype(code, arguments.length) if code.prototype
+      previous_match = @match_state
+      @local_stack.within do
+        loop do
+          env = code.environment.call_frame(arguments, want: context, package: code.package, state_owner: code)
+          result = code.body.run_subroutine(env, context)
+          if result.is_a?(GotoRequest)
+            code = result.code
+            next
+          end
+          return context == :list ? Array(result).map(&:copy) : result
+        end
+      end
+    ensure
+      @match_state = previous_match
+    end
+
+    def validate_prototype(code, count)
+      prototype = code.prototype
+      return if prototype.nil?
+
+      required, _, optional = prototype.partition(';')
+      minimum = prototype_arity(required.delete_suffix('@').delete_suffix('%'))
+      maximum = required.match?(/[@%]\z/) ? nil : minimum + prototype_arity(optional)
+      return if count >= minimum && (maximum.nil? || count <= maximum)
+
+      raise PerlError, "Wrong number of arguments for #{code.name || 'anonymous subroutine'}"
+    end
+
+    def prototype_arity(prototype)
+      prototype.scan(/\\?[$@%&*+_]/).length
+    end
+
+    def with_warning_scope
+      previous = @warnings.dup
+      yield
+    ensure
+      @warnings = previous
+    end
+
+    def configure_warnings(categories, disable: false)
+      selected = categories.empty? ? %w[uninitialized numeric once redefine] : categories
+      disable ? @warnings.subtract(selected) : @warnings.merge(selected)
+    end
+
+    def warning_enabled?(category)
+      @warnings.include?(category) || Conv.truthy?(@warning_switch.get)
+    end
+
+    def warnings_active?
+      !@warnings.empty? || Conv.truthy?(@warning_switch.get)
+    end
+
+    def warning_categories = @warnings.dup
+
+    def warning(category, message)
+      return unless warning_enabled?(category)
+
+      emit_warning(message)
+    end
+
+    def emit_warning(message, file: @current_file, line: 1)
+      formatted = error_message(message, file:, line:)
+      handler = @stash.glob('SIG').hash.fetch('__WARN__')
+      handler = handler.target if handler.is_a?(Ref) && handler.kind == 'CODE'
+      return call(handler, [Scalar.new(formatted)], :void) if handler.is_a?(Code)
+
+      @stderr.print(formatted)
+    end
+
+    def number(value)
+      warning('uninitialized', 'Use of uninitialized value') if value.nil?
+      warning('numeric', %(Argument "#{value}" isn't numeric)) if value.is_a?(String) && !Conv::NUM_RE.match?(value)
+      Conv.to_num(value)
+    end
+
+    def file_stat(path, lstat: false)
+      return @file_stat if path == '_'
+
+      @file_stat_path = path
+      @file_stat = nil
+      @file_stat = File.public_send(lstat ? :lstat : :stat, path)
+    end
+
+    def register_object(reference)
+      @objects[reference] = true
+    end
+
+    def release(reference)
+      destroy(reference) if @refcount
+    end
+
+    def shutdown
+      run_phase(:end, reverse: true)
+      @objects.each_key { |reference| destroy(reference) }
+    end
+
+    def install_signal(name, value)
+      return if %w[__DIE__ __WARN__].include?(name)
+
+      handler = value.is_a?(Ref) && value.kind == 'CODE' ? value.target : value
+      return Signal.trap(name, handler || 'DEFAULT') unless handler.is_a?(Code)
+
+      Signal.trap(name) { call(handler, [Scalar.new(name)], :void) }
+    rescue ArgumentError => e
+      raise PerlError, e.message
+    end
+
+    def update_environment(name, value)
+      value.nil? ? ENV.delete(name) : ENV[name] = Conv.to_str(value)
+    end
+
+    def register_overload(package, pairs, disable: false)
+      return @overloads.delete(package) if disable
+
+      @overloads[package] = pairs
+    end
+
+    def overloads? = !@overloads.empty?
+
+    def overloaded(reference, operator, other = nil, swapped: false)
+      table = overload_table(reference)
+      return [false, nil] unless table
+
+      method = table[operator] || table['nomethod']
+      return [false, nil] unless method
+
+      entry = @mro.resolve(reference.blessed, Conv.to_str(method), autoload: false)
+      return [false, nil] unless entry
+
+      arguments = [Scalar.new(reference), Scalar.new(other), Scalar.new(swapped ? 1 : '')]
+      arguments << Scalar.new(operator) if table[operator].nil?
+      [true, call(entry.last, arguments, :scalar)]
+    end
+
+    def overload_table(reference)
+      return unless reference.is_a?(Ref) && reference.blessed
+
+      @mro.lineage(reference.blessed).filter_map { |package| @overloads[package] }.first
+    end
+
+    def open_next_argv
+      cell = @stash.glob('ARGV').array.cells.shift
+      if cell
+        path = Conv.to_str(cell.get)
+        @stash.glob('ARGV').scalar.set(path)
+        @argv_handle = path == '-' ? @stdin_handle : IOHandle.new(File.open(path))
+      elsif !defined?(@argv_started)
+        @argv_started = true
+        @stash.glob('ARGV').scalar.set('-')
+        @argv_handle = @stdin_handle
+      else
+        @argv_finished = true
+      end
+    end
+
+    def register_phase(kind, operation, env: self.env)
+      @phases[kind] << [operation, env]
+    end
+
+    def run_phase(kind, reverse: false)
+      operations = @phases.delete(kind) || []
+      operations.reverse! if reverse
+      operations.each { |operation, phase_env| operation.run(phase_env, :void) }
+    end
+
+    def destroy(reference)
+      return unless reference.is_a?(Ref) && reference.blessed
+      return if @destroyed[reference]
+
+      @destroyed[reference] = true
+      entry = @mro.resolve(reference.blessed, 'DESTROY')
+      call(entry.last, [Scalar.new(reference)], :void) if entry
+    end
+  end
+end

data/lib/peruby/validator.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+module Peruby
+  # Compile-time lexical checks for the strict pragma.
+  class Validator
+    State = Data.define(:strict, :warnings, :declared) do
+      def nested = State.new(strict.dup, warnings.dup, declared.dup)
+    end
+
+    SPECIAL = %w[_ a b ARGV ENV INC SIG].freeze
+
+    def self.validate(node, runtime: nil, strict: Set.new, warnings: Set.new)
+      new(runtime, strict, warnings).validate(node)
+    end
+
+    def initialize(runtime = nil, strict = Set.new, warnings = Set.new)
+      @runtime = runtime
+      @strict = strict
+      @warnings = warnings
+      @package_uses = Hash.new { |uses, key| uses[key] = [] }
+      @loop_labels = []
+    end
+
+    def validate(node)
+      visit(node, State.new(@strict.dup, @warnings.dup, {}))
+      warn_once
+      node
+    end
+
+    private
+
+    def visit(node, state)
+      return if node.nil?
+      return node.each { |item| visit(item, state) } if node.is_a?(Array)
+      return unless node.class.name.start_with?('Peruby::Node::')
+
+      name = node.class.name.split('::').last.gsub(/([A-Z]+)([A-Z][a-z])/, '\\1_\\2')
+                 .gsub(/([a-z\d])([A-Z])/, '\\1_\\2').downcase
+      method = "visit_#{name}"
+      respond_to?(method, true) ? send(method, node, state) : visit_members(node, state)
+    end
+
+    def visit_program(node, state) = visit_sequence(node.statements, state)
+    def visit_block(node, state) = visit_sequence(node.statements, state.nested)
+
+    def visit_sequence(statements, state)
+      statements.each do |statement|
+        if statement.is_a?(Node::Use) && statement.module_name == 'strict'
+          update_strict(statement, state)
+        elsif statement.is_a?(Node::Use) && statement.module_name == 'warnings'
+          update_warnings(statement, state)
+        elsif statement.is_a?(Node::Use) && statement.module_name == 'vars'
+          update_vars(statement, state)
+        else
+          visit(statement, state)
+        end
+      end
+    end
+
+    def update_vars(node, state)
+      return if node.disable
+
+      sigils = { '$' => :scalar, '@' => :array, '%' => :hash }
+      node.imports.each do |name|
+        text = name.to_s
+        sigil = sigils[text[0]]
+        state.declared[[sigil, text[1..]]] = :package if sigil && text.length > 1
+      end
+    end
+
+    def visit_my(node, state) = visit_declaration(node, state, :lexical)
+    def visit_state(node, state) = visit_declaration(node, state, :lexical)
+    def visit_our(node, state) = visit_declaration(node, state, :package)
+
+    def visit_declaration(node, state, kind)
+      visit(node.initializer, state)
+      variables = node.variable.is_a?(Node::List) ? node.variable.items : [node.variable]
+      variables.each do |variable|
+        name = kind == :package ? variable.name.rpartition('::').last : variable.name
+        state.declared[[variable.sigil, name]] = kind
+        record_package_use(variable, state) if kind == :package
+      end
+    end
+
+    def visit_variable(node, state)
+      declaration = state.declared[[node.sigil, node.name]]
+      record_package_use(node, state) if declaration == :package || (declaration.nil? && package_variable?(node))
+      return unless state.strict.include?('vars')
+      return if node.name.include?('::') || SPECIAL.include?(node.name) || special_variable?(node)
+      return if declaration
+
+      error(node, "Global symbol \"#{sigil(node.sigil)}#{node.name}\" requires explicit package name")
+    end
+
+    def visit_bareword(node, state)
+      error(node, "Bareword \"#{node.value}\" not allowed while strict subs in use") if state.strict.include?('subs')
+    end
+
+    def visit_literal(node, state)
+      value = node.value
+      source = value.body if value.is_a?(Lexer::Heredoc) && value.interpolate
+      source = value.parts.first if value.is_a?(Lexer::Quote) && value.interpolate
+      return unless source
+
+      name = Interpolation::NAME.source
+      source.scan(/(?<!\\)([$@])(?:\{(#{name})\}|(#{name}))/) do |sigil, braced, plain|
+        kind = sigil == '$' ? :scalar : :array
+        visit_variable(Node::Variable.new(kind, braced || plain, node.file, node.line), state)
+      end
+      source.scan(/(?<!\\)\$#(#{name})/) do |match|
+        visit_variable(Node::Variable.new(:array, match.first, node.file, node.line), state)
+      end
+    end
+
+    def visit_while(node, state)
+      visit(node.condition, state)
+      visit_loop(node.label) do
+        visit(node.body, state)
+        visit(node.continue_block, state)
+      end
+    end
+
+    def visit_bare_block(node, state)
+      visit_loop(node.label) { visit(node.body, state) }
+    end
+
+    def visit_c_for(node, state)
+      loop_state = state.nested
+      visit(node.initializer, loop_state)
+      visit(node.condition, loop_state)
+      visit_loop(node.label) do
+        visit(node.body, loop_state)
+        visit(node.continue_block, loop_state)
+        visit(node.step, loop_state)
+      end
+    end
+
+    def visit_for_each(node, state)
+      visit(node.list, state)
+      loop_state = state.nested
+      if node.declaration
+        loop_state.declared[[node.variable.sigil, node.variable.name]] = :lexical
+      else
+        visit(node.variable, state)
+      end
+      visit_loop(node.label) do
+        visit(node.body, loop_state)
+        visit(node.continue_block, loop_state)
+      end
+    end
+
+    def visit_modifier_condition(node, state)
+      visit(node.condition, state)
+      if %i[while until].include?(node.kind)
+        visit_loop(nil) { visit(node.expression, state) }
+      else
+        visit(node.expression, state)
+      end
+    end
+
+    def visit_modifier_for(node, state)
+      visit(node.list, state)
+      visit_loop(nil) { visit(node.expression, state) }
+    end
+
+    def visit_loop_jump(node, _state)
+      valid = node.label ? @loop_labels.include?(node.label) : !@loop_labels.empty?
+      return if valid
+
+      message = if node.label
+                  %(Label not found for "#{node.kind} #{node.label}")
+                else
+                  %(Can't "#{node.kind}" outside a loop block)
+                end
+      error(node, message)
+    end
+
+    def visit_element(node, state)
+      container = node.container
+      if container.is_a?(Node::Variable) && container.sigil != node.kind
+        container = Node::Variable.new(node.kind, container.name, container.file, container.line)
+      end
+      visit(container, state)
+      visit(node.key, state) unless node.kind == :hash && node.key.is_a?(Node::Bareword)
+    end
+
+    def visit_members(node, state)
+      node.members.reject { |member| %i[file line].include?(member) }.each do |member|
+        visit(node.public_send(member), state)
+      end
+    end
+
+    def visit_loop(label)
+      @loop_labels << label
+      yield
+    ensure
+      @loop_labels.pop
+    end
+
+    def update_strict(node, state)
+      categories = node.imports.empty? ? %w[refs subs vars] : node.imports
+      node.disable ? state.strict.subtract(categories) : state.strict.merge(categories)
+    end
+
+    def update_warnings(node, state)
+      categories = node.imports.empty? ? %w[uninitialized numeric once redefine] : node.imports
+      node.disable ? state.warnings.subtract(categories) : state.warnings.merge(categories)
+    end
+
+    def package_variable?(node)
+      !SPECIAL.include?(node.name) && !special_variable?(node)
+    end
+
+    def special_variable?(node) = node.name.match?(/\A(?:\d+|\W|\^.)\z/)
+
+    def record_package_use(node, state)
+      @package_uses[[node.sigil, node.name]] << [node, state.warnings.include?('once')]
+    end
+
+    def warn_once
+      @package_uses.each do |(_sigil, name), uses|
+        next unless uses.one? && uses.first.last && @runtime
+
+        node = uses.first.first
+        symbol = name.include?('::') ? name : "main::#{name}"
+        @runtime.emit_warning(%(Name "#{symbol}" used only once: possible typo), file: node.file, line: node.line)
+      end
+    end
+
+    def sigil(kind) = { scalar: '$', array: '@', hash: '%', code: '&', glob: '*' }.fetch(kind, '$')
+
+    def error(node, message)
+      raise CompileError, "#{message} at #{node.file} line #{node.line}."
+    end
+  end
+end

data/lib/peruby/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Peruby
+  VERSION = '0.1.0'
+end

data/lib/peruby.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'peruby/version'
+require_relative 'peruby/errors'
+require_relative 'peruby/runtime/scalar'
+require_relative 'peruby/runtime/perl_array'
+require_relative 'peruby/runtime/perl_hash'
+require_relative 'peruby/runtime/glob'
+require_relative 'peruby/runtime/ref'
+require_relative 'peruby/runtime/conv'
+require_relative 'peruby/runtime/stash'
+require_relative 'peruby/runtime/local_stack'
+require_relative 'peruby/runtime/sprintf'
+require_relative 'peruby/runtime/regexp_compiler'
+require_relative 'peruby/runtime/match_state'
+require_relative 'peruby/runtime/mro'
+require_relative 'peruby/runtime/io_handle'
+require_relative 'peruby/runtime/directory_handle'
+require_relative 'peruby/runtime/module_loader'
+require_relative 'peruby/runtime/test_builder'
+require_relative 'peruby/op'
+require_relative 'peruby/lexer'
+require_relative 'peruby/node'
+require_relative 'peruby/parser'
+require_relative 'peruby/validator'
+require_relative 'peruby/runtime'
+require_relative 'peruby/compiler'
+require_relative 'peruby/compile_unit'
+
+# Pure Ruby implementation of a Perl 5 interpreter.
+module Peruby; end

data/t/00-basic.t

@@ -0,0 +1,5 @@
+use MiniTest qw(ok is done_testing);
+
+ok(1, "truth");
+is(2 + 3, 5, "arithmetic");
+done_testing();

data/t/lib/MiniTest.pm

@@ -0,0 +1,22 @@
+package MiniTest;
+
+our $count = 0;
+
+sub ok {
+    my ($value, $name) = @_;
+    $count += 1;
+    print($value ? "ok " : "not ok ", $count, defined($name) ? " - $name" : "", "\n");
+    return $value ? 1 : 0;
+}
+
+sub is {
+    my ($got, $expected, $name) = @_;
+    return ok(defined($got) && defined($expected) && $got eq $expected, $name);
+}
+
+sub done_testing {
+    print "1..$count\n";
+    return 1;
+}
+
+1;