unixdev.net


Switch to SpeakEasy.net DSL

The Modular Manual Browser

Home Page
Manual: (OpenBSD-3.6)
Page:
Section:
Apropos / Subsearch:
optional field



File::Spec::Mac(3Perl Programmers Reference GuFile::Spec::Mac(3p)


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(":") = ":"



perl v5.8.5                 2002-11-06                          1





File::Spec::Mac(3Perl Programmers Reference GuFile::Spec::Mac(3p)


         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.




perl v5.8.5                 2002-11-06                          2





File::Spec::Mac(3Perl Programmers Reference GuFile::Spec::Mac(3p)


               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:" .



perl v5.8.5                 2002-11-06                          3





File::Spec::Mac(3Perl Programmers Reference GuFile::Spec::Mac(3p)


       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".





perl v5.8.5                 2002-11-06                          4





File::Spec::Mac(3Perl Programmers Reference GuFile::Spec::Mac(3p)


       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->splitpath( $path );
             ($volume,$directories,$file) = File::Spec->splitpath( $path, $no_file );

         Splits a path into volume, directory, and filename



perl v5.8.5                 2002-11-06                          5





File::Spec::Mac(3Perl Programmers Reference GuFile::Spec::Mac(3p)


         portions.

         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,$directory,$file);




perl v5.8.5                 2002-11-06                          6





File::Spec::Mac(3Perl Programmers Reference GuFile::Spec::Mac(3p)


         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.

         If $path and $base appear to be on two different vol-
         umes, we will not attempt to resolve the two paths, and
         we will instead simply return $path.  Note that previous
         versions of this module ignored the volume of $base,
         which resulted in garbage results part of the time.

         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



perl v5.8.5                 2002-11-06                          7





File::Spec::Mac(3Perl Programmers Reference GuFile::Spec::Mac(3p)


         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 <schinderATpobox.com> and Thomas Wegner <weg-
       ner_thomasATyahoo.com>.

SEE ALSO
       See File::Spec and File::Spec::Unix.  This package over-
       rides the implementation of these methods, not the seman-
       tics.






























perl v5.8.5                 2002-11-06                          8