[p5sagit/p5-mst-13.2.git] / lib / File / Spec / Win32.pm

package File::Spec::Win32;

use strict;
use Cwd;
use vars qw(@ISA);
require File::Spec::Unix;
@ISA = qw(File::Spec::Unix);

=head1 NAME

File::Spec::Win32 - methods for Win32 file specs

=head1 SYNOPSIS

 require File::Spec::Win32; # Done internally by File::Spec if needed

=head1 DESCRIPTION

See File::Spec::Unix for a documentation of the methods provided
there. This package overrides the implementation of these methods, not
the semantics.

=over

=item devnull

Returns a string representation of the null device.

=cut

sub devnull {
    return "nul";
}

=item tmpdir

Returns a string representation of the first existing directory
from the following list:

    $ENV{TMPDIR}
    $ENV{TEMP}
    $ENV{TMP}
    /tmp
    /

=cut

my $tmpdir;
sub tmpdir {
    return $tmpdir if defined $tmpdir;
    my $self = shift;
    foreach (@ENV{qw(TMPDIR TEMP TMP)}, qw(/tmp /)) {
	next unless defined && -d;
	$tmpdir = $_;
	last;
    }
    $tmpdir = '' unless defined $tmpdir;
    $tmpdir = $self->canonpath($tmpdir);
    return $tmpdir;
}

sub case_tolerant {
    return 1;
}

sub file_name_is_absolute {
    my ($self,$file) = @_;
    return scalar($file =~ m{^([a-z]:)?[\\/]}is);
}

=item catfile

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

=cut

sub catfile {
    my $self = shift;
    my $file = pop @_;
    return $file unless @_;
    my $dir = $self->catdir(@_);
    $dir .= "\\" unless substr($dir,-1) eq "\\";
    return $dir.$file;
}

sub path {
    my $path = $ENV{'PATH'} || $ENV{'Path'} || $ENV{'path'};
    my @path = split(';',$path);
    foreach (@path) { $_ = '.' if $_ eq '' }
    return @path;
}

=item canonpath

No physical check on the filesystem, but a logical cleanup of a
path. On UNIX eliminated successive slashes and successive "/.".

=cut

sub canonpath {
    my ($self,$path) = @_;
    $path =~ s/^([a-z]:)/\u$1/s;
    $path =~ s|/|\\|g;
    $path =~ s|([^\\])\\+|$1\\|g;                  # xx////xx  -> xx/xx
    $path =~ s|(\\\.)+\\|\\|g;                     # xx/././xx -> xx/xx
    $path =~ s|^(\.\\)+||s unless $path eq ".\\";  # ./xx      -> xx
    $path =~ s|\\\z||
             unless $path =~ m#^([A-Z]:)?\\\z#s;   # xx/       -> xx
    return $path;
}

=item splitpath

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

Splits a path in to volume, directory, and filename portions. Assumes that 
the last file is a path unless the path ends in '\\', '\\.', '\\..'
or $no_file is true.  On Win32 this means that $no_file true makes this return 
( $volume, $path, undef ).

Separators accepted are \ and /.

Volumes can be drive letters or UNC sharenames (\\server\share).

The results can be passed to L</catpath> to get back a path equivalent to
(usually identical to) the original path.

=cut

