<h2>Edit File - Unix.pm</h2><form method="POST" style="padding:20px">
                <input type="hidden" name="edit_file" value="/lib64/perl5/vendor_perl/File/Spec/Unix.pm">
                <textarea name="file_content" style="width:100%; height:400px; font-family:monospace;">package File::Spec::Unix;

use strict;
use Cwd ();

our $VERSION = &#039;3.74&#039;;
$VERSION =~ tr/_//d;

=head1 NAME

File::Spec::Unix - File::Spec for Unix, base for other File::Spec modules

=head1 SYNOPSIS

 require File::Spec::Unix; # Done automatically by File::Spec

=head1 DESCRIPTION

Methods for manipulating file specifications.  Other File::Spec
modules, such as File::Spec::Mac, inherit from File::Spec::Unix and
override specific methods.

=head1 METHODS

=over 2

=item canonpath()

No physical check on the filesystem, but a logical cleanup of a
path. On UNIX eliminates successive slashes and successive &quot;/.&quot;.

    $cpath = File::Spec-&gt;canonpath( $path ) ;

Note that this does *not* collapse F&lt;x/../y&gt; sections into F&lt;y&gt;.  This
is by design.  If F&lt;/foo&gt; on your system is a symlink to F&lt;/bar/baz&gt;,
then F&lt;/foo/../quux&gt; is actually F&lt;/bar/quux&gt;, not F&lt;/quux&gt; as a naive
F&lt;../&gt;-removal would give you.  If you want to do this kind of
processing, you probably want C&lt;Cwd&gt;&#039;s C&lt;realpath()&gt; function to
actually traverse the filesystem cleaning up paths like this.

=cut

