webshell

Ghost Exploiter Team Official

C:/Program Files/Git/usr/share/perl5/core_perl/

File / Folder	Size	Action
.	-
App	--	ren
Archive	--	ren
Attribute	--	ren
B	--	ren
Carp	--	ren
Class	--	ren
Compress	--	ren
Config	--	ren
DBM_Filter	--	ren
Devel	--	ren
Digest	--	ren
Encode	--	ren
Exporter	--	ren
File	--	ren
Filter	--	ren
Getopt	--	ren
HTTP	--	ren
I18N	--	ren
IO	--	ren
IPC	--	ren
JSON	--	ren
Math	--	ren
Memoize	--	ren
Module	--	ren
Net	--	ren
Params	--	ren
Parse	--	ren
Perl	--	ren
PerlIO	--	ren
Search	--	ren
Term	--	ren
Test	--	ren
Test2	--	ren
Text	--	ren
Thread	--	ren
Tie	--	ren
Time	--	ren
User	--	ren
Win32API	--	ren
autodie	--	ren
encoding	--	ren
overload	--	ren
source	--	ren
unicore	--	ren
version	--	ren
warnings	--	ren
AnyDBM_File.pm	2.557KB	edt ren
AutoLoader.pm	15.427KB	edt ren
AutoSplit.pm	19.177KB	edt ren
Benchmark.pm	30.323KB	edt ren
CPAN.pm	146.087KB	edt ren
Carp.pm	35.15KB	edt ren
DB.pm	18.478KB	edt ren
DBM_Filter.pm	14.026KB	edt ren
Digest.pm	10.962KB	edt ren
DirHandle.pm	2.036KB	edt ren
Dumpvalue.pm	17.254KB	edt ren
English.pm	4.649KB	edt ren
Env.pm	5.438KB	edt ren
Exporter.pm	18.762KB	edt ren
Fatal.pm	59.189KB	edt ren
FileCache.pm	5.419KB	edt ren
FileHandle.pm	6.646KB	edt ren
FindBin.pm	4.688KB	edt ren
Memoize.pm	31.822KB	edt ren
NEXT.pm	18.537KB	edt ren
PerlIO.pm	13.925KB	edt ren
Safe.pm	24.804KB	edt ren
SelectSaver.pm	1.051KB	edt ren
SelfLoader.pm	17.125KB	edt ren
Symbol.pm	4.79KB	edt ren
Test.pm	29.338KB	edt ren
Test2.pm	6.24KB	edt ren
Thread.pm	8.096KB	edt ren
UNIVERSAL.pm	6.313KB	edt ren
XSLoader.pm	11.15KB	edt ren
_charnames.pm	34.843KB	edt ren
autodie.pm	12.108KB	edt ren
autouse.pm	4.139KB	edt ren
base.pm	10.704KB	edt ren
bigfloat.pm	21.376KB	edt ren
bigint.pm	22.625KB	edt ren
bignum.pm	27.48KB	edt ren
bigrat.pm	20.554KB	edt ren
blib.pm	2.014KB	edt ren
builtin.pm	15.504KB	edt ren
bytes.pm	3.766KB	edt ren
charnames.pm	20.556KB	edt ren
constant.pm	14.379KB	edt ren
deprecate.pm	4.495KB	edt ren
diagnostics.pm	18.891KB	edt ren
dumpvar.pl	15.19KB	edt ren
experimental.pm	8.905KB	edt ren
feature.pm	34.207KB	edt ren
fields.pm	9.229KB	edt ren
filetest.pm	3.909KB	edt ren
if.pm	3.546KB	edt ren
integer.pm	3.178KB	edt ren
less.pm	3.129KB	edt ren
locale.pm	4.645KB	edt ren
meta_notation.pm	2.021KB	edt ren
ok.pm	0.948KB	edt ren
open.pm	8.299KB	edt ren
overload.pm	53.44KB	edt ren
overloading.pm	1.766KB	edt ren
parent.pm	2.71KB	edt ren
perl5db.pl	311.113KB	edt ren
perlfaq.pm	0.075KB	edt ren
sigtrap.pm	8.528KB	edt ren
sort.pm	2.952KB	edt ren
stable.pm	4.75KB	edt ren
strict.pm	5.362KB	edt ren
subs.pm	0.923KB	edt ren
utf8.pm	10.745KB	edt ren
vars.pm	2.4KB	edt ren
version.pm	1.932KB	edt ren
vmsish.pm	4.212KB	edt ren
warnings.pm	56.38KB	edt ren

package Symbol;

use strict;
use warnings;

=head1 NAME

Symbol - manipulate Perl symbols and their names

=head1 SYNOPSIS

use Symbol;

$sym = gensym;
    open($sym, '<', "filename");
    $_ = <$sym>;
    # etc.

ungensym $sym;      # no effect

# replace *FOO{IO} handle but not $FOO, %FOO, etc.
    *FOO = geniosym;

