PERLPORT(1)      Perl Programmers Reference Guide     PERLPORT(1)

       perlport - Writing portable Perl

       Perl runs on a variety of operating systems.  While most
       of them share a lot in common, they also have their own
       very particular and unique features.

       This document is meant to help you to find out what
       constitutes portable Perl code, so that once you have made
       your decision to write portably, you know where the lines
       are drawn, and you can stay within them.

       There is a tradeoff between taking full advantage of aa
       particular type of computer, and taking advantage of a
       full rraannggee of them.  Naturally, as you make your range
       bigger (and thus more diverse), the common denominators
       drop, and you are left with fewer areas of common ground
       in which you can operate to accomplish a particular task.
       Thus, when you begin attacking a problem, it is important
       to consider which part of the tradeoff curve you want to
       operate under. Specifically, whether it is important to
       you that the task that you are coding needs the full
       generality of being portable, or if it is sufficient to
       just get the job done.  This is the hardest choice to be
       made.  The rest is easy, because Perl provides lots of
       choices, whichever way you want to approach your problem.

       Looking at it another way, writing portable code is
       usually about willfully limiting your available choices.
       Naturally, it takes discipline to do that.

       Be aware of two important points:

       Not all Perl programs have to be portable
           There is no reason why you should not use Perl as a
           language to glue Unix tools together, or to prototype
           a Macintosh application, or to manage the Windows
           registry.  If it makes no sense to aim for portability
           for one reason or another in a given program, then
           don't bother.

       The vast majority of Perl iiss portable
           Don't be fooled into thinking that it is hard to
           create portable Perl code.  It isn't.  Perl tries its
           level-best to bridge the gaps between what's available
           on different platforms, and all the means available to
           use those features.  Thus almost all Perl code runs on
           any machine without modification.  But there are some
           significant issues in writing portable code, and this
           document is entirely about those issues.

       Here's the general rule: When you approach a task that is
       commonly done using a whole range of platforms, think in
       terms of writing portable code.  That way, you don't
       sacrifice much by way of the implementation choices you
       can avail yourself of, and at the same time you can give
       your users lots of platform choices.  On the other hand,
       when you have to take advantage of some unique feature of
       a particular platform, as is often the case with systems
       programming (whether for Unix, Windows, Mac OS, VMS,
       etc.), consider writing platform-specific code.

       When the code will run on only two or three operating
       systems, then you may only need to consider the
       differences of those particular systems.  The important
       thing is to decide where the code will run, and to be
       deliberate in your decision.

       The material below is separated into three main sections:
       main issues of portability (the section on ISSUES,
       platform-specific issues (the section on PLATFORMS, and
       builtin perl functions that behave differently on various
       ports (the section on FUNCTION IMPLEMENTATIONS.

       This information should not be considered complete; it
       includes possibly transient information about
       idiosyncrasies of some of the ports, almost all of which
       are in a state of constant evolution.  Thus this material
       should be considered a perpetual work in progress (<IMG
       SRC="yellow_sign.gif" ALT="Under Construction">).


       In most operating systems, lines in files are terminated
       by newlines.  Just what is used as a newline may vary from
       OS to OS.  Unix traditionally uses \012, one kind of
       Windows I/O uses \015\012, and Mac OS uses \015.

       Perl uses \n to represent the "logical" newline, where
       what is logical may depend on the platform in use.  In
       MacPerl, \n always means \015.  In DOSish perls, \n
       usually means \012, but when accessing a file in "text"
       mode, STDIO translates it to (or from) \015\012.

       Due to the "text" mode translation, DOSish perls have
       limitations of using seek and tell when a file is being
       accessed in "text" mode.  Specifically, if you stick to
       seek-ing to locations you got from tell (and no others),
       you are usually free to use seek and tell even in "text"
       mode.  In general, using seek or tell or other file
       operations that count bytes instead of characters, without
       considering the length of \n, may be non-portable.  If you
       use binmode on a file, however, you can usually use seek
       and tell with arbitrary values quite safely.

       A common misconception in socket programming is that \n eq
       \012 everywhere.  When using protocols such as common
       Internet protocols, \012 and \015 are called for
       specifically, and the values of the logical \n and \r
       (carriage return) are not reliable.

           print SOCKET "Hi there, client!\r\n";      # WRONG
           print SOCKET "Hi there, client!\015\012";  # RIGHT

       [NOTE: this does not necessarily apply to communications
       that are filtered by another program or module before
       sending to the socket; the the most popular EBCDIC
       webserver, for instance, accepts \r\n, which translates
       those characters, along with all other characters in text
       streams, from EBCDIC to ASCII.]

       However, using \015\012 (or \cM\cJ, or \x0D\x0A) can be
       tedious and unsightly, as well as confusing to those
       maintaining the code.  As such, the Socket module supplies
       the Right Thing for those who want it.

           use Socket qw(:DEFAULT :crlf);
           print SOCKET "Hi there, client!$CRLF"      # RIGHT

       When reading from a socket, remember that the default
       input record separator ($/) is \n, but code like this
       should recognize $/ as \012 or \015\012:

           while (<SOCKET>) {
               # ...


           use Socket qw(:DEFAULT :crlf);
           local($/) = LF;      # not needed if $/ is already \012

           while (<SOCKET>) {
               s/$CR?$LF/\n/;   # not sure if socket uses LF or CRLF, OK
           #   s/\015?\012/\n/; # same thing

       And this example is actually better than the previous one
       even for Unix platforms, because now any \015's (\cM's)
       are stripped out (and there was much rejoicing).

       An important thing to remember is that functions that
       return data should translate newlines when appropriate.
       Often one line of code will suffice:

               $data =~ s/\015?\012/\n/g;
               return $data;

       NNuummbbeerrss eennddiiaannnneessss aanndd WWiiddtthh

       Different CPUs store integers and floating point numbers
       in different orders (called endianness) and widths (32-bit
       and 64-bit being the most common).  This affects your
       programs if they attempt to transfer numbers in binary
       format from a CPU architecture to another over some
       channel: either 'live' via network connections or storing
       the numbers to secondary storage such as a disk file.

       Conflicting storage orders make utter mess out of the
       numbers: if a little-endian host (Intel, Alpha) stores
       0x12345678 (305419896 in decimal), a big-endian host
       (Motorola, MIPS, Sparc, PA) reads it as 0x78563412
       (2018915346 in decimal).  To avoid this problem in network
       (socket) connections use the pack() and unpack() formats
       "n" and "N", the "network" orders, they are guaranteed to
       be portable.

       Different widths can cause truncation even between
       platforms of equal endianness: the platform of shorter
       width loses the upper parts of the number.  There is no
       good solution for this problem except to avoid
       transferring or storing raw binary numbers.

       One can circumnavigate both these problems in two ways:
       either transfer and store numbers always in text format,
       instead of raw binary, or consider using modules like
       Data::Dumper (included in the standard distribution as of
       Perl 5.005) and Storable.

       FFiilleess aanndd FFiilleessyysstteemmss

       Most platforms these days structure files in a
       hierarchical fashion.  So, it is reasonably safe to assume
       that any platform supports the notion of a "path" to
       uniquely identify a file on the system.  Just how that
       path is actually written, differs.

       While they are similar, file path specifications differ
       between Unix, Windows, Mac OS, OS/2, VMS, VOS, RISC OS and
       probably others.  Unix, for example, is one of the few
       OSes that has the idea of a single root directory.

       VMS, Windows, and OS/2 can work similarly to Unix with /
       as path separator, or in their own idiosyncratic ways
       (such as having several root directories and various
       "unrooted" device files such NIL: and LPT:).

       Mac OS uses : as a path separator instead of /.

       The filesystem may support neither hard links (link()) nor
       symbolic links (symlink(), readlink(), lstat()).

       The filesystem may not support neither access timestamp
       nor change timestamp (meaning that about the only portable
       timestamp is the modification timestamp), or one second
       granularity of any timestamps (e.g. the FAT filesystem
       limits the time granularity to two seconds).

       VOS perl can emulate Unix filenames with / as path
       separator.  The native pathname characters greater-than,
       less-than, number-sign, and percent-sign are always

       RISC OS perl can emulate Unix filenames with / as path
       separator, or go native and use . for path separator and :
       to signal filing systems and disc names.

       As with the newline problem above, there are modules that
       can help.  The File::Spec modules provide methods to do
       the Right Thing on whatever platform happens to be running
       the program.

           use File::Spec;
           chdir(File::Spec->updir());        # go up one directory
           $file = File::Spec->catfile(
               File::Spec->curdir(), 'temp', 'file.txt'
           # on Unix and Win32, './temp/file.txt'
           # on Mac OS, ':temp:file.txt'

       File::Spec is available in the standard distribution, as
       of version 5.004_05.

       In general, production code should not have file paths
       hardcoded; making them user supplied or from a
       configuration file is better, keeping in mind that file
       path syntax varies on different machines.

       This is especially noticeable in scripts like Makefiles
       and test suites, which often assume / as a path separator
       for subdirectories.

       Also of use is File::Basename, from the standard
       distribution, which splits a pathname into pieces (base
       filename, full path to directory, and file suffix).

       Even when on a single platform (if you can call UNIX a
       single platform), remember not to count on the existence
       or the contents of system-specific files or directories,
       like /etc/passwd, /etc/sendmail.conf, /etc/resolv.conf, or
       even /tmp/. For example, /etc/passwd may exist but it may
       not contain the encrypted passwords because the system is
       using some form of enhanced security -- or it may not
       contain all the accounts because the system is using NIS.
       If code does need to rely on such a file, include a
       description of the file and its format in the code's
       documentation, and make it easy for the user to override
       the default location of the file.

       Don't assume a text file will end with a newline.

       Do not have two files of the same name with different
       case, like and, as many platforms have
       case-insensitive filenames.  Also, try not to have non-
       word characters (except for .)  in the names, and keep
       them to the 8.3 convention, for maximum portability.

       Likewise, if using AutoSplit, try to keep the split
       functions to 8.3 naming and case-insensitive conventions;
       or, at the very least, make it so the resulting files have
       a unique (case-insensitively) first 8 characters.

       There certainly can be whitespace in filenames.  Many
       systems (DOS, VMS) cannot have more than one "." in their

       Don't assume > won't be the first character of a filename.
       Always use < explicitly to open a file for reading.

           open(FILE, "<$existing_file") or die $!;

       Actually, though, if filenames might use strange
       characters, it is safest to open it with sysopen instead
       of open, which is magic.

       SSyysstteemm IInntteerraaccttiioonn

       Not all platforms provide for the notion of a command
       line, necessarily.  These are usually platforms that rely
       on a Graphical User Interface (GUI) for user interaction.
       So a program requiring command lines might not work
       everywhere.  But this is probably for the user of the
       program to deal with.

       Some platforms can't delete or rename files that are being
       held open by the system.  Remember to close files when you
       are done with them.  Don't unlink or rename an open file.
       Don't tie to or open a file that is already tied to or
       opened; untie or close first.

       Don't open the same file more than once at a time for
       writing, as some operating systems put mandatory locks on
       such files.

       Don't count on a specific environment variable existing in
       %ENV.  Don't count on %ENV entries being case-sensitive,
       or even case-preserving.

       Don't count on signals.

       Don't count on filename globbing.  Use opendir, readdir,
       and closedir instead.

       Don't count on per-program environment variables, or per-
       program current directories.

       Don't count on specific values of $!.

       IInntteerrpprroocceessss CCoommmmuunniiccaattiioonn ((IIPPCC))

       In general, don't directly access the system in code that
       is meant to be portable.  That means, no system, exec,
       fork, pipe, ``, qx//, open with a |, nor any of the other
       things that makes being a Unix perl hacker worth being.

       Commands that launch external processes are generally
       supported on most platforms (though many of them do not
       support any type of forking), but the problem with using
       them arises from what you invoke with them.  External
       tools are often named differently on different platforms,
       often not available in the same location, often accept
       different arguments, often behave differently, and often
       represent their results in a platform-dependent way.  Thus
       you should seldom depend on them to produce consistent

       One especially common bit of Perl code is opening a pipe
       to sendmail:

           open(MAIL, '|/usr/lib/sendmail -t') or die $!;

       This is fine for systems programming when sendmail is
       known to be available.  But it is not fine for many non-
       Unix systems, and even some Unix systems that may not have
       sendmail installed.  If a portable solution is needed, see
       the Mail::Send and Mail::Mailer modules in the MailTools
       distribution.  Mail::Mailer provides several mailing
       methods, including mail, sendmail, and direct SMTP (via
       Net::SMTP) if a mail transfer agent is not available.

       The rule of thumb for portable code is: Do it all in
       portable Perl, or use a module (that may internally
       implement it with platform-specific code, but expose a
       common interface).

       The UNIX System V IPC (msg*(), sem*(), shm*()) is not
       available even in all UNIX platforms.

       EExxtteerrnnaall SSuubbrroouuttiinneess ((XXSS))

       XS code, in general, can be made to work with any
       platform; but dependent libraries, header files, etc.,
       might not be readily available or portable, or the XS code
       itself might be platform-specific, just as Perl code might
       be.  If the libraries and headers are portable, then it is
       normally reasonable to make sure the XS code is portable,

       There is a different kind of portability issue with
       writing XS code: availability of a C compiler on the end-
       user's system.  C brings with it its own portability
       issues, and writing XS code will expose you to some of
       those.  Writing purely in perl is a comparatively easier
       way to achieve portability.

       SSttaannddaarrdd MMoodduulleess

       In general, the standard modules work across platforms.
       Notable exceptions are (which currently makes
       connections to external programs that may not be
       available), platform-specific modules (like
       ExtUtils::MM_VMS), and DBM modules.

       There is no one DBM module that is available on all
       platforms.  SDBM_File and the others are generally
       available on all Unix and DOSish ports, but not in
       MacPerl, where only NBDM_File and DB_File are available.

       The good news is that at least some DBM module should be
       available, and AnyDBM_File will use whichever module it
       can find.  Of course, then the code needs to be fairly
       strict, dropping to the lowest common denominator (e.g.,
       not exceeding 1K for each record).

       TTiimmee aanndd DDaattee

       The system's notion of time of day and calendar date is
       controlled in widely different ways. Don't assume the
       timezone is stored in $ENV{TZ}, and even if it is, don't
       assume that you can control the timezone through that

       Don't assume that the epoch starts at 00:00:00, January 1,
       1970, because that is OS-specific.  Better to store a date
       in an unambiguous representation.  The ISO 8601 standard
       defines YYYY-MM-DD as the date format.  A text
       representation (like 1 Jan 1970) can be easily converted
       into an OS-specific value using a module like Date::Parse.
       An array of values, such as those returned by localtime,
       can be converted to an OS-specific representation using

       CChhaarraacctteerr sseettss aanndd cchhaarraacctteerr eennccooddiinngg

       Assume very little about character sets.  Do not assume
       anything about the numerical values (ord(), chr()) of
       characters.  Do not assume that the alphabetic characters
       are encoded contiguously (in numerical sense).  Do not
       assume anything about the ordering of the characters.  The
       lowercase letters may come before or after the uppercase
       letters, the lowercase and uppercase may be interlaced so
       that both 'a' and 'A' come before the 'b', the accented
       and other international characters may be interlaced so
       that ae comes before the 'b'.


       If you may assume POSIX (a rather large assumption, that
       in practice means UNIX), you may read more about the POSIX
       locale system from the perllocale manpage.  The locale
       system at least attempts to make things a little bit more
       portable, or at least more convenient and native-friendly
       for non-English users.  The system affects character sets
       and encoding, and date and time formatting, among other

       SSyysstteemm RReessoouurrcceess

       If your code is destined for systems with severely
       constrained (or missing!) virtual memory systems then you
       want to be especially mindful of avoiding wasteful
       constructs such as:

           # NOTE: this is no longer "bad" in perl5.005
           for (0..10000000) {}                       # bad
           for (my $x = 0; $x <= 10000000; ++$x) {}   # good

           @lines = <VERY_LARGE_FILE>;                # bad

           while (<FILE>) {$file .= $_}               # sometimes bad
           $file = join('', <FILE>);                  # better

       The last two may appear unintuitive to most people.  The
       first of those two constructs repeatedly grows a string,
       while the second allocates a large chunk of memory in one
       go.  On some systems, the latter is more efficient that
       the former.


       Most multi-user platforms provide basic levels of security
       that is usually felt at the file-system level.  Other
       platforms usually don't (unfortunately).  Thus the notion
       of user id, or "home" directory, or even the state of
       being logged-in, may be unrecognizable on many platforms.
       If you write programs that are security conscious, it is
       usually best to know what type of system you will be
       operating under, and write code explicitly for that
       platform (or class of platforms).


       For those times when it is necessary to have platform-
       specific code, consider keeping the platform-specific code
       in one place, making porting to other platforms easier.
       Use the Config module and the special variable $^O to
       differentiate platforms, as described in the section on

CCPPAANN TTeesstteerrss
       Modules uploaded to CPAN are tested by a variety of
       volunteers on different platforms.  These CPAN testers are
       notified by mail of each new upload, and reply to the list
       with PASS, FAIL, NA (not applicable to this platform), or
       UNKNOWN (unknown), along with any relevant notations.

       The purpose of the testing is twofold: one, to help
       developers fix any problems in their code that crop up
       because of lack of testing on other platforms; two, to
       provide users with information about whether or not a
       given module works on a given platform.

       Mailing list:

       Testing results:

       As of version 5.002, Perl is built with a $^O variable
       that indicates the operating system it was built on.  This
       was implemented to help speed up code that would otherwise
       have to use Config; and use the value of
       $Config{'osname'}.  Of course, to get detailed information
       about the system, looking into %Config is certainly


       Perl works on a bewildering variety of Unix and Unix-like
       platforms (see e.g. most of the files in the hints/
       directory in the source code kit).  On most of these
       systems, the value of $^O (hence $Config{'osname'}, too)
       is determined by lowercasing and stripping punctuation
       from the first field of the string returned by typing
       uname -a (or a similar command) at the shell prompt.
       Here, for example, are a few of the more popular Unix

           uname        $^O        $Config{'archname'}
           AIX          aix        aix
           FreeBSD      freebsd    freebsd-i386
           Linux        linux      i386-linux
           HP-UX        hpux       PA-RISC1.1
           IRIX         irix       irix
           OSF1         dec_osf    alpha-dec_osf
           SunOS        solaris    sun4-solaris
           SunOS        solaris    i86pc-solaris
           SunOS4       sunos      sun4-sunos

       Note that because the $Config{'archname'} may depend on
       the hardware architecture it may vary quite a lot, much
       more than the $^O.

       DDOOSS aanndd DDeerriivvaattiivveess

       Perl has long been ported to PC style microcomputers
       running under systems like PC-DOS, MS-DOS, OS/2, and most
       Windows platforms you can bring yourself to mention
       (except for Windows CE, if you count that).  Users
       familiar with COMMAND.COM and/or CMD.EXE style shells
       should be aware that each of these file specifications may
       have subtle differences:

           $filespec0 = "c:/foo/bar/file.txt";
           $filespec1 = "c:\\foo\\bar\\file.txt";
           $filespec2 = 'c:\foo\bar\file.txt';
           $filespec3 = 'c:\\foo\\bar\\file.txt';

       System calls accept either / or \ as the path separator.
       However, many command-line utilities of DOS vintage treat
       / as the option prefix, so they may get confused by
       filenames containing /.  Aside from calling any external
       programs, / will work just fine, and probably better, as
       it is more consistent with popular usage, and avoids the
       problem of remembering what to backwhack and what not to.

       The DOS FAT filesystem can only accommodate "8.3" style
       filenames.  Under the "case insensitive, but case
       preserving" HPFS (OS/2) and NTFS (NT) filesystems you may
       have to be careful about case returned with functions like
       readdir or used with functions like open or opendir.

       DOS also treats several filenames as special, such as AUX,
       PRN, NUL, CON, COM1, LPT1, LPT2 etc.  Unfortunately these
       filenames won't even work if you include an explicit
       directory prefix, in some cases.  It is best to avoid such
       filenames, if you want your code to be portable to DOS and
       its derivatives.

       Users of these operating systems may also wish to make use
       of scripts such as pl2bat.bat or pl2cmd as appropriate to
       put wrappers around your scripts.

       Newline (\n) is translated as \015\012 by STDIO when
       reading from and writing to files.  binmode(FILEHANDLE)
       will keep \n translated as \012 for that filehandle.
       Since it is a noop on other systems, binmode should be
       used for cross-platform code that deals with binary data.

       The $^O variable and the $Config{'archname'} values for
       various DOSish perls are as follows:

           OS            $^O        $Config{'archname'}
           MS-DOS        dos
           PC-DOS        dos
           OS/2          os2
           Windows 95    MSWin32    MSWin32-x86
           Windows NT    MSWin32    MSWin32-x86
           Windows NT    MSWin32    MSWin32-alpha
           Windows NT    MSWin32    MSWin32-ppc

       Also see:

       The djgpp environment for DOS,

       The EMX environment for DOS, OS/2, etc.,

       Build instructions for Win32, the perlwin32 manpage.

       The ActiveState Pages,

       MMaacc OOSS

       Any module requiring XS compilation is right out for most
       people, because MacPerl is built using non-free (and non-
       cheap!) compilers.  Some XS modules that can work with
       MacPerl are built and distributed in binary form on CPAN.
       See MacPerl: Power and Ease and the section on CPAN
       Testers for more details.

       Directories are specified as:

           volume:folder:file              for absolute pathnames
           volume:folder:                  for absolute pathnames
           :folder:file                    for relative pathnames
           :folder:                        for relative pathnames
           :file                           for relative pathnames
           file                            for relative pathnames

       Files in a directory are stored in alphabetical order.
       Filenames are limited to 31 characters, and may include
       any character except :, which is reserved as a path

       Instead of flock, see FSpSetFLock and FSpRstFLock in the
       Mac::Files module, or chmod(0444, ...) and chmod(0666,

       In the MacPerl application, you can't run a program from
       the command line; programs that expect @ARGV to be
       populated can be edited with something like the following,
       which brings up a dialog box asking for the command line

           if (!@ARGV) {
               @ARGV = split /\s+/, MacPerl::Ask('Arguments?');

       A MacPerl script saved as a droplet will populate @ARGV
       with the full pathnames of the files dropped onto the

       Mac users can use programs on a kind of command line under
       MPW (Macintosh Programmer's Workshop, a free development
       environment from Apple).  MacPerl was first introduced as
       an MPW tool, and MPW can be used like a shell:

           perl myscript.plx some arguments

       ToolServer is another app from Apple that provides access
       to MPW tools from MPW and the MacPerl app, which allows
       MacPerl programs to use system, backticks, and piped open.

       "Mac OS" is the proper name for the operating system, but
       the value in $^O is "MacOS".  To determine architecture,
       version, or whether the application or MPW tool version is
       running, check:

           $is_app    = $MacPerl::Version =~ /App/;
           $is_tool   = $MacPerl::Version =~ /MPW/;
           ($version) = $MacPerl::Version =~ /^(\S+)/;
           $is_ppc    = $MacPerl::Architecture eq 'MacPPC';
           $is_68k    = $MacPerl::Architecture eq 'Mac68K';

       Mac OS X, to be based on NeXT's OpenStep OS, will (in
       theory) be able to run MacPerl natively, but Unix perl
       will also run natively under the built-in Unix

       Also see:

       The MacPerl Pages,

       The MacPerl mailing list,


       Perl on VMS is discussed in vms/perlvms.pod in the perl
       distribution.  Note that perl on VMS can accept either
       VMS- or Unix-style file specifications as in either of the

           $ perl -ne "print if /perl_setup/i" SYS$LOGIN:LOGIN.COM
           $ perl -ne "print if /perl_setup/i" /sys$login/

       but not a mixture of both as in:

           $ perl -ne "print if /perl_setup/i" sys$login:/
           Can't open sys$login:/ file specification syntax error

       Interacting with Perl from the Digital Command Language
       (DCL) shell often requires a different set of quotation
       marks than Unix shells do.  For example:

           $ perl -e "print ""Hello, world.\n"""
           Hello, world.

       There are a number of ways to wrap your perl scripts in
       DCL .COM files if you are so inclined.  For example:

           $ write sys$output "Hello from DCL!"
           $ if p1 .eqs. ""
           $ then perl -x 'f$environment("PROCEDURE")
           $ else perl -x - 'p1 'p2 'p3 'p4 'p5 'p6 'p7 'p8
           $ deck/dollars="__END__"

           print "Hello from Perl!\n";

           $ endif

       Do take care with $ ASSIGN/nolog/user SYS$COMMAND:
       SYS$INPUT if your perl-in-DCL script expects to do things
       like $read = <STDIN>;.

       Filenames are in the format "name.extension;version".  The
       maximum length for filenames is 39 characters, and the
       maximum length for extensions is also 39 characters.
       Version is a number from 1 to 32767.  Valid characters are

       VMS' RMS filesystem is case insensitive and does not
       preserve case.  readdir returns lowercased filenames, but
       specifying a file for opening remains case insensitive.
       Files without extensions have a trailing period on them,
       so doing a readdir with a file named A.;5 will return a.
       (though that file could be opened with open(FH, 'A')).

       RMS had an eight level limit on directory depths from any
       rooted logical (allowing 16 levels overall) prior to VMS
       7.2.  Hence PERL_ROOT:[LIB.] is a valid
       directory specification but
       PERL_ROOT:[LIB.] is not.  Makefile.PL
       authors might have to take this into account, but at least
       they can refer to the former as

       The VMS::Filespec module, which gets installed as part of
       the build process on VMS, is a pure Perl module that can
       easily be installed on non-VMS platforms and can be
       helpful for conversions to and from RMS native formats.

       What \n represents depends on the type of file that is
       open.  It could be \015, \012, \015\012, or nothing.
       Reading from a file translates newlines to \012, unless
       binmode was executed on that handle, just like DOSish

       TCP/IP stacks are optional on VMS, so socket routines
       might not be implemented.  UDP sockets may not be

       The value of $^O on OpenVMS is "VMS".  To determine the
       architecture that you are running on without resorting to
       loading all of %Config you can examine the content of the
       @INC array like so:

           if (grep(/VMS_AXP/, @INC)) {
               print "I'm on Alpha!\n";
           } elsif (grep(/VMS_VAX/, @INC)) {
               print "I'm on VAX!\n";
           } else {
               print "I'm not so sure about where $^O is...\n";

       Also see:

       the perlvms.pod manpage

       vmsperl list,
           Put words SUBSCRIBE VMSPERL in message body.

       vmsperl on the web,


       Perl on VOS is discussed in README.vos in the perl
       distribution.  Note that perl on VOS can accept either
       VOS- or Unix-style file specifications as in either of the

           $ perl -ne "print if /perl_setup/i" >system>notices
           $ perl -ne "print if /perl_setup/i" /system/notices

       or even a mixture of both as in:

           $ perl -ne "print if /perl_setup/i" >system/notices

       Note that even though VOS allows the slash character to
       appear in object names, because the VOS port of Perl
       interprets it as a pathname delimiting character, VOS
       files, directories, or links whose names contain a slash
       character cannot be processed.  Such files must be renamed
       before they can be processed by Perl.

       The following C functions are unimplemented on VOS, and
       any attempt by Perl to use them will result in a fatal
       error message and an immediate exit from Perl:  dup,
       do_aspawn, do_spawn, fork, waitpid.  Once these functions
       become available in the VOS POSIX.1 implementation, you
       can either recompile and rebind Perl, or you can download
       a newer port from

       The value of $^O on VOS is "VOS".  To determine the
       architecture that you are running on without resorting to
       loading all of %Config you can examine the content of the
       @INC array like so:

           if (grep(/VOS/, @INC)) {
               print "I'm on a Stratus box!\n";
           } else {
               print "I'm not on a Stratus box!\n";

           if (grep(/860/, @INC)) {
               print "This box is a Stratus XA/R!\n";
           } elsif (grep(/7100/, @INC)) {
               print "This box is a Stratus HP 7100 or 8000!\n";
           } elsif (grep(/8000/, @INC)) {
               print "This box is a Stratus HP 8000!\n";
           } else {
               print "This box is a Stratus 68K...\n";

       Also see:

       the README.vos manpage

       VOS mailing list
           There is no specific mailing list for Perl on VOS.
           You can post comments to the comp.sys.stratus
           newsgroup, or subscribe to the general Stratus mailing
           list.  Send a letter with "Subscribe Info-Stratus" in
           the message body to

       VOS Perl on the web at

       EEBBCCDDIICC PPllaattffoorrmmss

       Recent versions of Perl have been ported to platforms such
       as OS/400 on AS/400 minicomputers as well as OS/390 &
       VM/ESA for IBM Mainframes.  Such computers use EBCDIC
       character sets internally (usually Character Code Set ID
       00819 for OS/400 and IBM-1047 for OS/390 & VM/ESA).  Note
       that on the mainframe perl currently works under the "Unix
       system services for OS/390" (formerly known as
       OpenEdition) and VM/ESA OpenEdition.

       As of R2.5 of USS for OS/390 and Version 2.3 of VM/ESA
       these Unix sub-systems do not support the #! shebang trick
       for script invocation.  Hence, on OS/390 and VM/ESA perl
       scripts can be executed with a header similar to the
       following simple script:

           : # use perl
               eval 'exec /usr/local/bin/perl -S $0 ${1+"$@"}'
                   if 0;
           #!/usr/local/bin/perl     # just a comment really

           print "Hello from perl!\n";

       On these platforms, bear in mind that the EBCDIC character
       set may have an effect on what happens with some perl
       functions (such as chr, pack, print, printf, ord, sort,
       sprintf, unpack), as well as bit-fiddling with ASCII
       constants using operators like ^, & and |, not to mention
       dealing with socket interfaces to ASCII computers (see the
       Newlines manpage).

       Fortunately, most web servers for the mainframe will
       correctly translate the \n in the following statement to
       its ASCII equivalent (note that \r is the same under both
       Unix and OS/390 & VM/ESA):

           print "Content-type: text/html\r\n\r\n";

       The value of $^O on OS/390 is "os390".

       The value of $^O on VM/ESA is "vmesa".

       Some simple tricks for determining if you are running on
       an EBCDIC platform could include any of the following
       (perhaps all):

           if ("\t" eq "\05")   { print "EBCDIC may be spoken here!\n"; }

           if (ord('A') == 193) { print "EBCDIC may be spoken here!\n"; }

           if (chr(169) eq 'z') { print "EBCDIC may be spoken here!\n"; }

       Note that one thing you may not want to rely on is the
       EBCDIC encoding of punctuation characters since these may
       differ from code page to code page (and once your module
       or script is rumoured to work with EBCDIC, folks will want
       it to work with all EBCDIC character sets).

       Also see:

       perl-mvs list
           The list is for discussion of
           porting issues as well as general usage issues for all
           EBCDIC Perls.  Send a message body of "subscribe perl-
           mvs" to

       AS/400 Perl information at

       AAccoorrnn RRIISSCC OOSS

       As Acorns use ASCII with newlines (\n) in text files as
       \012 like Unix and Unix filename emulation is turned on by
       default, it is quite likely that most simple scripts will
       work "out of the box".  The native filing system is
       modular, and individual filing systems are free to be
       case-sensitive or insensitive, and are usually case-
       preserving.  Some native filing systems have name length
       limits which file and directory names are silently
       truncated to fit - scripts should be aware that the
       standard disc filing system currently has a name length
       limit of 1100 characters, with up to 77 items in a
       directory, but other filing systems may not impose such

       Native filenames are of the form



           Special_Field is not usually present, but may contain . and $ .
           Filesystem =~ m|[A-Za-z0-9_]|
           DsicName   =~ m|[A-Za-z0-9_/]|
           $ represents the root directory
           . is the path separator
           @ is the current directory (per filesystem but machine global)
           ^ is the parent directory
           Directory and File =~ m|[^\0- "\.\$\%\&:\@\\^\|\177]+|

       The default filename translation is roughly tr|/.|./|;

       Note that "ADFS::HardDisc.$.File" ne
       'ADFS::HardDisc.$.File' and that the second stage of $
       interpolation in regular expressions will fall foul of the
       $. if scripts are not careful.

       Logical paths specified by system variables containing
       comma-separated search lists are also allowed, hence
       System:Modules is a valid filename, and the filesystem
       will prefix Modules with each section of System$Path until
       a name is made that points to an object on disc.  Writing
       to a new file System:Modules would only be allowed if
       System$Path contains a single item list.  The filesystem
       will also expand system variables in filenames if enclosed
       in angle brackets, so <System$Dir>.Modules would look for
       the file $ENV{'System$Dir'} . 'Modules'.  The obvious
       implication of this is that ffuullllyy qquuaalliiffiieedd ffiilleennaammeess ccaann
       ssttaarrtt wwiitthh <<b><><b>> and should be protected when open is used
       for input.

       Because . was in use as a directory separator and
       filenames could not be assumed to be unique after 10
       characters, Acorn implemented the C compiler to strip the
       trailing .c .h .s and .o suffix from filenames specified
       in source code and store the respective files in
       subdirectories named after the suffix. Hence files are

           C:foo.h        (logical path variable)
           sys/os.h        sys.h.os       (C compiler groks Unix-speak)
           10charname.c    c.10charname
           10charname.o    o.10charname
           11charname_.c   c.11charname   (assuming filesystem truncates at 10)

       The Unix emulation library's translation of filenames to
       native assumes that this sort of translation is required,
       and allows a user defined list of known suffixes which it
       will transpose in this fashion.  This may appear
       transparent, but consider that with these rules
       foo/bar/baz.h and foo/bar/h/baz both map to,
       and that readdir and glob cannot and do not attempt to
       emulate the reverse mapping.  Other .s in filenames are
       translated to /.

       As implied above the environment accessed through %ENV is
       global, and the convention is that program specific
       environment variables are of the form Program$Name.  Each
       filing system maintains a current directory, and the
       current filing system's current directory is the gglloobbaall
       current directory.  Consequently, sociable scripts don't
       change the current directory but rely on full pathnames,
       and scripts (and Makefiles) cannot assume that they can
       spawn a child process which can change the current
       directory without affecting its parent (and everyone else
       for that matter).

       As native operating system filehandles are global and
       currently are allocated down from 255, with 0 being a
       reserved value the Unix emulation library emulates Unix
       filehandles.  Consequently, you can't rely on passing
       STDIN, STDOUT, or STDERR to your children.

       The desire of users to express filenames of the form
       <Foo$Dir>.Bar on the command line unquoted causes
       problems, too: `` command output capture has to perform a
       guessing game.  It assumes that a string <[^<>]+\$[^<>]>
       is a reference to an environment variable, whereas
       anything else involving < or > is redirection, and
       generally manages to be 99% right.  Of course, the problem
       remains that scripts cannot rely on any Unix tools being
       available, or that any tools found have Unix-like command
       line arguments.

       Extensions and XS are, in theory, buildable by anyone
       using free tools.  In practice, many don't, as users of
       the Acorn platform are used to binary distribution.
       MakeMaker does run, but no available make currently copes
       with MakeMaker's makefiles; even if/when this is fixed,
       the lack of a Unix-like shell can cause problems with
       makefile rules, especially lines of the form cd sdbm &&
       make all, and anything using quoting.

       "RISC OS" is the proper name for the operating system, but
       the value in $^O is "riscos" (because we don't like

       Also see:

       perl list

       OOtthheerr ppeerrllss

       Perl has been ported to a variety of platforms that do not
       fit into any of the above categories.  Some, such as
       AmigaOS, BeOS, QNX, and Plan 9, have been well-integrated
       into the standard Perl source code kit.  You may need to
       see the ports/ directory on CPAN for information, and
       possibly binaries, for the likes of: aos, atari, lynxos,
       riscos, Tandem Guardian, vos, etc. (yes we know that some
       of these OSes may fall under the Unix category, but we are
       not a standards body.)

       See also:

       Atari, Guido Flohr's page

       HP 300 MPE/iX

       Novell Netware
           A free perl5-based PERL.NLM for Novell Netware is
           available from

       Listed below are functions unimplemented or implemented
       differently on various platforms.  Following each
       description will be, in parentheses, a list of platforms
       that the description applies to.

       The list may very well be incomplete, or wrong in some
       places.  When in doubt, consult the platform-specific
       README files in the Perl source distribution, and other
       documentation resources for a given port.

       Be aware, moreover, that even among Unix-ish systems there
       are variations.

       For many functions, you can also query %Config, exported
       by default from  For example, to check if the
       platform has the lstat call, check $Config{'d_lstat'}.
       See the manpage for a full description of
       available variables.

       AAllpphhaabbeettiiccaall LLiissttiinngg ooff PPeerrll FFuunnccttiioonnss


       -X EXPR

       -X      -r, -w, and -x have only a very limited meaning;
               directories and applications are executable, and
               there are no uid/gid considerations. -o is not
               supported. (Mac OS)

               -r, -w, -x, and -o tell whether or not file is
               accessible, which may not reflect UIC-based file
               protections. (VMS)

               -s returns the size of the data fork, not the
               total size of data fork plus resource fork.
               (Mac OS).

               -s by name on an open file will return the space
               reserved on disk, rather than the current extent.
               -s on an open filehandle returns the current size.
               (RISC OS)

               -R, -W, -X, -O are indistinguishable from -r, -w,
               -x, -o. (Mac OS, Win32, VMS, RISC OS)

               -b, -c, -k, -g, -p, -u, -A are not implemented.
               (Mac OS)

               -g, -k, -l, -p, -u, -A are not particularly
               meaningful.  (Win32, VMS, RISC OS)

               -d is true if passed a device spec without an
               explicit directory.  (VMS)

               -T and -B are implemented, but might misclassify
               Mac text files with foreign characters; this is
               the case will all platforms, but may affect Mac OS
               often. (Mac OS)

               -x (or -X) determine if a file ends in one of the
               executable suffixes. -S is meaningless. (Win32)

               -x (or -X) determine if a file has an executable
               file type.  (RISC OS)

       binmode FILEHANDLE
               Meaningless. (Mac OS, RISC OS)

               Reopens file and restores pointer; if function
               fails, underlying filehandle may be closed, or
               pointer may be in a different position.  (VMS)

               The value returned by tell may be affected after
               the call, and the filehandle may be flushed.

       chmod LIST
               Only limited meaning. Disabling/enabling write
               permission is mapped to locking/unlocking the
               file. (Mac OS)

               Only good for changing "owner" read-write access,
               "group", and "other" bits are meaningless. (Win32)

               Only good for changing "owner" and "other" read-
               write access. (RISC OS)

               Access permissions are mapped onto VOS access-
               control list changes. (VOS)

       chown LIST
               Not implemented. (Mac OS, Win32, Plan9, RISC OS,

               Does nothing, but won't fail. (Win32)

       chroot FILENAME

       chroot  Not implemented. (Mac OS, Win32, VMS, Plan9,
               RISC OS, VOS, VM/ESA)

       crypt PLAINTEXT,SALT
               May not be available if library or source was not
               provided when building perl. (Win32)

               Not implemented. (VOS)

       dbmclose HASH
               Not implemented. (VMS, Plan9, VOS)

       dbmopen HASH,DBNAME,MODE
               Not implemented. (VMS, Plan9, VOS)

       dump LABEL
               Not useful. (Mac OS, RISC OS)

               Not implemented. (Win32)

               Invokes VMS debugger. (VMS)

       exec LIST
               Not implemented. (Mac OS)

               Implemented via Spawn. (VM/ESA)

               Not implemented. (Win32, VMS)

               Not implemented (Mac OS, VMS, RISC OS, VOS).

               Available only on Windows NT (not on Windows 95).

       fork    Not implemented. (Mac OS, Win32, AmigaOS, RISC OS,
               VOS, VM/ESA)

               Not implemented. (Mac OS, RISC OS)

       getpgrp PID
               Not implemented. (Mac OS, Win32, VMS, RISC OS,

       getppid Not implemented. (Mac OS, Win32, VMS, RISC OS)

       getpriority WHICH,WHO
               Not implemented. (Mac OS, Win32, VMS, RISC OS,
               VOS, VM/ESA)

       getpwnam NAME
               Not implemented. (Mac OS, Win32)

               Not useful. (RISC OS)

       getgrnam NAME
               Not implemented. (Mac OS, Win32, VMS, RISC OS)

       getnetbyname NAME
               Not implemented. (Mac OS, Win32, Plan9)

       getpwuid UID
               Not implemented. (Mac OS, Win32)

               Not useful. (RISC OS)

       getgrgid GID
               Not implemented. (Mac OS, Win32, VMS, RISC OS)

       getnetbyaddr ADDR,ADDRTYPE
               Not implemented. (Mac OS, Win32, Plan9)

       getprotobynumber NUMBER
               Not implemented. (Mac OS)

       getservbyport PORT,PROTO
               Not implemented. (Mac OS)

               Not implemented. (Mac OS, Win32, VM/ESA)

               Not implemented. (Mac OS, Win32, VMS, VM/ESA)

               Not implemented. (Mac OS, Win32)

               Not implemented. (Mac OS, Win32, Plan9)

               Not implemented. (Mac OS, Win32, Plan9)

               Not implemented. (Win32, Plan9)

               Not implemented. (Mac OS, Win32, RISC OS)

               Not implemented. (Mac OS, Win32, VMS, RISC OS)

       sethostent STAYOPEN
               Not implemented. (Mac OS, Win32, Plan9, RISC OS)

       setnetent STAYOPEN
               Not implemented. (Mac OS, Win32, Plan9, RISC OS)

       setprotoent STAYOPEN
               Not implemented. (Mac OS, Win32, Plan9, RISC OS)

       setservent STAYOPEN
               Not implemented. (Plan9, Win32, RISC OS)

               Not implemented. (Mac OS, Win32, VM/ESA)

               Not implemented. (Mac OS, Win32, VMS, RISC OS,

               Not implemented. (Mac OS, Win32)

               Not implemented. (Mac OS, Win32, Plan9)

               Not implemented. (Mac OS, Win32, Plan9)

               Not implemented. (Plan9, Win32)

       getsockopt SOCKET,LEVEL,OPTNAME
               Not implemented. (Mac OS, Plan9)

       glob EXPR

       glob    Globbing built-in, but only * and ? metacharacters
               are supported.  (Mac OS)

               Features depend on external perlglob.exe or
               perlglob.bat. May be overridden with something
               like File::DosGlob, which is recommended.  (Win32)

               Globbing built-in, but only * and ? metacharacters
               are supported.  Globbing relies on operating
               system calls, which may return filenames in any
               order.  As most filesystems are case-insensitive,
               even "sorted" filenames will not be in case-
               sensitive order. (RISC OS)

               Not implemented. (VMS)

               Available only for socket handles, and it does
               what the ioctlsocket() call in the Winsock API
               does. (Win32)

               Available only for socket handles. (RISC OS)

       kill LIST
               Not implemented, hence not useful for taint
               checking. (Mac OS, RISC OS)

               Available only for process handles returned by the
               system(1, ...)  method of spawning a process.

               Not implemented. (Mac OS, Win32, VMS, RISC OS)

               Link count not updated because hard links are not
               quite that hard (They are sort of half-way between
               hard and soft links). (AmigaOS)

       lstat FILEHANDLE

       lstat EXPR

       lstat   Not implemented. (VMS, RISC OS)

               Return values may be bogus. (Win32)

       msgctl ID,CMD,ARG

       msgget KEY,FLAGS

       msgsnd ID,MSG,FLAGS

       msgrcv ID,VAR,SIZE,TYPE,FLAGS
               Not implemented. (Mac OS, Win32, VMS, Plan9,
               RISC OS, VOS)


       open FILEHANDLE
               The | variants are only supported if ToolServer is
               installed.  (Mac OS)

               open to |- and -| are unsupported. (Mac OS, Win32,
               RISC OS)

               Not implemented. (Mac OS)

               Very limited functionality. (MiNT)

       readlink EXPR

               Not implemented. (Win32, VMS, RISC OS)

               Only implemented on sockets. (Win32)

               Only reliable on sockets. (RISC OS)

       semctl ID,SEMNUM,CMD,ARG

       semget KEY,NSEMS,FLAGS

       semop KEY,OPSTRING
               Not implemented. (Mac OS, Win32, VMS, RISC OS,

       setpgrp PID,PGRP
               Not implemented. (Mac OS, Win32, VMS, RISC OS,

       setpriority WHICH,WHO,PRIORITY
               Not implemented. (Mac OS, Win32, VMS, RISC OS,

               Not implemented. (Mac OS, Plan9)

       shmctl ID,CMD,ARG

       shmget KEY,SIZE,FLAGS

       shmread ID,VAR,POS,SIZE

       shmwrite ID,STRING,POS,SIZE
               Not implemented. (Mac OS, Win32, VMS, RISC OS,

               Not implemented. (Mac OS, Win32, VMS, RISC OS,
               VOS, VM/ESA)

       stat FILEHANDLE

       stat EXPR

       stat    mtime and atime are the same thing, and ctime is
               creation time instead of inode change time.
               (Mac OS)

               device and inode are not meaningful.  (Win32)

               device and inode are not necessarily reliable.

               mtime, atime and ctime all return the last
               modification time.  Device and inode are not
               necessarily reliable.  (RISC OS)

       symlink OLDFILE,NEWFILE
               Not implemented. (Win32, VMS, RISC OS)

       syscall LIST
               Not implemented. (Mac OS, Win32, VMS, RISC OS,
               VOS, VM/ESA)

               The traditional "0", "1", and "2" MODEs are
               implemented with different numeric values on some
               systems.  The flags exported by Fcntl (O_RDONLY,
               O_WRONLY, O_RDWR) should work everywhere though.
               (Mac OS, OS/390, VM/ESA)

       system LIST
               Only implemented if ToolServer is installed.
               (Mac OS)

               As an optimization, may not call the command shell
               specified in $ENV{PERL5SHELL}. system(1, @args)
               spawns an external process and immediately returns
               its process designator, without waiting for it to
               terminate.  Return value may be used subsequently
               in wait or waitpid.  (Win32)

               There is no shell to process metacharacters, and
               the native standard is to pass a command line
               terminated by "\n" "\r" or "\0" to the spawned
               program.  Redirection such as > foo is performed
               (if at all) by the run time library of the spawned
               program.  system list will call the Unix emulation
               library's exec emulation, which attempts to
               provide emulation of the stdin, stdout, stderr in
               force in the parent, providing the child program
               uses a compatible version of the emulation
               library.  scalar will call the native command line
               direct and no such emulation of a child Unix
               program will exists.  Mileage wwiillll vary.
               (RISC OS)

               Far from being POSIX compliant.  Because there may
               be no underlying /bin/sh tries to work around the
               problem by forking and execing the first token in
               its argument string.  Handles basic redirection
               ("<" or ">") on its own behalf. (MiNT)

       times   Only the first entry returned is nonzero. (Mac OS)

               "cumulative" times will be bogus.  On anything
               other than Windows NT, "system" time will be
               bogus, and "user" time is actually the time
               returned by the clock() function in the C runtime
               library. (Win32)

               Not useful. (RISC OS)

       truncate FILEHANDLE,LENGTH

       truncate EXPR,LENGTH
               Not implemented. (VMS)

               Truncation to zero-length only. (VOS)

               If a FILEHANDLE is supplied, it must be writable
               and opened in append mode (i.e., use open(FH,
               '>filename')> or sysopen(FH,...,O_APPEND|O_RDWR).
               If a filename is supplied, it should not be held
               open elsewhere. (Win32)

       umask EXPR

       umask   Returns undef where unavailable, as of version

               umask() works but the correct permissions are only
               set when the file is finally close()d. (AmigaOS)

       utime LIST
               Only the modification time is updated. (Mac OS,
               VMS, RISC OS)

               May not behave as expected.  Behavior depends on
               the C runtime library's implementation of utime(),
               and the filesystem being used.  The FAT filesystem
               typically does not support an "access time" field,
               and it may limit timestamps to a granularity of
               two seconds. (Win32)


       waitpid PID,FLAGS
               Not implemented. (Mac OS, VOS)

               Can only be applied to process handles returned
               for processes spawned using system(1, ...).

               Not useful. (RISC OS)

       v1.39, 11 February, 1999
           Changes from Jarkko and EMX URL fixes Michael Schwern.
           Additional note about newlines added.

       v1.38, 31 December 1998
           More changes from Jarkko.

       v1.37, 19 December 1998
           More minor changes.  Merge two separate version 1.35

       v1.36, 9 September 1998
           Updated for Stratus VOS.  Also known as version 1.35.

       v1.35, 13 August 1998
           Integrate more minor changes, plus addition of new
           sections under the section on ISSUES: the section on
           Numbers endianness and Width, the section on Character
           sets and character encoding, the section on

       v1.33, 06 August 1998
           Integrate more minor changes.

       v1.32, 05 August 1998
           Integrate more minor changes.

       v1.30, 03 August 1998
           Major update for RISC OS, other minor changes.

       v1.23, 10 July 1998
           First public release with perl5.005.

       Abigail <>, Charles Bailey
       <>, Graham Barr <>,
       Tom Christiansen <>, Nicholas Clark
       <>, Andy Dougherty
       <>, Dominic Dunlop
       <>, Neale Ferguson <>
       Paul Green <>, M.J.T. Guy
       <>, Jarkko Hietaniemi <<gt>,
       Luther Huffman <>, Nick Ing-Simmons
       <>, Andreas J. Koenig
       <>, Markus Laker <>,
       Andrew M. Langmead <>, Paul Moore
       <>, Chris Nandor
       <>, Matthias Neeracher
       <>, Gary Ng
       <71564.1743@CompuServe.COM>, Tom Phoenix
       <>, Peter Prymmer <>,
       Hugo van der Sanden <>, Gurusamy
       Sarathy <>, Paul J. Schinder
       <>, Michael G Schwern
       <>, Dan Sugalski <>,
       Nathan Torkington <>.

       This document is maintained by Chris Nandor

       Version 1.39, last modified 11 February 1999

11/Feb/1999            perl 5.005, patch 03                     1