<html><head><meta name="color-scheme" content="light dark"></head><body><pre style="word-wrap: break-word; white-space: pre-wrap;">package B::Lint;
use if $] &gt; 5.017, 'deprecate';

our $VERSION = '1.17';    ## no critic

=head1 NAME

B::Lint - Perl lint

=head1 SYNOPSIS

perl -MO=Lint[,OPTIONS] foo.pl

=head1 DESCRIPTION

The B::Lint module is equivalent to an extended version of the B&lt;-w&gt;
option of B&lt;perl&gt;. It is named after the program F&lt;lint&gt; which carries
out a similar process for C programs.

=head1 OPTIONS AND LINT CHECKS

Option words are separated by commas (not whitespace) and follow the
usual conventions of compiler backend options. Following any options
(indicated by a leading B&lt;-&gt;) come lint check arguments. Each such
argument (apart from the special B&lt;all&gt; and B&lt;none&gt; options) is a
word representing one possible lint check (turning on that check) or
is B&lt;no-foo&gt; (turning off that check). Before processing the check
arguments, a standard list of checks is turned on. Later options
override earlier ones. Available options are:

=over 8

=item B&lt;magic-diamond&gt;

Produces a warning whenever the magic C&lt;E&lt;lt&gt;E&lt;gt&gt;&gt; readline is
used. Internally it uses perl's two-argument open which itself treats
filenames with special characters specially. This could allow
interestingly named files to have unexpected effects when reading.

  % touch 'rm *|'
  % perl -pe 1

The above creates a file named C&lt;rm *|&gt;. When perl opens it with
C&lt;E&lt;lt&gt;E&lt;gt&gt;&gt; it actually executes the shell program C&lt;rm *&gt;. This
makes C&lt;E&lt;lt&gt;E&lt;gt&gt;&gt; dangerous to use carelessly.

=item B&lt;context&gt;

Produces a warning whenever an array is used in an implicit scalar
context. For example, both of the lines

    $foo = length(@bar);
    $foo = @bar;

will elicit a warning. Using an explicit B&lt;scalar()&gt; silences the
warning. For example,

    $foo = scalar(@bar);

=item B&lt;implicit-read&gt; and B&lt;implicit-write&gt;

These options produce a warning whenever an operation implicitly
reads or (respectively) writes to one of Perl's special variables.
For example, B&lt;implicit-read&gt; will warn about these:

    /foo/;

and B&lt;implicit-write&gt; will warn about these:

    s/foo/bar/;

Both B&lt;implicit-read&gt; and B&lt;implicit-write&gt; warn about this:

    for (@a) { ... }

=item B&lt;bare-subs&gt;

This option warns whenever a bareword is implicitly quoted, but is also
the name of a subroutine in the current package. Typical mistakes that it will
trap are:

    use constant foo =&gt; 'bar';
    @a = ( foo =&gt; 1 );
    $b{foo} = 2;

Neither of these will do what a naive user would expect.

=item B&lt;dollar-underscore&gt;

This option warns whenever C&lt;$_&gt; is used either explicitly anywhere or
as the implicit argument of a B&lt;print&gt; statement.

=item B&lt;private-names&gt;

This option warns on each use of any variable, subroutine or
method name that lives in a non-current package but begins with
an underscore ("_"). Warnings aren't issued for the special case
of the single character name "_" by itself (e.g. C&lt;$_&gt; and C&lt;@_&gt;).

=item B&lt;undefined-subs&gt;

This option warns whenever an undefined subroutine is invoked.
This option will only catch explicitly invoked subroutines such
as C&lt;foo()&gt; and not indirect invocations such as C&lt;&amp;$subref()&gt;
or C&lt;$obj-E&lt;gt&gt;meth()&gt;. Note that some programs or modules delay
definition of subs until runtime by means of the AUTOLOAD
mechanism.

=item B&lt;regexp-variables&gt;