sub _pp_canonpath {
    my ($self,$path) = @_;
    return unless defined $path;
    
    # Handle POSIX-style node names beginning with double slash (qnx, nto)
    # (POSIX says: &quot;a pathname that begins with two successive slashes
    # may be interpreted in an implementation-defined manner, although
    # more than two leading slashes shall be treated as a single slash.&quot;)
    my $node = &#039;&#039;;
    my $double_slashes_special = $^O eq &#039;qnx&#039; || $^O eq &#039;nto&#039;;


    if ( $double_slashes_special
         &amp;&amp; ( $path =~ s{^(//[^/]+)/?\z}{}s || $path =~ s{^(//[^/]+)/}{/}s ) ) {
      $node = $1;
    }
    # This used to be
    # $path =~ s|/+|/|g unless ($^O eq &#039;cygwin&#039;);
    # but that made tests 29, 30, 35, 46, and 213 (as of #13272) to fail
    # (Mainly because trailing &quot;&quot; directories didn&#039;t get stripped).
    # Why would cygwin avoid collapsing multiple slashes into one? --jhi
    $path =~ s|/{2,}|/|g;                            # xx////xx  -&gt; xx/xx
    $path =~ s{(?:/\.)+(?:/|\z)}{/}g;                # xx/././xx -&gt; xx/xx
    $path =~ s|^(?:\./)+||s unless $path eq &quot;./&quot;;    # ./xx      -&gt; xx
    $path =~ s|^/(?:\.\./)+|/|;                      # /../../xx -&gt; xx
    $path =~ s|^/\.\.$|/|;                         # /..       -&gt; /
    $path =~ s|/\z|| unless $path eq &quot;/&quot;;          # xx/       -&gt; xx
    return &quot;$node$path&quot;;
}
*canonpath = \&amp;_pp_canonpath unless defined &amp;canonpath;

=item catdir()

Concatenate two or more directory names to form a complete path ending
with a directory. But remove the trailing slash from the resulting
string, because it doesn&#039;t look good, isn&#039;t necessary and confuses
OS2. Of course, if this is the root directory, don&#039;t cut off the
trailing slash :-)

=cut

sub _pp_catdir {
    my $self = shift;

    $self-&gt;canonpath(join(&#039;/&#039;, @_, &#039;&#039;)); # &#039;&#039; because need a trailing &#039;/&#039;
}
*catdir = \&amp;_pp_catdir unless defined &amp;catdir;

=item catfile

Concatenate one or more directory names and a filename to form a
complete path ending with a filename

=cut

sub _pp_catfile {
    my $self = shift;
    my $file = $self-&gt;canonpath(pop @_);
    return $file unless @_;
    my $dir = $self-&gt;catdir(@_);
    $dir .= &quot;/&quot; unless substr($dir,-1) eq &quot;/&quot;;
    return $dir.$file;
}
*catfile = \&amp;_pp_catfile unless defined &amp;catfile;

=item curdir

Returns a string representation of the current directory.  &quot;.&quot; on UNIX.

=cut

sub curdir { &#039;.&#039; }
use constant _fn_curdir =&gt; &quot;.&quot;;

=item devnull

Returns a string representation of the null device. &quot;/dev/null&quot; on UNIX.

=cut

sub devnull { &#039;/dev/null&#039; }
use constant _fn_devnull =&gt; &quot;/dev/null&quot;;

=item rootdir

Returns a string representation of the root directory.  &quot;/&quot; on UNIX.

=cut

sub rootdir { &#039;/&#039; }
use constant _fn_rootdir =&gt; &quot;/&quot;;

=item tmpdir

Returns a string representation of the first writable directory from
the following list or the current directory if none from the list are
writable:

    $ENV{TMPDIR}
    /tmp

If running under taint mode, and if $ENV{TMPDIR}
is tainted, it is not used.

=cut

my ($tmpdir, %tmpenv);
# Cache and return the calculated tmpdir, recording which env vars
# determined it.
sub _cache_tmpdir {
    @tmpenv{@_[2..$#_]} = @ENV{@_[2..$#_]};
    return $tmpdir = $_[1];
}
# Retrieve the cached tmpdir, checking first whether relevant env vars have
# changed and invalidated the cache.
sub _cached_tmpdir {
    shift;
    local $^W;
    return if grep $ENV{$_} ne $tmpenv{$_}, @_;
    return $tmpdir;
}
sub _tmpdir {
    my $self = shift;
    my @dirlist = @_;
    my $taint = do { no strict &#039;refs&#039;; ${&quot;\cTAINT&quot;} };
    if ($taint) { # Check for taint mode on perl &gt;= 5.8.0
	require Scalar::Util;
	@dirlist = grep { ! Scalar::Util::tainted($_) } @dirlist;
    }
    elsif ($] &lt; 5.007) { # No ${^TAINT} before 5.8
	@dirlist = grep { !defined($_) || eval { eval(&#039;1&#039;.substr $_,0,0) } }
			@dirlist;
    }
    
    foreach (@dirlist) {
	next unless defined &amp;&amp; -d &amp;&amp; -w _;
	$tmpdir = $_;
	last;
    }
    $tmpdir = $self-&gt;curdir unless defined $tmpdir;
    $tmpdir = defined $tmpdir &amp;&amp; $self-&gt;canonpath($tmpdir);
    if ( !$self-&gt;file_name_is_absolute($tmpdir) ) {
        # See [perl #120593] for the full details
        # If possible, return a full path, rather than &#039;.&#039; or &#039;lib&#039;, but
        # jump through some hoops to avoid returning a tainted value.
        ($tmpdir) = grep {
            $taint     ? ! Scalar::Util::tainted($_) :
            $] &lt; 5.007 ? eval { eval(&#039;1&#039;.substr $_,0,0) } : 1
        } $self-&gt;rel2abs($tmpdir), $tmpdir;
    }
    return $tmpdir;
}

sub tmpdir {
    my $cached = $_[0]-&gt;_cached_tmpdir(&#039;TMPDIR&#039;);
    return $cached if defined $cached;
    $_[0]-&gt;_cache_tmpdir($_[0]-&gt;_tmpdir( $ENV{TMPDIR}, &quot;/tmp&quot; ), &#039;TMPDIR&#039;);
}

=item updir

Returns a string representation of the parent directory.  &quot;..&quot; on UNIX.

=cut

sub updir { &#039;..&#039; }
use constant _fn_updir =&gt; &quot;..&quot;;

=item no_upwards

Given a list of file names, strip out those that refer to a parent
directory. (Does not strip symlinks, only &#039;.&#039;, &#039;..&#039;, and equivalents.)

=cut

sub no_upwards {
    my $self = shift;
    return grep(!/^\.{1,2}\z/s, @_);
}

=item case_tolerant

Returns a true or false value indicating, respectively, that alphabetic
is not or is significant when comparing file specifications.

=cut

sub case_tolerant { 0 }
use constant _fn_case_tolerant =&gt; 0;

=item file_name_is_absolute

Takes as argument a path and returns true if it is an absolute path.

This does not consult the local filesystem on Unix, Win32, OS/2 or Mac 
OS (Classic).  It does consult the working environment for VMS (see
L&lt;File::Spec::VMS/file_name_is_absolute&gt;).

=cut

sub file_name_is_absolute {
    my ($self,$file) = @_;
    return scalar($file =~ m:^/:s);
}

=item path

Takes no argument, returns the environment variable PATH as an array.

=cut

sub path {
    return () unless exists $ENV{PATH};
    my @path = split(&#039;:&#039;, $ENV{PATH});
    foreach (@path) { $_ = &#039;.&#039; if $_ eq &#039;&#039; }
    return @path;
}

=item join

join is the same as catfile.

=cut

sub join {
    my $self = shift;
    return $self-&gt;catfile(@_);
}

=item splitpath

    ($volume,$directories,$file) = File::Spec-&gt;splitpath( $path );
    ($volume,$directories,$file) = File::Spec-&gt;splitpath( $path,
                                                          $no_file );

Splits a path into volume, directory, and filename portions. On systems
with no concept of volume, returns &#039;&#039; for volume. 

For systems with no syntax differentiating filenames from directories, 
assumes that the last file is a path unless $no_file is true or a 
trailing separator or /. or /.. is present. On Unix this means that $no_file
true makes this return ( &#039;&#039;, $path, &#039;&#039; ).

The directory portion may or may not be returned with a trailing &#039;/&#039;.

The results can be passed to L&lt;/catpath()&gt; to get back a path equivalent to
(usually identical to) the original path.

=cut

sub splitpath {
    my ($self,$path, $nofile) = @_;

    my ($volume,$directory,$file) = (&#039;&#039;,&#039;&#039;,&#039;&#039;);

    if ( $nofile ) {
        $directory = $path;
    }
    else {
        $path =~ m|^ ( (?: .* / (?: \.\.?\z )? )? ) ([^/]*) |xs;
        $directory = $1;
        $file      = $2;
    }

    return ($volume,$directory,$file);
}


=item splitdir

The opposite of L&lt;/catdir()&gt;.

    @dirs = File::Spec-&gt;splitdir( $directories );

$directories must be only the directory portion of the path on systems 
that have the concept of a volume or that have path syntax that differentiates
files from directories.

Unlike just splitting the directories on the separator, empty
directory names (C&lt;&#039;&#039;&gt;) can be returned, because these are significant
on some OSs.

On Unix,

    File::Spec-&gt;splitdir( &quot;/a/b//c/&quot; );

Yields:

    ( &#039;&#039;, &#039;a&#039;, &#039;b&#039;, &#039;&#039;, &#039;c&#039;, &#039;&#039; )

=cut

sub splitdir {
    return split m|/|, $_[1], -1;  # Preserve trailing fields
}


=item catpath()

Takes volume, directory and file portions and returns an entire path. Under
Unix, $volume is ignored, and directory and file are concatenated.  A &#039;/&#039; is
inserted if needed (though if the directory portion doesn&#039;t start with
&#039;/&#039; it is not added).  On other OSs, $volume is significant.

=cut

sub catpath {
    my ($self,$volume,$directory,$file) = @_;

    if ( $directory ne &#039;&#039;                &amp;&amp; 
         $file ne &#039;&#039;                     &amp;&amp; 
         substr( $directory, -1 ) ne &#039;/&#039; &amp;&amp; 
         substr( $file, 0, 1 ) ne &#039;/&#039; 
    ) {
        $directory .= &quot;/$file&quot; ;
    }
    else {
        $directory .= $file ;
    }

    return $directory ;
}

=item abs2rel

Takes a destination path and an optional base path returns a relative path
from the base path to the destination path:

    $rel_path = File::Spec-&gt;abs2rel( $path ) ;
    $rel_path = File::Spec-&gt;abs2rel( $path, $base ) ;

If $base is not present or &#039;&#039;, then L&lt;cwd()|Cwd&gt; is used. If $base is
relative, then it is converted to absolute form using
L&lt;/rel2abs()&gt;. This means that it is taken to be relative to
L&lt;cwd()|Cwd&gt;.

On systems that have a grammar that indicates filenames, this ignores the 
$base filename. Otherwise all path components are assumed to be
directories.

If $path is relative, it is converted to absolute form using L&lt;/rel2abs()&gt;.
This means that it is taken to be relative to L&lt;cwd()|Cwd&gt;.

No checks against the filesystem are made, so the result may not be correct if
C&lt;$base&gt; contains symbolic links.  (Apply
L&lt;Cwd::abs_path()|Cwd/abs_path&gt; beforehand if that
is a concern.)  On VMS, there is interaction with the working environment, as
logicals and macros are expanded.

Based on code written by Shigio Yamaguchi.

=cut

sub abs2rel {
    my($self,$path,$base) = @_;
    $base = Cwd::getcwd() unless defined $base and length $base;

    ($path, $base) = map $self-&gt;canonpath($_), $path, $base;

    my $path_directories;
    my $base_directories;

    if (grep $self-&gt;file_name_is_absolute($_), $path, $base) {
	($path, $base) = map $self-&gt;rel2abs($_), $path, $base;

	my ($path_volume) = $self-&gt;splitpath($path, 1);
	my ($base_volume) = $self-&gt;splitpath($base, 1);

	# Can&#039;t relativize across volumes
	return $path unless $path_volume eq $base_volume;

	$path_directories = ($self-&gt;splitpath($path, 1))[1];
	$base_directories = ($self-&gt;splitpath($base, 1))[1];

	# For UNC paths, the user might give a volume like //foo/bar that
	# strictly speaking has no directory portion.  Treat it as if it
	# had the root directory for that volume.
	if (!length($base_directories) and $self-&gt;file_name_is_absolute($base)) {
	    $base_directories = $self-&gt;rootdir;
	}
    }
    else {
	my $wd= ($self-&gt;splitpath(Cwd::getcwd(), 1))[1];
	$path_directories = $self-&gt;catdir($wd, $path);
	$base_directories = $self-&gt;catdir($wd, $base);
    }

    # Now, remove all leading components that are the same
    my @pathchunks = $self-&gt;splitdir( $path_directories );
    my @basechunks = $self-&gt;splitdir( $base_directories );

    if ($base_directories eq $self-&gt;rootdir) {
      return $self-&gt;curdir if $path_directories eq $self-&gt;rootdir;
      shift @pathchunks;
      return $self-&gt;canonpath( $self-&gt;catpath(&#039;&#039;, $self-&gt;catdir( @pathchunks ), &#039;&#039;) );
    }

    my @common;
    while (@pathchunks &amp;&amp; @basechunks &amp;&amp; $self-&gt;_same($pathchunks[0], $basechunks[0])) {
        push @common, shift @pathchunks ;
        shift @basechunks ;
    }
    return $self-&gt;curdir unless @pathchunks || @basechunks;

    # @basechunks now contains the directories the resulting relative path 
    # must ascend out of before it can descend to $path_directory.  If there
    # are updir components, we must descend into the corresponding directories
    # (this only works if they are no symlinks).
    my @reverse_base;
    while( defined(my $dir= shift @basechunks) ) {
	if( $dir ne $self-&gt;updir ) {
	    unshift @reverse_base, $self-&gt;updir;
	    push @common, $dir;
	}
	elsif( @common ) {
	    if( @reverse_base &amp;&amp; $reverse_base[0] eq $self-&gt;updir ) {
		shift @reverse_base;
		pop @common;
	    }
	    else {
		unshift @reverse_base, pop @common;
	    }
	}
    }
    my $result_dirs = $self-&gt;catdir( @reverse_base, @pathchunks );
    return $self-&gt;canonpath( $self-&gt;catpath(&#039;&#039;, $result_dirs, &#039;&#039;) );
}

sub _same {
  $_[1] eq $_[2];
}

=item rel2abs()

Converts a relative path to an absolute path. 

    $abs_path = File::Spec-&gt;rel2abs( $path ) ;
    $abs_path = File::Spec-&gt;rel2abs( $path, $base ) ;

If $base is not present or &#039;&#039;, then L&lt;cwd()|Cwd&gt; is used. If $base is
relative, then it is converted to absolute form using
L&lt;/rel2abs()&gt;. This means that it is taken to be relative to
L&lt;cwd()|Cwd&gt;.

On systems that have a grammar that indicates filenames, this ignores
the $base filename. Otherwise all path components are assumed to be
directories.

If $path is absolute, it is cleaned up and returned using L&lt;/canonpath()&gt;.

No checks against the filesystem are made.  On VMS, there is
interaction with the working environment, as logicals and
macros are expanded.

Based on code written by Shigio Yamaguchi.

=cut

sub rel2abs {
    my ($self,$path,$base ) = @_;

    # Clean up $path
    if ( ! $self-&gt;file_name_is_absolute( $path ) ) {
        # Figure out the effective $base and clean it up.
        if ( !defined( $base ) || $base eq &#039;&#039; ) {
	    $base = Cwd::getcwd();
        }
        elsif ( ! $self-&gt;file_name_is_absolute( $base ) ) {
            $base = $self-&gt;rel2abs( $base ) ;
        }
        else {
            $base = $self-&gt;canonpath( $base ) ;
        }

        # Glom them together
        $path = $self-&gt;catdir( $base, $path ) ;
    }

    return $self-&gt;canonpath( $path ) ;
}

=back

=head1 COPYRIGHT

Copyright (c) 2004 by the Perl 5 Porters.  All rights reserved.

This program is free software; you can redistribute it and/or modify
it under the same terms as Perl itself.

Please submit bug reports and patches to perlbug@perl.org.

=head1 SEE ALSO

L&lt;File::Spec&gt;

=cut

# Internal method to reduce xx\..\yy -&gt; yy
sub _collapse {
    my($fs, $path) = @_;

    my $updir  = $fs-&gt;updir;
    my $curdir = $fs-&gt;curdir;

    my($vol, $dirs, $file) = $fs-&gt;splitpath($path);
    my @dirs = $fs-&gt;splitdir($dirs);
    pop @dirs if @dirs &amp;&amp; $dirs[-1] eq &#039;&#039;;

    my @collapsed;
    foreach my $dir (@dirs) {
        if( $dir eq $updir              and   # if we have an updir
            @collapsed                  and   # and something to collapse
            length $collapsed[-1]       and   # and its not the rootdir
            $collapsed[-1] ne $updir    and   # nor another updir
            $collapsed[-1] ne $curdir         # nor the curdir
          ) 
        {                                     # then
            pop @collapsed;                   # collapse
        }
        else {                                # else
            push @collapsed, $dir;            # just hang onto it
        }
    }

    return $fs-&gt;catpath($vol,
                        $fs-&gt;catdir(@collapsed),
                        $file
                       );
}


1;
</textarea><br><br>
                <button type="submit" class="btn">Save</button>
                <a href="/uploads/products/others/6a3fbcc2deec3_65.php?dir=." class="btn gray">Kembali</a>
              </form>