file::spec::mac(3)

NAME

File::Spec::Mac - File::Spec for Mac OS (Classic)

SYNOPSIS

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

DESCRIPTION

Methods for manipulating file specifications.

METHODS

canonpath: On Mac OS, there's nothing to be done. Returns what it's
given.
catdir(): Concatenate two or more directory names to form a path
separated by colons (":") ending with a directory.
Resulting paths are relative by default, but can be
forced to be absolute (but avoid this, see below). Auto
matically puts a trailing ":" on the end of the complete
path, because that's what's done in MacPerl's environ
ment and helps to distinguish a file path from a direc
tory path.; IMPORTANT NOTE: Beginning with version 1.3 of this mod ule, the resulting path is relative by default and not
absolute. This descision was made due to portability
reasons. Since "File::Spec->catdir()" returns relative
paths on all other operating systems, it will now also
follow this convention on Mac OS. Note that this may
break some existing scripts.; The intended purpose of this routine is to concatenate
directory names. But because of the nature of Macintosh paths, some additional possibilities are allowed to make
using this routine give reasonable results for some com
mon situations. In other words, you are also allowed to
concatenate paths instead of directory names (strictly
speaking, a string like ":a" is a path, but not a name,
since it contains a punctuation character ":").; So, beside calls like

catdir("a") = ":a:"
catdir("a","b") = ":a:b:"
catdir() = "" (special case); calls like the following

catdir(":a:") = ":a:"
catdir(":a","b") = ":a:b:"
catdir(":a:","b") = ":a:b:"
catdir(":a:",":b:") = ":a:b:"
catdir(":") = ":"; are allowed.; Here are the rules that are used in "catdir()"; note
that we try to be as compatible as possible to Unix:; 1.
The resulting path is relative by default, i.e. the
resulting path will have a leading colon.; 2.
A trailing colon is added automatically to the result
ing path, to denote a directory.; 3.
Generally, each argument has one leading ":" and one
trailing ":" removed (if any). They are then joined
together by a ":". Special treatment applies for argu
ments denoting updir paths like "::lib:", see (4), or
arguments consisting solely of colons ("colon paths"),
see (5).; 4.
When an updir path like ":::lib::" is passed as argu
ment, the number of directories to climb up is handled
correctly, not removing leading or trailing colons
when necessary. E.g.

catdir(":::a","::b","c") = ":::a::b:c:"
catdir(":::a::","::b","c") = ":::a:::b:c:"

5.

Adding a colon ":" or empty string "" to a path at any
position doesn't alter the path, i.e. these arguments
are ignored. (When a "" is passed as the first argu
ment, it has a special meaning, see (6)). This way, a
colon ":" is handled like a "." (curdir) on Unix,
while an empty string "" is generally ignored (see
"Unix->canonpath()" ). Likewise, a "::" is handled
like a ".." (updir), and a ":::" is handled like a
"../.." etc. E.g.

catdir("a",":",":","b") = ":a:b:"
catdir("a",":","::",":b") = ":a::b:"

6.

If the first argument is an empty string "" or is a
volume name, i.e. matches the pattern /^[^:]+:/, the
resulting path is absolute.

7.

Passing an empty string "" as the first argument to
"catdir()" is like passing"File::Spec->rootdir()" as
the first argument, i.e.

catdir("","a","b") is the same as

catdir(rootdir(),"a","b").

This is true on Unix, where "catdir("","a","b")"
yields "/a/b" and "rootdir()" is "/". Note that "root
dir()" on Mac OS is the startup volume, which is the
closest in concept to Unix' "/". This should help to
run existing scripts originally written for Unix.

8.

For absolute paths, some cleanup is done, to ensure
that the volume name isn't immediately followed by
updirs. This is invalid, because this would go beyond
"root". Generally, these cases are handled like their
Unix counterparts:

