MirOS Manual: File::Spec::Mac(3p)


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. Result-
       ing paths are relative by default, but can be forced to be
       absolute (but avoid this, see below). Automatically puts a
       trailing ":" on the end of the complete path, because
       that's what's done in MacPerl's environment and helps to
       distinguish a file path from a directory path.

       IMPORTANT NOTE: Beginning with version 1.3 of this module,
       the resulting path is relative by default and not abso-
       lute. This decision was made due to portability reasons.
       Since "File::Spec->catdir()" returns relative paths on all
       other operating systems, it will now also follow this con-
       vention 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 common
       situations. In other words, you are also allowed to con-
       catenate paths instead of directory names (strictly speak-
       ing, 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

perl v5.8.8                2005-02-05                           1

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

           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 resulting
         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 argument,
         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

perl v5.8.8                2005-02-05                           2

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

         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 "rootdir()" 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 coun-
         terparts:

          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 arguments
         following "root" (again, see "Unix->canonpath()" ). If
         there are more arguments that move up the directory
         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 argument. How-
       ever, 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, direc-
       tory 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

perl v5.8.8                2005-02-05                           3

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

       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. Resulting
       paths are relative by default, but can be forced to be
       absolute (but avoid this).

       IMPORTANT NOTE: Beginning with version 1.3 of this module,
       the resulting path is relative by default and not abso-
       lute. This decision 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 exist-
       ing scripts.

       The last argument is always considered to be the file por-
       tion. 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
       filenames, you are encouraged to use "catpath()" (see

perl v5.8.8                2005-02-05                           4

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

       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
       "MacintoshHD:Temporary Items:", which is a hidden direc-
       tory 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 rela-
       tive 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 considered to be
       relative (i.e. it is considered to be a filename). Use ":"
       in the appropriate place in the path if you want to dis-
       tinguish unambiguously. As a special case, the filename ''
       is always considered to be absolute. Note that with ver-
       sion 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)

perl v5.8.8                2005-02-05                           5

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

     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:ExtUtils: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 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 direc-
       tories. 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:

perl v5.8.8                2005-02-05                           6

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

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

       while

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

       yields:

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

     catpath
           $path = File::Spec->catpath($volume,$directory,$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 leading ":" (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 destina-
       tion 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 con-
       verted to absolute form using "rel2abs()". This means that
       it is taken to be relative to the current working direc-
       tory.

       If $path and $base appear to be on two different volumes,
       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.

perl v5.8.8                2005-02-05                           7

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

       If $path is relative, it is converted to absolute form
       using "rel2abs()". This means that it is taken to be rela-
       tive 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 work-
       ing 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
     <wegner_thomas@yahoo.com>.

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.

SEE ALSO

     See File::Spec and File::Spec::Unix.  This package overrides
     the implementation of these methods, not the semantics.

perl v5.8.8                2005-02-05                           8

Generated on 2014-07-04 21:17:45 by $MirOS: src/scripts/roff2htm,v 1.79 2014/02/10 00:36:11 tg Exp $

These manual pages and other documentation are copyrighted by their respective writers; their source is available at our CVSweb, AnonCVS, and other mirrors. The rest is Copyright © 2002‒2014 The MirOS Project, Germany.
This product includes material provided by Thorsten Glaser.

This manual page’s HTML representation is supposed to be valid XHTML/1.1; if not, please send a bug report – diffs preferred.