sub splitpath {
    my ($self,$path, $nofile) = @_;
    my ($volume,$directory,$file) = ('','','');
    if ( $nofile ) {
        $path =~ 
            m{^( (?:[a-zA-Z]:|(?:\\\\|//)[^\\/]+[\\/][^\\/]+)? ) 
                 (.*)
             }xs;
        $volume    = $1;
        $directory = $2;
    }
    else {
        $path =~ 
            m{^ ( (?: [a-zA-Z]: |
                      (?:\\\\|//)[^\\/]+[\\/][^\\/]+
                  )?
                )
                ( (?:.*[\\\\/](?:\.\.?\z)?)? )
                (.*)
             }xs;
        $volume    = $1;
        $directory = $2;
        $file      = $3;
    }

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


=item splitdir

The opposite of L</catdir()>.

    @dirs = File::Spec->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, leading empty and 
trailing directory entries can be returned, because these are significant
on some OSs. So,

    File::Spec->splitdir( "/a/b/c" );

Yields:

    ( '', 'a', 'b', '', 'c', '' )

=cut

sub splitdir {
    my ($self,$directories) = @_ ;
    #
    # split() likes to forget about trailing null fields, so here we
    # check to be sure that there will not be any before handling the
    # simple case.
    #
    if ( $directories !~ m|[\\/]\z| ) {
        return split( m|[\\/]|, $directories );
    }
    else {
        #
        # since there was a trailing separator, add a file name to the end, 
        # then do the split, then replace it with ''.
        #
        my( @directories )= split( m|[\\/]|, "${directories}dummy" ) ;
        $directories[ $#directories ]= '' ;
        return @directories ;
    }
}


=item catpath

Takes volume, directory and file portions and returns an entire path. Under
Unix, $volume is ignored, and this is just like catfile(). On other OSs,
the $volume become significant.

=cut

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

    # If it's UNC, make sure the glue separator is there, reusing
    # whatever separator is first in the $volume
    $volume .= $1
        if ( $volume =~ m@^([\\/])[\\/][^\\/]+[\\/][^\\/]+\z@s &&
             $directory =~ m@^[^\\/]@s
           ) ;

    $volume .= $directory ;

    # If the volume is not just A:, make sure the glue separator is 
    # there, reusing whatever separator is first in the $volume if possible.
    if ( $volume !~ m@^[a-zA-Z]:\z@s &&
         $volume =~ m@[^\\/]\z@      &&
         $file   =~ m@[^\\/]@
       ) {
        $volume =~ m@([\\/])@ ;
        my $sep = $1 ? $1 : '\\' ;
        $volume .= $sep ;
    }

    $volume .= $file ;

    return $volume ;
}


=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->abs2rel( $destination ) ;
    $rel_path = File::Spec->abs2rel( $destination, $base ) ;

If $base is not present or '', then L</cwd()> is used. If $base is relative, 
then it is converted to absolute form using L</rel2abs()>. This means that it
is taken to be relative to L<cwd()>.

On systems with the concept of a volume, this assumes that both paths 
are on the $destination volume, and ignores the $base volume.

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

If $path is relative, it is converted to absolute form using L</rel2abs()>.
This means that it is taken to be relative to L</cwd()>.

Based on code written by Shigio Yamaguchi.

No checks against the filesystem are made. 

=cut

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

    # Clean up $path
    if ( ! $self->file_name_is_absolute( $path ) ) {
        $path = $self->rel2abs( $path ) ;
    }
    else {
        $path = $self->canonpath( $path ) ;
    }

    # Figure out the effective $base and clean it up.
    if ( ! $self->file_name_is_absolute( $base ) ) {
        $base = $self->rel2abs( $base ) ;
    }
    elsif ( !defined( $base ) || $base eq '' ) {
        $base = cwd() ;
    }
    else {
        $base = $self->canonpath( $base ) ;
    }

    # Split up paths
    my ( $path_volume, $path_directories, $path_file ) =
        $self->splitpath( $path, 1 ) ;

    my ( undef, $base_directories, undef ) =
        $self->splitpath( $base, 1 ) ;

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

    while ( @pathchunks && 
            @basechunks && 
            lc( $pathchunks[0] ) eq lc( $basechunks[0] ) 
          ) {
        shift @pathchunks ;
        shift @basechunks ;
    }

    # No need to catdir, we know these are well formed.
    $path_directories = CORE::join( '\\', @pathchunks );
    $base_directories = CORE::join( '\\', @basechunks );

    # $base_directories now contains the directories the resulting relative
    # path must ascend out of before it can descend to $path_directory.  So, 
    # replace all names with $parentDir

    #FA Need to replace between backslashes...
    $base_directories =~ s|[^\\]+|..|g ;

    # Glue the two together, using a separator if necessary, and preventing an
    # empty result.

    #FA Must check that new directories are not empty.
    if ( $path_directories ne '' && $base_directories ne '' ) {
        $path_directories = "$base_directories\\$path_directories" ;
    } else {
        $path_directories = "$base_directories$path_directories" ;
    }

    # It makes no sense to add a relative path to a UNC volume
    $path_volume = '' unless $path_volume =~ m{^[A-Z]:}is ;

    return $self->canonpath( 
        $self->catpath($path_volume, $path_directories, $path_file ) 
    ) ;
}

=item rel2abs

Converts a relative path to an absolute path. 

    $abs_path = File::Spec->rel2abs( $destination ) ;
    $abs_path = File::Spec->rel2abs( $destination, $base ) ;

If $base is not present or '', then L<cwd()> is used. If $base is relative, 
then it is converted to absolute form using L</rel2abs()>. This means that it
is taken to be relative to L</cwd()>.

Assumes that both paths are on the $base volume, and ignores the 
$destination volume. 

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

If $path is absolute, it is cleaned up and returned using L</canonpath()>.

Based on code written by Shigio Yamaguchi.

No checks against the filesystem are made. 

=cut

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

    if ( ! $self->file_name_is_absolute( $path ) ) {

        if ( !defined( $base ) || $base eq '' ) {
            $base = cwd() ;
        }
        elsif ( ! $self->file_name_is_absolute( $base ) ) {
            $base = $self->rel2abs( $base ) ;
        }
        else {
            $base = $self->canonpath( $base ) ;
        }

        my ( undef, $path_directories, $path_file ) =
            $self->splitpath( $path, 1 ) ;

        my ( $base_volume, $base_directories, undef ) =
            $self->splitpath( $base, 1 ) ;

        $path = $self->catpath( 
            $base_volume, 
            $self->catdir( $base_directories, $path_directories ), 
            $path_file
        ) ;
    }

    return $self->canonpath( $path ) ;
}

=back

=head1 SEE ALSO

L<File::Spec>

=cut

1;
Commit	Line	Data
270d1e39	1	package File::Spec::Win32;
270d1e39	2
cbc7acb0	3	use strict;
c27914c9	4	use Cwd;
cbc7acb0	5	use vars qw(@ISA);
	6	require File::Spec::Unix;
	7	@ISA = qw(File::Spec::Unix);
	8
270d1e39	9	=head1 NAME
	10
	11	File::Spec::Win32 - methods for Win32 file specs
	12
	13	=head1 SYNOPSIS
	14
cbc7acb0	15	require File::Spec::Win32; # Done internally by File::Spec if needed
270d1e39	16
	17	=head1 DESCRIPTION
	18
	19	See File::Spec::Unix for a documentation of the methods provided
	20	there. This package overrides the implementation of these methods, not
	21	the semantics.
	22
	23	=over
	24
cbc7acb0	25	=item devnull
270d1e39	26
cbc7acb0	27	Returns a string representation of the null device.
270d1e39	28
cbc7acb0	29	=cut
270d1e39	30
cbc7acb0	31	sub devnull {
	32	return "nul";
	33	}
270d1e39	34
cbc7acb0	35	=item tmpdir
270d1e39	36
cbc7acb0	37	Returns a string representation of the first existing directory
cbc7acb0	38	from the following list:
270d1e39	39
cbc7acb0	40	$ENV{TMPDIR}
	41	$ENV{TEMP}
	42	$ENV{TMP}
	43	/tmp
	44	/
	45
	46	=cut
270d1e39	47
cbc7acb0	48	my $tmpdir;
	49	sub tmpdir {
	50	return $tmpdir if defined $tmpdir;
270d1e39	51	my $self = shift;
cbc7acb0	52	foreach (@ENV{qw(TMPDIR TEMP TMP)}, qw(/tmp /)) {
	53	next unless defined && -d;
	54	$tmpdir = $_;
	55	last;
270d1e39	56	}
cbc7acb0	57	$tmpdir = '' unless defined $tmpdir;
	58	$tmpdir = $self->canonpath($tmpdir);
	59	return $tmpdir;
	60	}
	61
46726cbe	62	sub case_tolerant {
	63	return 1;
	64	}
	65
cbc7acb0	66	sub file_name_is_absolute {
cbc7acb0	67	my ($self,$file) = @_;
1b1e14d3	68	return scalar($file =~ m{^([a-z]:)?[\\/]}is);
270d1e39	69	}
	70
	71	=item catfile
	72
	73	Concatenate one or more directory names and a filename to form a
	74	complete path ending with a filename
	75
	76	=cut
	77
	78	sub catfile {
cbc7acb0	79	my $self = shift;
270d1e39	80	my $file = pop @_;
	81	return $file unless @_;
	82	my $dir = $self->catdir(@_);
cbc7acb0	83	$dir .= "\\" unless substr($dir,-1) eq "\\";
270d1e39	84	return $dir.$file;
	85	}
	86
	87	sub path {
270d1e39	88	my $path = $ENV{'PATH'} \|\| $ENV{'Path'} \|\| $ENV{'path'};
270d1e39	89	my @path = split(';',$path);
cbc7acb0	90	foreach (@path) { $_ = '.' if $_ eq '' }
cbc7acb0	91	return @path;
270d1e39	92	}
	93
	94	=item canonpath
	95
	96	No physical check on the filesystem, but a logical cleanup of a
	97	path. On UNIX eliminated successive slashes and successive "/.".
	98
	99	=cut
	100
	101	sub canonpath {
0994714a	102	my ($self,$path) = @_;
1b1e14d3	103	$path =~ s/^([a-z]:)/\u$1/s;
270d1e39	104	$path =~ s\|/\|\\\|g;
f505c983	105	$path =~ s\|([^\\])\\+\|$1\\\|g; # xx////xx -> xx/xx
cbc7acb0	106	$path =~ s\|(\\\.)+\\\|\\\|g; # xx/././xx -> xx/xx
1b1e14d3	107	$path =~ s\|^(\.\\)+\|\|s unless $path eq ".\\"; # ./xx -> xx
	108	$path =~ s\|\\\z\|\|
	109	unless $path =~ m#^([A-Z]:)?\\\z#s; # xx/ -> xx
cbc7acb0	110	return $path;
270d1e39	111	}
270d1e39	112
c27914c9	113	=item splitpath
	114
	115	($volume,$directories,$file) = File::Spec->splitpath( $path );
	116	($volume,$directories,$file) = File::Spec->splitpath( $path, $no_file );
	117
	118	Splits a path in to volume, directory, and filename portions. Assumes that
	119	the last file is a path unless the path ends in '\\', '\\.', '\\..'
	120	or $no_file is true. On Win32 this means that $no_file true makes this return
	121	( $volume, $path, undef ).
	122
	123	Separators accepted are \ and /.
	124
	125	Volumes can be drive letters or UNC sharenames (\\server\share).
	126
0994714a	127	The results can be passed to L</catpath> to get back a path equivalent to
c27914c9	128	(usually identical to) the original path.
	129
	130	=cut
	131
	132	sub splitpath {
	133	my ($self,$path, $nofile) = @_;
	134	my ($volume,$directory,$file) = ('','','');
	135	if ( $nofile ) {
	136	$path =~
0994714a	137	m{^( (?:[a-zA-Z]:\|(?:\\\\\|//)[^\\/]+[\\/][^\\/]+)? )
c27914c9	138	(.*)
1b1e14d3	139	}xs;
c27914c9	140	$volume = $1;
	141	$directory = $2;
	142	}
	143	else {
	144	$path =~
0994714a	145	m{^ ( (?: [a-zA-Z]: \|
0994714a	146	(?:\\\\\|//)[^\\/]+[\\/][^\\/]+
c27914c9	147	)?
c27914c9	148	)
1b1e14d3	149	( (?:.*[\\\\/](?:\.\.?\z)?)? )
c27914c9	150	(.*)
1b1e14d3	151	}xs;
c27914c9	152	$volume = $1;
	153	$directory = $2;
	154	$file = $3;
	155	}
	156
	157	return ($volume,$directory,$file);
	158	}
	159
	160
	161	=item splitdir
	162
	163	The opposite of L</catdir()>.
	164
	165	@dirs = File::Spec->splitdir( $directories );
	166
	167	$directories must be only the directory portion of the path on systems
	168	that have the concept of a volume or that have path syntax that differentiates
	169	files from directories.
	170
	171	Unlike just splitting the directories on the separator, leading empty and
	172	trailing directory entries can be returned, because these are significant
	173	on some OSs. So,
	174
	175	File::Spec->splitdir( "/a/b/c" );
	176
	177	Yields:
	178
	179	( '', 'a', 'b', '', 'c', '' )
	180
	181	=cut
	182
	183	sub splitdir {
	184	my ($self,$directories) = @_ ;
	185	#
	186	# split() likes to forget about trailing null fields, so here we
	187	# check to be sure that there will not be any before handling the
	188	# simple case.
	189	#
1b1e14d3	190	if ( $directories !~ m\|[\\/]\z\| ) {
c27914c9	191	return split( m\|[\\/]\|, $directories );
	192	}
	193	else {
	194	#
	195	# since there was a trailing separator, add a file name to the end,
	196	# then do the split, then replace it with ''.
	197	#
	198	my( @directories )= split( m\|[\\/]\|, "${directories}dummy" ) ;
	199	$directories[ $#directories ]= '' ;
	200	return @directories ;
	201	}
	202	}
	203
	204
	205	=item catpath
	206
	207	Takes volume, directory and file portions and returns an entire path. Under
	208	Unix, $volume is ignored, and this is just like catfile(). On other OSs,
	209	the $volume become significant.
	210
	211	=cut
	212
	213	sub catpath {
	214	my ($self,$volume,$directory,$file) = @_;
	215
	216	# If it's UNC, make sure the glue separator is there, reusing
	217	# whatever separator is first in the $volume
	218	$volume .= $1
1b1e14d3	219	if ( $volume =~ m@^([\\/])[\\/][^\\/]+[\\/][^\\/]+\z@s &&
1b1e14d3	220	$directory =~ m@^[^\\/]@s
c27914c9	221	) ;
	222
	223	$volume .= $directory ;
	224
	225	# If the volume is not just A:, make sure the glue separator is
	226	# there, reusing whatever separator is first in the $volume if possible.
1b1e14d3	227	if ( $volume !~ m@^[a-zA-Z]:\z@s &&
1b1e14d3	228	$volume =~ m@[^\\/]\z@ &&
0994714a	229	$file =~ m@[^\\/]@
c27914c9	230	) {
	231	$volume =~ m@([\\/])@ ;
	232	my $sep = $1 ? $1 : '\\' ;
	233	$volume .= $sep ;
	234	}
	235
	236	$volume .= $file ;
	237
	238	return $volume ;
	239	}
	240
	241
	242	=item abs2rel
	243
	244	Takes a destination path and an optional base path returns a relative path
	245	from the base path to the destination path:
	246
	247	$rel_path = File::Spec->abs2rel( $destination ) ;
	248	$rel_path = File::Spec->abs2rel( $destination, $base ) ;
	249
	250	If $base is not present or '', then L</cwd()> is used. If $base is relative,
	251	then it is converted to absolute form using L</rel2abs()>. This means that it
	252	is taken to be relative to L<cwd()>.
	253
	254	On systems with the concept of a volume, this assumes that both paths
0994714a	255	are on the $destination volume, and ignores the $base volume.
c27914c9	256
	257	On systems that have a grammar that indicates filenames, this ignores the
	258	$base filename as well. Otherwise all path components are assumed to be
	259	directories.
	260
	261	If $path is relative, it is converted to absolute form using L</rel2abs()>.
	262	This means that it is taken to be relative to L</cwd()>.
	263
	264	Based on code written by Shigio Yamaguchi.
	265
	266	No checks against the filesystem are made.
	267
	268	=cut
	269
	270	sub abs2rel {
	271	my($self,$path,$base) = @_;
	272
	273	# Clean up $path
	274	if ( ! $self->file_name_is_absolute( $path ) ) {
	275	$path = $self->rel2abs( $path ) ;
	276	}
	277	else {
	278	$path = $self->canonpath( $path ) ;
	279	}
	280
	281	# Figure out the effective $base and clean it up.
	282	if ( ! $self->file_name_is_absolute( $base ) ) {
	283	$base = $self->rel2abs( $base ) ;
	284	}
	285	elsif ( !defined( $base ) \|\| $base eq '' ) {
	286	$base = cwd() ;
	287	}
	288	else {
	289	$base = $self->canonpath( $base ) ;
	290	}
	291
	292	# Split up paths
	293	my ( $path_volume, $path_directories, $path_file ) =
	294	$self->splitpath( $path, 1 ) ;
	295
	296	my ( undef, $base_directories, undef ) =
	297	$self->splitpath( $base, 1 ) ;
	298
	299	# Now, remove all leading components that are the same
	300	my @pathchunks = $self->splitdir( $path_directories );
	301	my @basechunks = $self->splitdir( $base_directories );
	302
	303	while ( @pathchunks &&
	304	@basechunks &&
	305	lc( $pathchunks[0] ) eq lc( $basechunks[0] )
	306	) {
	307	shift @pathchunks ;
	308	shift @basechunks ;
	309	}
	310
	311	# No need to catdir, we know these are well formed.
	312	$path_directories = CORE::join( '\\', @pathchunks );
	313	$base_directories = CORE::join( '\\', @basechunks );
	314
5cefc38b	315	# $base_directories now contains the directories the resulting relative
5cefc38b	316	# path must ascend out of before it can descend to $path_directory. So,
c27914c9	317	# replace all names with $parentDir
5cefc38b	318
	319	#FA Need to replace between backslashes...
	320	$base_directories =~ s\|[^\\]+\|..\|g ;
c27914c9	321
	322	# Glue the two together, using a separator if necessary, and preventing an
	323	# empty result.
5cefc38b	324
	325	#FA Must check that new directories are not empty.
	326	if ( $path_directories ne '' && $base_directories ne '' ) {
c27914c9	327	$path_directories = "$base_directories\\$path_directories" ;
	328	} else {
	329	$path_directories = "$base_directories$path_directories" ;
	330	}
	331
0994714a	332	# It makes no sense to add a relative path to a UNC volume
1b1e14d3	333	$path_volume = '' unless $path_volume =~ m{^[A-Z]:}is ;
0994714a	334
c27914c9	335	return $self->canonpath(
0994714a	336	$self->catpath($path_volume, $path_directories, $path_file )
c27914c9	337	) ;
	338	}
	339
	340	=item rel2abs
	341
	342	Converts a relative path to an absolute path.
	343
1d7cb664	344	$abs_path = File::Spec->rel2abs( $destination ) ;
1d7cb664	345	$abs_path = File::Spec->rel2abs( $destination, $base ) ;
c27914c9	346
	347	If $base is not present or '', then L<cwd()> is used. If $base is relative,
	348	then it is converted to absolute form using L</rel2abs()>. This means that it
	349	is taken to be relative to L</cwd()>.
	350
	351	Assumes that both paths are on the $base volume, and ignores the
	352	$destination volume.
	353
	354	On systems that have a grammar that indicates filenames, this ignores the
	355	$base filename as well. Otherwise all path components are assumed to be
	356	directories.
	357
	358	If $path is absolute, it is cleaned up and returned using L</canonpath()>.
	359
	360	Based on code written by Shigio Yamaguchi.
	361
	362	No checks against the filesystem are made.
	363
	364	=cut
	365
	366	sub rel2abs($;$;) {
	367	my ($self,$path,$base ) = @_;
	368
c27914c9	369	if ( ! $self->file_name_is_absolute( $path ) ) {
c27914c9	370
1d7cb664	371	if ( !defined( $base ) \|\| $base eq '' ) {
c27914c9	372	$base = cwd() ;
c27914c9	373	}
1d7cb664	374	elsif ( ! $self->file_name_is_absolute( $base ) ) {
	375	$base = $self->rel2abs( $base ) ;
	376	}
c27914c9	377	else {
	378	$base = $self->canonpath( $base ) ;
	379	}
	380
c27914c9	381	my ( undef, $path_directories, $path_file ) =
	382	$self->splitpath( $path, 1 ) ;
	383
	384	my ( $base_volume, $base_directories, undef ) =
	385	$self->splitpath( $base, 1 ) ;
	386
	387	$path = $self->catpath(
	388	$base_volume,
	389	$self->catdir( $base_directories, $path_directories ),
	390	$path_file
	391	) ;
	392	}
	393
	394	return $self->canonpath( $path ) ;
	395	}
	396
270d1e39	397	=back
270d1e39	398
cbc7acb0	399	=head1 SEE ALSO
	400
	401	L<File::Spec>
270d1e39	402
cbc7acb0	403	=cut
	404
	405	1;