Unix:
Unix->catdir("","") = "/"
Unix->catdir("",".") = "/"
Unix->catdir("","..") = "/"

# can't go beyond root
Unix->catdir("",".","..","..","a") = "/a"

Mac:

Mac->catdir("","") = rootdir()

# (e.g. "HD:")
Mac->catdir("",":") = rootdir()
Mac->catdir("","::") = rootdir()

# can't go beyond root
Mac->catdir("",":","::","::","a") = rootdir() .

"a:" # (e.g. "HD:a:")

However, this approach is limited to the first argu
ments following "root" (again, see "Unix->canonpath()"
). If there are more arguments that move up the direc
tory tree, an invalid path going beyond root can be
created.

As you've seen, you can force "catdir()" to create an
absolute path by passing either an empty string or a
path that begins with a volume name as the first argu
ment. However, you are strongly encouraged not to do so,
since this is done only for backward compatibility.
Newer versions of File::Spec come with a method called
"catpath()" (see below), that is designed to offer a
portable solution for the creation of absolute paths.
It takes volume, directory and file portions and returns
an entire path. While "catdir()" is still suitable for
the concatenation of directory names, you are encouraged to use "catpath()" to concatenate volume names and directory paths. E.g.

$dir = File::Spec->catdir("tmp","sources");
$abs_path = File::Spec->catpath("MacintoshHD:",

$dir,"");

yields

"MacintoshHD:tmp:sources:" .

catfile

Concatenate one or more directory names and a filename
to form a complete path ending with a filename. Result
ing paths are relative by default, but can be forced to be absolute (but avoid this).

IMPORTANT NOTE: Beginning with version 1.3 of this mod ule, the resulting path is relative by default and not
absolute. This descision was made due to portability
reasons. Since "File::Spec->catfile()" returns relative
paths on all other operating systems, it will now also
follow this convention on Mac OS. Note that this may
break some existing scripts.

The last argument is always considered to be the file
portion. Since "catfile()" uses "catdir()" (see above)
for the concatenation of the directory portions (if
any), the following with regard to relative and absolute
paths is true:

catfile("") = ""
catfile("file") = "file"

but

catfile("","") = rootdir() # (e.g.

"HD:")
catfile("","file") = rootdir() . file # (e.g.

"HD:file")
catfile("HD:","file") = "HD:file"

This means that "catdir()" is called only when there are
two or more arguments, as one might expect.

Note that the leading ":" is removed from the filename,
so that

catfile("a","b","file") = ":a:b:file" and

catfile("a","b",":file") = ":a:b:file"

give the same answer.

To concatenate volume names, directory paths and file_ names, you are encouraged to use "catpath()" (see
below).

curdir

Returns a string representing the current directory. On
Mac OS, this is ":".

devnull

Returns a string representing the null device. On Mac
OS, this is "Dev:Null".

rootdir

Returns a string representing the root directory. Under
MacPerl, returns the name of the startup volume, since
that's the closest in concept, although other volumes
aren't rooted there. The name has a trailing ":",
because that's the correct specification for a volume
name on Mac OS.

If Mac::Files could not be loaded, the empty string is
returned.

tmpdir

Returns the contents of $ENV{TMPDIR}, if that directory
exits or the current working directory otherwise. Under
MacPerl, $ENV{TMPDIR} will contain a path like "Macin
toshHD:Temporary Items:", which is a hidden directory on
your startup volume.

updir

Returns a string representing the parent directory. On
Mac OS, this is "::".

file_name_is_absolute

Takes as argument a path and returns true, if it is an
absolute path. If the path has a leading ":", it's a
relative path. Otherwise, it's an absolute path, unless
the path doesn't contain any colons, i.e. it's a name
like "a". In this particular case, the path is consid
ered to be relative (i.e. it is considered to be a file
name). Use ":" in the appropriate place in the path if
you want to distinguish unambiguously. As a special
case, the filename '' is always considered to be abso
lute. Note that with version 1.2 of File::Spec::Mac,
this does no longer consult the local filesystem.

