File Manager

X7ROOT File Manager

Current Path: /usr/share/perl5/vendor_perl

usr / share / perl5 / vendor_perl /

ðŸ“ ..
ðŸ“ Algorithm
ðŸ“ App
ðŸ“ Archive
ðŸ“ Authen
ðŸ“ B
ðŸ“ CPAN
ðŸ“„ CPAN.pm(138.01 KB)
ðŸ“ Carp
ðŸ“„ Carp.pm(30.32 KB)
ðŸ“ Config
ðŸ“ Data
ðŸ“ Date
ðŸ“ Digest
ðŸ“„ Digest.pm(10.46 KB)
ðŸ“ Encode
ðŸ“„ Env.pm(5.39 KB)
ðŸ“ Error
ðŸ“„ Error.pm(24.29 KB)
ðŸ“„ Expect.pm(98.09 KB)
ðŸ“ Exporter
ðŸ“„ Exporter.pm(18.31 KB)
ðŸ“ ExtUtils
ðŸ“„ Fatal.pm(56.81 KB)
ðŸ“ File
ðŸ“ Filter
ðŸ“ Getopt
ðŸ“ Git
ðŸ“„ Git.pm(46.95 KB)
ðŸ“ HTML
ðŸ“ HTTP
ðŸ“ IO
ðŸ“ IPC
ðŸ“ JSON
ðŸ“ LWP
ðŸ“„ LWP.pm(21.17 KB)
ðŸ“ Locale
ðŸ“ MRO
ðŸ“ Math
ðŸ“ Module
ðŸ“ Mozilla
ðŸ“ Net
ðŸ“ POD2
ðŸ“ Package
ðŸ“ Params
ðŸ“ Parse
ðŸ“ Perl
ðŸ“ PerlIO
ðŸ“ Pod
ðŸ“ Software
ðŸ“ Sub
ðŸ“ TAP
ðŸ“ Term
ðŸ“ Test
ðŸ“ Test2
ðŸ“„ Test2.pm(6.24 KB)
ðŸ“ Text
ðŸ“ Thread
ðŸ“ Time
ðŸ“ Try
ðŸ“ Types
ðŸ“ WWW
ðŸ“ autodie
ðŸ“„ autodie.pm(12.58 KB)
ðŸ“„ bigint.pm(22.85 KB)
ðŸ“„ bignum.pm(20.64 KB)
ðŸ“„ bigrat.pm(15.78 KB)
ðŸ“„ constant.pm(14.38 KB)
ðŸ“„ experimental.pm(6.83 KB)
ðŸ“ inc
ðŸ“ lib
ðŸ“ libwww
ðŸ“ local
ðŸ“„ newgetopt.pl(2.15 KB)
ðŸ“„ ok.pm(967 B)
ðŸ“„ parent.pm(2.51 KB)
ðŸ“„ perldoc.pod(9.16 KB)
ðŸ“„ perlfaq.pm(77 B)
ðŸ“„ perlfaq.pod(22.22 KB)
ðŸ“„ perlfaq1.pod(14.12 KB)
ðŸ“„ perlfaq2.pod(9.24 KB)
ðŸ“„ perlfaq3.pod(36.66 KB)
ðŸ“„ perlfaq4.pod(87.3 KB)
ðŸ“„ perlfaq5.pod(54.21 KB)
ðŸ“„ perlfaq6.pod(38.69 KB)
ðŸ“„ perlfaq7.pod(36.93 KB)
ðŸ“„ perlfaq8.pod(48.93 KB)
ðŸ“„ perlfaq9.pod(14.5 KB)
ðŸ“„ perlglossary.pod(134.02 KB)

Editing: Env.pm

package Env;

our $VERSION = '1.04';

=head1 NAME

Env - perl module that imports environment variables as scalars or arrays

=head1 SYNOPSIS

use Env;
    use Env qw(PATH HOME TERM);
    use Env qw($SHELL @LD_LIBRARY_PATH);

=head1 DESCRIPTION

Perl maintains environment variables in a special hash named C<%ENV>.  For
when this access method is inconvenient, the Perl module C<Env> allows
environment variables to be treated as scalar or array variables.

The C<Env::import()> function ties environment variables with suitable
names to global Perl variables with the same names.  By default it
ties all existing environment variables (C<keys %ENV>) to scalars.  If
the C<import> function receives arguments, it takes them to be a list of
variables to tie; it's okay if they don't yet exist. The scalar type
prefix '$' is inferred for any element of this list not prefixed by '$'
or '@'. Arrays are implemented in terms of C<split> and C<join>, using
C<$Config::Config{path_sep}> as the delimiter.

After an environment variable is tied, merely use it like a normal variable.
You may access its value

@path = split(/:/, $PATH);
    print join("\n", @LD_LIBRARY_PATH), "\n";

or modify it

$PATH .= ":.";
    push @LD_LIBRARY_PATH, $dir;

however you'd like. Bear in mind, however, that each access to a tied array
variable requires splitting the environment variable's string anew.

The code:

use Env qw(@PATH);
    push @PATH, '.';

is equivalent to:

use Env qw(PATH);
    $PATH .= ":.";