This option warns whenever one of the regexp variables C&lt;$`&gt;, C&lt;$&amp;&gt; or C&lt;$'&gt;
is used. Any occurrence of any of these variables in your
program can slow your whole program down. See L&lt;perlre&gt; for
details.

=item B&lt;all&gt;

Turn all warnings on.

=item B&lt;none&gt;

Turn all warnings off.

=back

=head1 NON LINT-CHECK OPTIONS

=over 8

=item B&lt;-u Package&gt;

Normally, Lint only checks the main code of the program together
with all subs defined in package main. The B&lt;-u&gt; option lets you
include other package names whose subs are then checked by Lint.

=back

=head1 EXTENDING LINT

Lint can be extended by with plugins. Lint uses L&lt;Module::Pluggable&gt;
to find available plugins. Plugins are expected but not required to
inform Lint of which checks they are adding.

The C&lt;&lt; B::Lint-&gt;register_plugin( MyPlugin =&gt; \@new_checks ) &gt;&gt; method
adds the list of C&lt;@new_checks&gt; to the list of valid checks. If your
module wasn't loaded by L&lt;Module::Pluggable&gt; then your class name is
added to the list of plugins.

You must create a C&lt;match( \%checks )&gt; method in your plugin class or one
of its parents. It will be called on every op as a regular method call
with a hash ref of checks as its parameter.

The class methods C&lt;&lt; B::Lint-&gt;file &gt;&gt; and C&lt;&lt; B::Lint-&gt;line &gt;&gt; contain
the current filename and line number.

  package Sample;
  use B::Lint;
  B::Lint-&gt;register_plugin( Sample =&gt; [ 'good_taste' ] );
  
  sub match {
      my ( $op, $checks_href ) = shift @_;
      if ( $checks_href-&gt;{good_taste} ) {
          ...
      }
  }

=head1 TODO

=over

=item while(&lt;FH&gt;) stomps $_

=item strict oo

=item unchecked system calls

=item more tests, validate against older perls

=back

=head1 BUGS

This is only a very preliminary version.

=head1 AUTHOR

Malcolm Beattie, mbeattie@sable.ox.ac.uk.

=head1 ACKNOWLEDGEMENTS

Sebastien Aperghis-Tramoni - bug fixes

=cut

use strict;
use B qw( walkoptree_slow
    main_root main_cv walksymtable parents
    OPpOUR_INTRO
    OPf_WANT_VOID OPf_WANT_LIST OPf_WANT OPf_STACKED SVf_POK );
use Carp 'carp';

# The current M::P doesn't know about .pmc files.
use Module::Pluggable ( require =&gt; 1 );

use List::Util 'first';
## no critic Prototypes
sub any (&amp;@) { my $test = shift @_; $test-&gt;() and return 1 for @_; return 0 }

BEGIN {

    # Import or create some constants from B. B doesn't provide
    # everything I need so some things like OPpCONST_BARE are defined
    # here.
    for my $sym ( qw( begin_av check_av init_av end_av ),
        [ 'OPpCONST_BARE' =&gt; 64 ] )
    {
        my $val;
        ( $sym, $val ) = @$sym if ref $sym;

        if ( any { $sym eq $_ } @B::EXPORT_OK, @B::EXPORT ) {
            B-&gt;import($sym);
        }
        else {
            require constant;
            constant-&gt;import( $sym =&gt; $val );
        }
    }
}

my $file     = "unknown";    # shadows current filename
my $line     = 0;            # shadows current line number
my $curstash = "main";       # shadows current stash
my $curcv;                   # shadows current B::CV for pad lookups

sub file     {$file}
sub line     {$line}
sub curstash {$curstash}
sub curcv    {$curcv}

# Lint checks
my %check;
my %implies_ok_context;

map( $implies_ok_context{$_}++,
    qw(scalar av2arylen aelem aslice helem hslice
        keys values hslice defined undef delete) );

# Lint checks turned on by default
my @default_checks
    = qw(context magic_diamond undefined_subs regexp_variables);

my %valid_check;

# All valid checks
for my $check (
    qw(context implicit_read implicit_write dollar_underscore
    private_names bare_subs undefined_subs regexp_variables
    magic_diamond )
    )
{
    $valid_check{$check} = __PACKAGE__;
}

# Debugging options
my ($debug_op);

my %done_cv;           # used to mark which subs have already been linted
my @extra_packages;    # Lint checks mainline code and all subs which are
                       # in main:: or in one of these packages.

sub warning {
    my $format = ( @_ &lt; 2 ) ? "%s" : shift @_;
    warn sprintf( "$format at %s line %d\n", @_, $file, $line );
    return undef;      ## no critic undef
}

# This gimme can't cope with context that's only determined
# at runtime via dowantarray().
sub gimme {
    my $op    = shift @_;
    my $flags = $op-&gt;flags;
    if ( $flags &amp; OPf_WANT ) {
        return ( ( $flags &amp; OPf_WANT ) == OPf_WANT_LIST ? 1 : 0 );
    }
    return undef;      ## no critic undef
}

my @plugins = __PACKAGE__-&gt;plugins;

sub inside_grepmap {

    # A boolean function to be used while inside a B::walkoptree_slow
    # call. If we are in the EXPR part of C&lt;grep EXPR, ...&gt; or C&lt;grep
    # { EXPR } ...&gt;, this returns true.
    return any { $_-&gt;name =~ m/\A(?:grep|map)/xms } @{ parents() };
}

sub inside_foreach_modifier {

    # TODO: use any()

    # A boolean function to be used while inside a B::walkoptree_slow
    # call. If we are in the EXPR part of C&lt;EXPR foreach ...&gt; this
    # returns true.
    for my $ancestor ( @{ parents() } ) {
        next unless $ancestor-&gt;name eq 'leaveloop';

        my $first = $ancestor-&gt;first;
        next unless $first-&gt;name eq 'enteriter';

        next if $first-&gt;redoop-&gt;name =~ m/\A(?:next|db|set)state\z/xms;

        return 1;
    }
    return 0;
}

for (
    [qw[ B::PADOP::gv_harder gv padix]],
    [qw[ B::SVOP::sv_harder  sv targ]],
    [qw[ B::SVOP::gv_harder gv padix]]
    )
{

    # I'm generating some functions here because they're mostly
    # similar. It's all for compatibility with threaded
    # perl. Perhaps... this code should inspect $Config{usethreads}
    # and generate a *specific* function. I'm leaving it generic for
    # the moment.
    #
    # In threaded perl SVs and GVs aren't used directly in the optrees
    # like they are in non-threaded perls. The ops that would use a SV
    # or GV keep an index into the subroutine's scratchpad. I'm
    # currently ignoring $cv-&gt;DEPTH and that might be at my peril.

    my ( $subname, $attr, $pad_attr ) = @$_;
    my $target = do {    ## no critic strict
        no strict 'refs';
        \*$subname;
    };
    *$target = sub {
        my ($op) = @_;

        my $elt;
        if ( not $op-&gt;isa('B::PADOP') ) {
            $elt = $op-&gt;$attr;
        }
        return $elt if eval { $elt-&gt;isa('B::SV') };

        my $ix         = $op-&gt;$pad_attr;
        my @entire_pad = $curcv-&gt;PADLIST-&gt;ARRAY;
        my @elts       = map +( $_-&gt;ARRAY )[$ix], @entire_pad;
        ($elt) = first {
            eval { $_-&gt;isa('B::SV') } ? $_ : ();
        }
        @elts[ 0, reverse 1 .. $#elts ];
        return $elt;
    };
}

sub B::OP::lint {
    my ($op) = @_;

    # This is a fallback -&gt;lint for all the ops where I haven't
    # defined something more specific. Nothing happens here.

    # Call all registered plugins
    my $m;
    $m = $_-&gt;can('match'), $op-&gt;$m( \%check ) for @plugins;
    return;
}

sub B::COP::lint {
    my ($op) = @_;

    # nextstate ops sit between statements. Whenever I see one I
    # update the current info on file, line, and stash. This code also
    # updates it when it sees a dbstate or setstate op. I have no idea
    # what those are but having seen them mentioned together in other
    # parts of the perl I think they're kind of equivalent.
    if ( $op-&gt;name =~ m/\A(?:next|db|set)state\z/ ) {
        $file     = $op-&gt;file;
        $line     = $op-&gt;line;
        $curstash = $op-&gt;stash-&gt;NAME;
    }

    # Call all registered plugins
    my $m;
    $m = $_-&gt;can('match'), $op-&gt;$m( \%check ) for @plugins;
    return;
}

sub B::UNOP::lint {
    my ($op) = @_;

    my $opname = $op-&gt;name;

CONTEXT: {

        # Check arrays and hashes in scalar or void context where
        # scalar() hasn't been used.

        next
            unless $check{context}
            and $opname =~ m/\Arv2[ah]v\z/xms
            and not gimme($op);

        my ( $parent, $gparent ) = @{ parents() }[ 0, 1 ];
        my $pname = $parent-&gt;name;

        next if $implies_ok_context{$pname};

        # Three special cases to deal with: "foreach (@foo)", "delete
        # $a{$b}", and "exists $a{$b}" null out the parent so we have to
        # check for a parent of pp_null and a grandparent of
        # pp_enteriter, pp_delete, pp_exists

        next
            if $pname eq "null"
            and $gparent-&gt;name =~ m/\A(?:delete|enteriter|exists)\z/xms;

        # our( @bar ); would also trigger this error so I exclude
        # that.
        next
            if $op-&gt;private &amp; OPpOUR_INTRO
            and ( $op-&gt;flags &amp; OPf_WANT ) == OPf_WANT_VOID;

        warning 'Implicit scalar context for %s in %s',
            $opname eq "rv2av" ? "array" : "hash", $parent-&gt;desc;
    }

PRIVATE_NAMES: {

        # Looks for calls to methods with names that begin with _ and
        # that aren't visible within the current package. Maybe this
        # should look at @ISA.
        next
            unless $check{private_names}
            and $opname =~ m/\Amethod/xms;

        my $methop = $op-&gt;first;
        next unless $methop-&gt;name eq "const";

        my $method = $methop-&gt;sv_harder-&gt;PV;
        next
            unless $method =~ m/\A_/xms
            and not defined &amp;{"$curstash\::$method"};

        warning q[Illegal reference to private method name '%s'], $method;
    }

    # Call all registered plugins
    my $m;
    $m = $_-&gt;can('match'), $op-&gt;$m( \%check ) for @plugins;
    return;
}

sub B::PMOP::lint {
    my ($op) = @_;

IMPLICIT_READ: {

        # Look for /.../ that doesn't use =~ to bind to something.
        next
            unless $check{implicit_read}
            and $op-&gt;name eq "match"
            and not( $op-&gt;flags &amp; OPf_STACKED
            or inside_grepmap() );
        warning 'Implicit match on $_';
    }

IMPLICIT_WRITE: {

        # Look for s/.../.../ that doesn't use =~ to bind to
        # something.
        next
            unless $check{implicit_write}
            and $op-&gt;name eq "subst"
            and not $op-&gt;flags &amp; OPf_STACKED;
        warning 'Implicit substitution on $_';
    }

    # Call all registered plugins
    my $m;
    $m = $_-&gt;can('match'), $op-&gt;$m( \%check ) for @plugins;
    return;
}

sub B::LOOP::lint {
    my ($op) = @_;

IMPLICIT_FOO: {

        # Look for C&lt;for ( ... )&gt;.
        next
            unless ( $check{implicit_read} or $check{implicit_write} )
            and $op-&gt;name eq "enteriter";

        my $last = $op-&gt;last;
        next
            unless $last-&gt;name         eq "gv"
            and $last-&gt;gv_harder-&gt;NAME eq "_"
            and $op-&gt;redoop-&gt;name =~ m/\A(?:next|db|set)state\z/xms;

        warning 'Implicit use of $_ in foreach';
    }

    # Call all registered plugins
    my $m;
    $m = $_-&gt;can('match'), $op-&gt;$m( \%check ) for @plugins;
    return;
}

# In threaded vs non-threaded perls you'll find that threaded perls
# use PADOP in place of SVOPs so they can do lookups into the
# scratchpad to find things. I suppose this is so a optree can be
# shared between threads and all symbol table muckery will just get
# written to a scratchpad.
*B::PADOP::lint = *B::PADOP::lint = \&amp;B::SVOP::lint;

sub B::SVOP::lint {
    my ($op) = @_;

MAGIC_DIAMOND: {
        next
            unless $check{magic_diamond}
            and parents()-&gt;[0]-&gt;name eq 'readline'
            and $op-&gt;gv_harder-&gt;NAME eq 'ARGV';

        warning 'Use of &lt;&gt;';
    }

BARE_SUBS: {
        next
            unless $check{bare_subs}
            and $op-&gt;name eq 'const'
            and $op-&gt;private &amp; OPpCONST_BARE;

        my $sv = $op-&gt;sv_harder;
        next unless $sv-&gt;FLAGS &amp; SVf_POK;

        my $sub     = $sv-&gt;PV;
        my $subname = "$curstash\::$sub";

        # I want to skip over things that were declared with the
        # constant pragma. Well... sometimes. Hmm. I want to ignore
        # C&lt;&lt;use constant FOO =&gt; ...&gt;&gt; but warn on C&lt;&lt;FOO =&gt; ...&gt;&gt;
        # later. The former is typical declaration syntax and the
        # latter would be an error.
        #
        # Skipping over both could be handled by looking if
        # $constant::declared{$subname} is true.

        # Check that it's a function.
        next
            unless exists &amp;{"$curstash\::$sub"};

        warning q[Bare sub name '%s' interpreted as string], $sub;
    }

PRIVATE_NAMES: {
        next unless $check{private_names};

        my $opname = $op-&gt;name;
        if ( $opname =~ m/\Agv(?:sv)?\z/xms ) {

            # Looks for uses of variables and stuff that are named
            # private and we're not in the same package.
            my $gv   = $op-&gt;gv_harder;
            my $name = $gv-&gt;NAME;
            next
                unless $name =~ m/\A_./xms
                and $gv-&gt;STASH-&gt;NAME ne $curstash;

            warning q[Illegal reference to private name '%s'], $name;
        }
        elsif ( $opname eq "method_named" ) {
            my $method = $op-&gt;sv_harder-&gt;PV;
            next unless $method =~ m/\A_./xms;

            warning q[Illegal reference to private method name '%s'], $method;
        }
    }

DOLLAR_UNDERSCORE: {

        # Warn on uses of $_ with a few exceptions. I'm not warning on
        # $_ inside grep, map, or statement modifier foreach because
        # they localize $_ and it'd be impossible to use these
        # features without getting warnings.

        next
            unless $check{dollar_underscore}
            and $op-&gt;name            eq "gvsv"
            and $op-&gt;gv_harder-&gt;NAME eq "_"
            and not( inside_grepmap
            or inside_foreach_modifier );

        warning 'Use of $_';
    }

REGEXP_VARIABLES: {

        # Look for any uses of $`, $&amp;, or $'.
        next
            unless $check{regexp_variables}
            and $op-&gt;name eq "gvsv";

        my $name = $op-&gt;gv_harder-&gt;NAME;
        next unless $name =~ m/\A[\&amp;\'\`]\z/xms;

        warning 'Use of regexp variable $%s', $name;
    }