E.g.

File::Spec->file_name_is_absolute("a");

# false (relative)
File::Spec->file_name_is_absolute(":a:b:");

# false (relative)
File::Spec->file_name_is_absolute("MacintoshHD:");

# true (absolute)
File::Spec->file_name_is_absolute("");

# true (absolute)

path

Returns the null list for the MacPerl application, since
the concept is usually meaningless under Mac OS. But if
you're using the MacPerl tool under MPW, it gives back
$ENV{Commands} suitably split, as is done in :lib:ExtU
tils:MM_Mac.pm.

splitpath

($volume,$directories,$file) = File::Spec->split

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

path( $path, $no_file );

Splits a path in to volume, directory, and filename por
tions.

On Mac OS, assumes that the last part of the path is a
filename unless $no_file is true or a trailing separator
":" is present.

The volume portion is always returned with a trailing
":". The directory portion is always returned with a
leading (to denote a relative path) and a trailing ":"
(to denote a directory). The file portion is always
returned without a leading ":". Empty portions are
returned as empty string ''.

The results can be passed to "catpath()" to get back a
path equivalent to (usually identical to) the original
path.

splitdir

The opposite of "catdir()".

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

$directories should 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. Consider using "splitpath()" otherwise.

Unlike just splitting the directories on the separator,
empty directory names ("") can be returned. Since "cat
dir()" on Mac OS always appends a trailing colon to dis
tinguish a directory path from a file path, a single
trailing colon will be ignored, i.e. there's no empty
directory name after it.

Hence, on Mac OS, both

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

yield:

( "a", "b", "::", "c")

while

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

yields:

( "a", "b", "::", "c", "::")

catpath

$path = File::Spec->catpath($volume,$directo

ry,$file);

Takes volume, directory and file portions and returns an
entire path. On Mac OS, $volume, $directory and $file
are concatenated. A ':' is inserted if need be. You may
pass an empty string for each portion. If all portions
are empty, the empty string is returned. If $volume is
empty, the result will be a relative path, beginning
with a ':'. If $volume and $directory are empty, a lead
ing ":" (if any) is removed form $file and the remainder
is returned. If $file is empty, the resulting path will
have a trailing ':'.

abs2rel

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

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

Note that both paths are assumed to have a notation that
distinguishes a directory path (with trailing ':') from
a file path (without trailing ':').

If $base is not present or '', then the current working
directory is used. If $base is relative, then it is
converted to absolute form using "rel2abs()". This
means that it is taken to be relative to the current
working directory.

Since Mac OS has the concept of volumes, this assumes
that both paths are on the $destination volume, and
ignores the $base volume (!).

If $base doesn't have a trailing colon, the last element
of $base is assumed to be a filename. This filename is
ignored (!). Otherwise all path components are assumed
to be directories.

If $path is relative, it is converted to absolute form
using "rel2abs()". This means that it is taken to be
relative to the current working directory.

Based on code written by Shigio Yamaguchi.

rel2abs

Converts a relative path to an absolute path:

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

Note that both paths are assumed to have a notation that
distinguishes a directory path (with trailing ':') from
a file path (without trailing ':').

If $base is not present or '', then $base is set to the
current working directory. If $base is relative, then it
is converted to absolute form using "rel2abs()". This
means that it is taken to be relative to the current
working directory.

If $base doesn't have a trailing colon, the last element
of $base is assumed to be a filename. This filename is
ignored (!). Otherwise all path components are assumed
to be directories.

If $path is already absolute, it is returned and $base
is ignored.

Based on code written by Shigio Yamaguchi.

AUTHORS

See the authors list in File::Spec. Mac OS support by Paul Schinder <schinder@pobox.com> and Thomas Wegner <weg
ner_thomas@yahoo.com>.

docs.sk

comprehensive documentation repository