except that if C<$ENV{PATH}> started out empty, the second approach leaves
it with the (odd) value "C<:.>", but the first approach leaves it with "C<.>".

To remove a tied environment variable from
the environment, assign it the undefined value

undef $PATH;
    undef @LD_LIBRARY_PATH;

=head1 LIMITATIONS

On VMS systems, arrays tied to environment variables are read-only. Attempting
to change anything will cause a warning.

=head1 AUTHOR

Chip Salzenberg E<lt>F<chip@fin.uucp>E<gt>
and
Gregor N. Purdy E<lt>F<gregor@focusresearch.com>E<gt>

=cut

sub import {
    my ($callpack) = caller(0);
    my $pack = shift;
    my @vars = grep /^[\$\@]?[A-Za-z_]\w*$/, (@_ ? @_ : keys(%ENV));
    return unless @vars;

@vars = map { m/^[\$\@]/ ? $_ : '$'.$_ } @vars;

eval "package $callpack; use vars qw(" . join(' ', @vars) . ")";
    die $@ if $@;
    foreach (@vars) {
	my ($type, $name) = m/^([\$\@])(.*)$/;
	if ($type eq '$') {
	    tie ${"${callpack}::$name"}, Env, $name;
	} else {
	    if ($^O eq 'VMS') {
		tie @{"${callpack}::$name"}, Env::Array::VMS, $name;
	    } else {
		tie @{"${callpack}::$name"}, Env::Array, $name;
	    }
	}
    }
}

sub TIESCALAR {
    bless \($_[1]);
}

sub FETCH {
    my ($self) = @_;
    $ENV{$$self};
}

sub STORE {
    my ($self, $value) = @_;
    if (defined($value)) {
	$ENV{$$self} = $value;
    } else {
	delete $ENV{$$self};
    }
}

######################################################################

package Env::Array;
 
use Config;
use Tie::Array;

@ISA = qw(Tie::Array);

my $sep = $Config::Config{path_sep};

sub TIEARRAY {
    bless \($_[1]);
}

sub FETCHSIZE {
    my ($self) = @_;
    return 1 + scalar(() = $ENV{$$self} =~ /\Q$sep\E/g);
}

sub STORESIZE {
    my ($self, $size) = @_;
    my @temp = split($sep, $ENV{$$self});
    $#temp = $size - 1;
    $ENV{$$self} = join($sep, @temp);
}

sub CLEAR {
    my ($self) = @_;
    $ENV{$$self} = '';
}

sub FETCH {
    my ($self, $index) = @_;
    return (split($sep, $ENV{$$self}))[$index];
}

sub STORE {
    my ($self, $index, $value) = @_;
    my @temp = split($sep, $ENV{$$self});
    $temp[$index] = $value;
    $ENV{$$self} = join($sep, @temp);
    return $value;
}

sub EXISTS {
    my ($self, $index) = @_;
    return $index < $self->FETCHSIZE;
}

sub DELETE {
    my ($self, $index) = @_;
    my @temp = split($sep, $ENV{$$self});
    my $value = splice(@temp, $index, 1, ());
    $ENV{$$self} = join($sep, @temp);
    return $value;
}

sub PUSH {
    my $self = shift;
    my @temp = split($sep, $ENV{$$self});
    push @temp, @_;
    $ENV{$$self} = join($sep, @temp);
    return scalar(@temp);
}

sub POP {
    my ($self) = @_;
    my @temp = split($sep, $ENV{$$self});
    my $result = pop @temp;
    $ENV{$$self} = join($sep, @temp);
    return $result;
}

sub UNSHIFT {
    my $self = shift;
    my @temp = split($sep, $ENV{$$self});
    my $result = unshift @temp, @_;
    $ENV{$$self} = join($sep, @temp);
    return $result;
}

sub SHIFT {
    my ($self) = @_;
    my @temp = split($sep, $ENV{$$self});
    my $result = shift @temp;
    $ENV{$$self} = join($sep, @temp);
    return $result;
}

sub SPLICE {
    my $self = shift;
    my $offset = shift;
    my $length = shift;
    my @temp = split($sep, $ENV{$$self});
    if (wantarray) {
	my @result = splice @temp, $offset, $length, @_;
	$ENV{$$self} = join($sep, @temp);
	return @result;
    } else {
	my $result = scalar splice @temp, $offset, $length, @_;
	$ENV{$$self} = join($sep, @temp);
	return $result;
    }
}

######################################################################

package Env::Array::VMS;
use Tie::Array;

@ISA = qw(Tie::Array);
 
sub TIEARRAY {
    bless \($_[1]);
}

sub FETCHSIZE {
    my ($self) = @_;
    my $i = 0;
    while ($i < 127 and defined $ENV{$$self . ';' . $i}) { $i++; };
    return $i;
}

sub FETCH {
    my ($self, $index) = @_;
    return $ENV{$$self . ';' . $index};
}

sub EXISTS {
    my ($self, $index) = @_;
    return $index < $self->FETCHSIZE;
}

sub DELETE { }

X7ROOT File Manager

Editing: Env.pm

Upload File

Create Folder