UNDEFINED_SUBS: {

        # Look for calls to functions that either don't exist or don't
        # have a definition.
        next
            unless $check{undefined_subs}
            and $op-&gt;name       eq "gv"
            and $op-&gt;next-&gt;name eq "entersub";

        my $gv      = $op-&gt;gv_harder;
        my $subname = $gv-&gt;STASH-&gt;NAME . "::" . $gv-&gt;NAME;

        no strict 'refs';    ## no critic strict
        if ( not exists &amp;$subname ) {
            $subname =~ s/\Amain:://;
            warning q[Nonexistent subroutine '%s' called], $subname;
        }
        elsif ( not defined &amp;$subname ) {
            $subname =~ s/\A\&amp;?main:://;
            warning q[Undefined subroutine '%s' called], $subname;
        }
    }

    # Call all registered plugins
    my $m;
    $m = $_-&gt;can('match'), $op-&gt;$m( \%check ) for @plugins;
    return;
}

sub B::GV::lintcv {

    # Example: B::svref_2object( \ *A::Glob )-&gt;lintcv

    my $gv = shift @_;
    my $cv = $gv-&gt;CV;
    return unless $cv-&gt;can('lintcv');
    $cv-&gt;lintcv;
    return;
}

sub B::CV::lintcv {

    # Example: B::svref_2object( \ &amp;foo )-&gt;lintcv

    # Write to the *global* $
    $curcv = shift @_;

    #warn sprintf("lintcv: %s::%s (done=%d)\n",
    #		 $gv-&gt;STASH-&gt;NAME, $gv-&gt;NAME, $done_cv{$$curcv});#debug
    return unless ref($curcv) and $$curcv and not $done_cv{$$curcv}++;
    my $root = $curcv-&gt;ROOT;

    #warn "    root = $root (0x$$root)\n";#debug
    walkoptree_slow( $root, "lint" ) if $$root;
    return;
}