print qualify("x"), "\n";              # "main::x"
    print qualify("x", "FOO"), "\n";       # "FOO::x"
    print qualify("BAR::x"), "\n";         # "BAR::x"
    print qualify("BAR::x", "FOO"), "\n";  # "BAR::x"
    print qualify("STDOUT", "FOO"), "\n";  # "main::STDOUT" (global)
    print qualify(\*x), "\n";              # returns \*x
    print qualify(\*x, "FOO"), "\n";       # returns \*x

use strict refs;
    print { qualify_to_ref $fh } "foo!\n";
    $ref = qualify_to_ref $name, $pkg;

use Symbol qw(delete_package);
    delete_package('Foo::Bar');
    print "deleted\n" unless exists $Foo::{'Bar::'};

=head1 DESCRIPTION

C<Symbol::gensym> creates an anonymous glob and returns a reference
to it.  Such a glob reference can be used as a file or directory
handle.

For backward compatibility with older implementations that didn't
support anonymous globs, C<Symbol::ungensym> is also provided.
But it doesn't do anything.

C<Symbol::geniosym> creates an anonymous IO handle.  This can be
assigned into an existing glob without affecting the non-IO portions
of the glob.

C<Symbol::qualify> turns unqualified symbol names into qualified
variable names (e.g. "myvar" -E<gt> "MyPackage::myvar").  If it is given a
second parameter, C<qualify> uses it as the default package;
otherwise, it uses the package of its caller.  Regardless, global
variable names (e.g. "STDOUT", "ENV", "SIG") are always qualified with
"main::".

Qualification applies only to symbol names (strings).  References are
left unchanged under the assumption that they are glob references,
which are qualified by their nature.

C<Symbol::qualify_to_ref> is just like C<Symbol::qualify> except that it
returns a glob ref rather than a symbol name, so you can use the result
even if C<use strict 'refs'> is in effect.

C<Symbol::delete_package> wipes out a whole package namespace.  Note
this routine is not exported by default--you may want to import it
explicitly.

=head1 BUGS

C<Symbol::delete_package> is a bit too powerful. It undefines every symbol that
lives in the specified package. Since perl, for performance reasons, does not
perform a symbol table lookup each time a function is called or a global
variable is accessed, some code that has already been loaded and that makes use
of symbols in package C<Foo> may stop working after you delete C<Foo>, even if
you reload the C<Foo> module afterwards.

=cut

require Exporter;
our @ISA = qw(Exporter);
our @EXPORT = qw(gensym ungensym qualify qualify_to_ref);
our @EXPORT_OK = qw(delete_package geniosym);

our $VERSION = '1.09';

my $genpkg = "Symbol::";
my $genseq = 0;

my %global = map {$_ => 1} qw(ARGV ARGVOUT ENV INC SIG STDERR STDIN STDOUT);

#
# Note that we never _copy_ the glob; we just make a ref to it.
# If we did copy it, then SVf_FAKE would be set on the copy, and
# glob-specific behaviors (e.g. C<*$ref = \&func>) wouldn't work.
#
sub gensym () {
    my $name = "GEN" . $genseq++;
    no strict 'refs';
    my $ref = \*{$genpkg . $name};
    delete $$genpkg{$name};
    $ref;
}

sub geniosym () {
    my $sym = gensym();
    # force the IO slot to be filled
    select(select $sym);
    *$sym{IO};
}

sub ungensym ($) {}

sub qualify ($;$) {
    my ($name) = @_;
    if (!ref($name) && index($name, '::') == -1 && index($name, "'") == -1) {
	my $pkg;
	# Global names: special character, "^xyz", or other. 
	if ($name =~ /^(([^a-z])|(\^[a-z_]+))\z/i || $global{$name}) {
	    # RGS 2001-11-05 : translate leading ^X to control-char
	    $name =~ s/^\^([a-z_])/'qq(\c'.$1.')'/eei;
	    $pkg = "main";
	}
	else {
	    $pkg = (@_ > 1) ? $_[1] : caller;
	}
	$name = $pkg . "::" . $name;
    }
    $name;
}

sub qualify_to_ref ($;$) {
    no strict 'refs';
    return \*{ qualify $_[0], @_ > 1 ? $_[1] : caller };
}

#
# of Safe.pm lineage
#
sub delete_package ($) {
    my $pkg = shift;

# expand to full symbol table name if needed

unless ($pkg =~ /^main::.*::$/) {
        $pkg = "main$pkg"	if	$pkg =~ /^::/;
        $pkg = "main::$pkg"	unless	$pkg =~ /^main::/;
        $pkg .= '::'		unless	$pkg =~ /::$/;
    }

my($stem, $leaf) = $pkg =~ m/(.*::)(\w+::)$/;
    no strict 'refs';
    my $stem_symtab = *{$stem}{HASH};
    return unless defined $stem_symtab and exists $stem_symtab->{$leaf};

# free all the symbols in the package

my $leaf_symtab = *{$stem_symtab->{$leaf}}{HASH};
    foreach my $name (keys %$leaf_symtab) {
        undef *{$pkg . $name};
    }
    use strict 'refs';

# delete the symbol table

%$leaf_symtab = ();
    delete $stem_symtab->{$leaf};
}