sub do_lint {
    my %search_pack;

    # Copy to the global $curcv for use in pad lookups.
    $curcv = main_cv;
    walkoptree_slow( main_root, "lint" ) if ${ main_root() };

    # Do all the miscellaneous non-sub blocks.
    for my $av ( begin_av, init_av, check_av, end_av ) {
        next unless eval { $av-&gt;isa('B::AV') };
        for my $cv ( $av-&gt;ARRAY ) {
            next unless ref($cv) and $cv-&gt;FILE eq $0;
            $cv-&gt;lintcv;
        }
    }

    walksymtable(
        \%main::,
        sub {
            if ( $_[0]-&gt;FILE eq $0 ) { $_[0]-&gt;lintcv }
        },
        sub {1}
    );
    return;
}

sub compile {
    my @options = @_;

    # Turn on default lint checks
    for my $opt (@default_checks) {
        $check{$opt} = 1;
    }

OPTION:
    while ( my $option = shift @options ) {
        my ( $opt, $arg );
        unless ( ( $opt, $arg ) = $option =~ m/\A-(.)(.*)/xms ) {
            unshift @options, $option;
            last OPTION;
        }

        if ( $opt eq "-" &amp;&amp; $arg eq "-" ) {
            shift @options;
            last OPTION;
        }
        elsif ( $opt eq "D" ) {
            $arg ||= shift @options;
            foreach my $arg ( split //, $arg ) {
                if ( $arg eq "o" ) {
                    B-&gt;debug(1);
                }
                elsif ( $arg eq "O" ) {
                    $debug_op = 1;
                }
            }
        }
        elsif ( $opt eq "u" ) {
            $arg ||= shift @options;
            push @extra_packages, $arg;
        }
    }

    foreach my $opt ( @default_checks, @options ) {
        $opt =~ tr/-/_/;
        if ( $opt eq "all" ) {
            %check = %valid_check;
        }
        elsif ( $opt eq "none" ) {
            %check = ();
        }
        else {
            if ( $opt =~ s/\Ano_//xms ) {
                $check{$opt} = 0;
            }
            else {
                $check{$opt} = 1;
            }
            carp "No such check: $opt"
                unless defined $valid_check{$opt};
        }
    }

    # Remaining arguments are things to check. So why aren't I
    # capturing them or something? I don't know.

    return \&amp;do_lint;
}

sub register_plugin {
    my ( undef, $plugin, $new_checks ) = @_;

    # Allow the user to be lazy and not give us a name.
    $plugin = caller unless defined $plugin;

    # Register the plugin's named checks, if any.
    for my $check ( eval {@$new_checks} ) {
        if ( not defined $check ) {
            carp 'Undefined value in checks.';
            next;
        }
        if ( exists $valid_check{$check} ) {
            carp
                "$check is already registered as a $valid_check{$check} feature.";
            next;
        }

        $valid_check{$check} = $plugin;
    }

    # Register a non-Module::Pluggable loaded module. @plugins already
    # contains whatever M::P found on disk. The user might load a
    # plugin manually from some arbitrary namespace and ask for it to
    # be registered.
    if ( not any { $_ eq $plugin } @plugins ) {
        push @plugins, $plugin;
    }

    return;
}

1;
</pre></body></html>