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,
-S<Mac OS>, VMS, etc.), consider writing platform-specific code.
+VMS, etc.), consider writing platform-specific code.
When the code will run on only two or three operating systems, you
may need to consider only the differences of those particular systems.
Perl uses C<\n> to represent the "logical" newline, where what is
logical may depend on the platform in use. In MacPerl, C<\n> always
-means C<\015>. In DOSish perls, C<\n> usually means C<\012>, but
-when accessing a file in "text" mode, STDIO translates it to (or
-from) C<\015\012>, depending on whether you're reading or writing.
-Unix does the same thing on ttys in canonical mode. C<\015\012>
-is commonly referred to as CRLF.
+means C<\015>. In DOSish perls, C<\n> usually means C<\012>, but when
+accessing a file in "text" mode, perl uses the C<:crlf> layer that
+translates it to (or from) C<\015\012>, depending on whether you're
+reading or writing. Unix does the same thing on ttys in canonical
+mode. C<\015\012> is commonly referred to as CRLF.
To trim trailing newlines from text lines use chomp(). With default
settings that function looks for a trailing C<\n> character and thus
several root directories and various "unrooted" device files such NIL:
and LPT:).
-S<Mac OS> uses C<:> as a path separator instead of C</>.
+S<Mac OS> 9 and earlier used C<:> as a path separator instead of C</>.
The filesystem may support neither hard links (C<link>) nor
symbolic links (C<symlink>, C<readlink>, C<lstat>).
(e.g. the FAT filesystem limits the time granularity to two seconds).
The "inode change timestamp" (the C<-C> filetest) may really be the
-"creation timestamp" (which it is not in UNIX).
+"creation timestamp" (which it is not in Unix).
VOS perl can emulate Unix filenames with C</> as path separator. The
native pathname characters greater-than, less-than, number-sign, and
separator, or go native and use C<.> for path separator and C<:> to
signal filesystems and disk names.
-Don't assume UNIX filesystem access semantics: that read, write,
+Don't assume Unix filesystem access semantics: that read, write,
and execute are all the permissions there are, and even if they exist,
that their semantics (for example what do r, w, and x mean on
-a directory) are the UNIX ones. The various UNIX/POSIX compatibility
+a directory) are the Unix ones. The various Unix/POSIX compatibility
layers usually try to make interfaces like chmod() work, but sometimes
there simply is no good mapping.
use File::Spec::Functions;
chdir(updir()); # go up one directory
- $file = catfile(curdir(), 'temp', 'file.txt');
+ my $file = catfile(curdir(), 'temp', 'file.txt');
# on Unix and Win32, './temp/file.txt'
- # on Mac OS, ':temp:file.txt'
+ # on Mac OS Classic, ':temp:file.txt'
# on VMS, '[.temp]file.txt'
File::Spec is available in the standard distribution as of version
better, use the three-arg version of open, unless you want the user to
be able to specify a pipe open.
- open(FILE, '<', $existing_file) or die $!;
+ open my $fh, '<', $existing_file) or die $!;
If filenames might use strange characters, it is safest to open it
with C<sysopen> instead of C<open>. C<open> is magic and can
directories.
Don't count on specific values of C<$!>, neither numeric nor
-especially the strings values-- users may switch their locales causing
+especially the strings values. Users may switch their locales causing
error messages to be translated into their languages. If you can
trust a POSIXish environment, you can portably use the symbols defined
by the Errno module, like ENOENT. And don't trust on the values of C<$!>
To convert $^X to a file pathname, taking account of the requirements
of the various operating system possibilities, say:
- use Config;
- $thisperl = $^X;
- if ($^O ne 'VMS')
- {$thisperl .= $Config{_exe} unless $thisperl =~ m/$Config{_exe}$/i;}
+ use Config;
+ my $thisperl = $^X;
+ if ($^O ne 'VMS')
+ {$thisperl .= $Config{_exe} unless $thisperl =~ m/$Config{_exe}$/i;}
To convert $Config{perlpath} to a file pathname, say:
- use Config;
- $thisperl = $Config{perlpath};
- if ($^O ne 'VMS')
- {$thisperl .= $Config{_exe} unless $thisperl =~ m/$Config{_exe}$/i;}
+ use Config;
+ my $thisperl = $Config{perlpath};
+ if ($^O ne 'VMS')
+ {$thisperl .= $Config{_exe} unless $thisperl =~ m/$Config{_exe}$/i;}
=head2 Networking
Don't assume that any particular port (service) will respond.
-Don't assume that Sys::Hostname (or any other API or command)
-returns either a fully qualified hostname or a non-qualified hostname:
-it all depends on how the system had been configured. Also remember
-things like DHCP and NAT-- the hostname you get back might not be very
-useful.
+Don't assume that Sys::Hostname (or any other API or command) returns
+either a fully qualified hostname or a non-qualified hostname: it all
+depends on how the system had been configured. Also remember that for
+things such as DHCP and NAT, the hostname you get back might not be
+very useful.
-All the above "don't":s may look daunting, and they are -- but the key
+All the above "don't":s may look daunting, and they are, but the key
is to degrade gracefully if one cannot reach the particular network
service one wants. Croaking or hanging do not look very professional.
store a date in an unambiguous representation. The ISO 8601 standard
defines YYYY-MM-DD as the date format, or YYYY-MM-DDTHH-MM-SS
(that's a literal "T" separating the date from the time).
-Please do use the ISO 8601 instead of making us to guess what
+Please do use the ISO 8601 instead of making us guess what
date 02/03/04 might be. ISO 8601 even sorts nicely as-is.
A text representation (like "1987-12-18") can be easily converted
into an OS-specific value using a module like Date::Parse.
it may be appropriate to calculate an offset for the epoch.
require Time::Local;
- $offset = Time::Local::timegm(0, 0, 0, 1, 0, 70);
+ my $offset = Time::Local::timegm(0, 0, 0, 1, 0, 70);
-The value for C<$offset> in Unix will be C<0>, but in Mac OS will be
-some large number. C<$offset> can then be added to a Unix time value
-to get what should be the proper value on any system.
+The value for C<$offset> in Unix will be C<0>, but in Mac OS Classic
+will be some large number. C<$offset> can then be added to a Unix time
+value to get what should be the proper value on any system.
=head2 Character sets and character encoding
for (0..10000000) {} # bad
for (my $x = 0; $x <= 10000000; ++$x) {} # good
- @lines = <VERY_LARGE_FILE>; # bad
+ my @lines = <$very_large_file>; # bad
- while (<FILE>) {$file .= $_} # sometimes bad
- $file = join('', <FILE>); # better
+ while (<$fh>) {$file .= $_} # sometimes bad
+ my $file = join('', <$fh>); # better
The last two constructs may appear unintuitive to most people. The
first repeatedly grows a string, whereas the second allocates a
=head2 Security
Most multi-user platforms provide basic levels of security, usually
-implemented at the filesystem level. Some, however, do
-not-- unfortunately. Thus the notion of user id, or "home" directory,
+implemented at the filesystem level. Some, however, unfortunately do
+not. 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 running
under so that you can write code explicitly for that platform (or
class of platforms).
-Don't assume the UNIX filesystem access semantics: the operating
+Don't assume the Unix filesystem access semantics: the operating
system or the filesystem may be using some ACL systems, which are
richer languages than the usual rwx. Even if the rwx exist,
their semantics might be different.
(From security viewpoint testing for permissions before attempting to
do something is silly anyway: if one tries this, there is potential
-for race conditions-- someone or something might change the
+for race conditions. Someone or something might change the
permissions between the permissions check and the actual operation.
Just try the operation.)
-Don't assume the UNIX user and group semantics: especially, don't
+Don't assume the Unix user and group semantics: especially, don't
expect the C<< $< >> and C<< $> >> (or the C<$(> and C<$)>) to work
for switching identities (or memberships).
=item *
-Mailing list: cpan-testers@perl.org
+Mailing list: cpan-testers-discuss@perl.org
=item *
-Testing results: http://testers.cpan.org/
+Testing results: http://www.cpantesters.org/
=back
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';
+ my $filespec0 = "c:/foo/bar/file.txt";
+ my $filespec1 = "c:\\foo\\bar\\file.txt";
+ my $filespec2 = 'c:\foo\bar\file.txt';
+ my $filespec3 = 'c:\\foo\\bar\\file.txt';
System calls accept either C</> or C<\> as the path separator.
However, many command-line utilities of DOS vintage treat C</> as
Windows 2000 MSWin32 MSWin32-x86 2 5 00
Windows XP MSWin32 MSWin32-x86 2 5 01
Windows 2003 MSWin32 MSWin32-x86 2 5 02
+ Windows Vista MSWin32 MSWin32-x86 2 6 00
+ Windows 7 MSWin32 MSWin32-x86 2 6 01
+ Windows 7 MSWin32 MSWin32-x64 2 6 01
Windows CE MSWin32 ? 3
Cygwin cygwin cygwin
=item *
The EMX environment for DOS, OS/2, etc. emx@iaehv.nl,
-http://www.leo.org/pub/comp/os/os2/leo/gnu/emx+gcc/index.html or
ftp://hobbes.nmsu.edu/pub/os2/dev/emx/ Also L<perlos2>.
=item *
=back
-=head2 S<Mac OS>
-
-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.
-
-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 are stored in the directory in alphabetical order. Filenames are
-limited to 31 characters, and may include any character except for
-null and C<:>, which is reserved as the path separator.
-
-Instead of C<flock>, see C<FSpSetFLock> and C<FSpRstFLock> in the
-Mac::Files module, or C<chmod(0444, ...)> and C<chmod(0666, ...)>.
-
-In the MacPerl application, you can't run a program from the command line;
-programs that expect C<@ARGV> to be populated can be edited with something
-like the following, which brings up a dialog box asking for the command
-line arguments.
-
- if (!@ARGV) {
- @ARGV = split /\s+/, MacPerl::Ask('Arguments?');
- }
-
-A MacPerl script saved as a "droplet" will populate C<@ARGV> with the full
-pathnames of the files dropped onto the script.
-
-Mac users can run programs under a type of command line interface
-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
-C<system>, backticks, and piped C<open>.
-
-"S<Mac OS>" is the proper name for the operating system, but the value
-in C<$^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';
-
-S<Mac OS X>, based on NeXT's OpenStep OS, runs MacPerl natively, under the
-"Classic" environment. There is no "Carbon" version of MacPerl to run
-under the primary Mac OS X environment. S<Mac OS X> and its Open Source
-version, Darwin, both run Unix perl natively.
-
-Also see:
-
-=over 4
-
-=item *
-
-MacPerl Development, http://dev.macperl.org/ .
-
-=item *
-
-The MacPerl Pages, http://www.macperl.com/ .
-
-=item *
-
-The MacPerl mailing lists, http://lists.perl.org/ .
-
-=item *
-
-MPW, ftp://ftp.apple.com/developer/Tool_Chest/Core_Mac_OS_Tools/
-
-=back
-
=head2 VMS
Perl on VMS is discussed in L<perlvms> in the perl distribution.
shell or file parsing utilities need to be prefixed with the C<^>
character, or replaced with hexadecimal characters prefixed with the
C<^> character. Such prefixing is only needed with the pathnames are
-in VMS format in applications. Programs that can accept the UNIX format
+in VMS format in applications. Programs that can accept the Unix format
of pathnames do not need the escape characters. The maximum length for
filenames is 255 characters. The ODS-5 file system can handle both
a case preserved and a case sensitive mode.
settings to preserve backward compatibility with Perl scripts that
assume the previous VMS limitations.
-In general routines on VMS that get a UNIX format file specification
-should return it in a UNIX format, and when they get a VMS format
+In general routines on VMS that get a Unix format file specification
+should return it in a Unix format, and when they get a VMS format
specification they should return a VMS format unless they are documented
to do a conversion.
For routines that generate return a file specification, VMS allows setting
if the C library which Perl is built on if it will be returned in VMS
-format or in UNIX format.
+format or in Unix format.
With the ODS-2 file system, there is not much difference in syntax of
-filenames without paths for VMS or UNIX. With the extended character
+filenames without paths for VMS or Unix. With the extended character
set available with ODS-5 there can be a significant difference.
Because of this, existing Perl scripts written for VMS were sometimes
-treating VMS and UNIX filenames interchangeably. Without the extended
+treating VMS and Unix filenames interchangeably. Without the extended
character set enabled, this behavior will mostly be maintained for
backwards compatibility.
When extended characters are enabled with ODS-5, the handling of
-UNIX formatted file specifications is to that of a UNIX system.
+Unix formatted file specifications is to that of a Unix system.
VMS file specifications without extensions have a trailing dot. An
-equivalent UNIX file specification should not show the trailing dot.
+equivalent Unix file specification should not show the trailing dot.
The result of all of this, is that for VMS, for portable scripts, you
can not depend on Perl to present the filenames in lowercase, to be
case sensitive, and that the filenames could be returned in either
-UNIX or VMS format.
+Unix or VMS format.
And if a routine returns a file specification, unless it is intended to
convert it, it should return it in the same format as it found it.
C<open(FH, 'A')>).
With support for extended file specifications and if C<opendir> was
-given a U
NIX format directory, a file named F<A.;5> will return F<a>
+given a U
nix format directory, a file named F<A.;5> will return F<a>
and optionally in the exact case on the disk. When C<opendir> is given
a VMS format directory, then C<readdir> should return F<a.>, and
again with the optionally the exact case.
directory levels have snuck into the core by running the following in the
top-level source directory:
- $ perl -ne "$_=~s/\s+.*//; print if scalar(split /\//) > 8;" < MANIFEST
+ $ perl -ne "$_=~s/\s+.*//; print if scalar(split /\//) > 8;" < MANIFEST
The VMS::Filespec module, which gets installed as part of the build
=head2 VOS
-Perl on VOS is discussed in F<README.vos> in the perl distribution
-(installed as L<perlvos>). Perl on VOS can accept either VOS- or
-Unix-style file specifications as in either of the following:
+Perl on VOS (also known as OpenVOS) is discussed in F<README.vos>
+in the perl distribution (installed as L<perlvos>). Perl on VOS
+can accept either VOS- or Unix-style file specifications as in
+either of the following:
$ perl -ne "print if /perl_setup/i" >system>notices
$ perl -ne "print if /perl_setup/i" /system/notices
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. Note that VOS limits
-file names to 32 or fewer characters, file names cannot start with a
-C<-> character, or contain any character matching C<< tr/ !%&'()*+;<>?// >>
-
-The value of C<$^O> on VOS is "VOS". To determine the architecture that
-you are running on without resorting to loading all of C<%Config> you
-can examine the content of the @INC array like so:
+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.
+
+Older releases of VOS (prior to OpenVOS Release 17.0) limit file
+names to 32 or fewer characters, prohibit file names from
+starting with a C<-> character, and prohibit file names from
+containing any character matching C<< tr/ !#%&'()*;<=>?// >>.
+
+Newer releases of VOS (OpenVOS Release 17.0 or later) support a
+feature known as extended names. On these releases, file names
+can contain up to 255 characters, are prohibited from starting
+with a C<-> character, and the set of prohibited characters is
+reduced to any character matching C<< tr/#%*<>?// >>. There are
+restrictions involving spaces and apostrophies: these characters
+must not begin or end a name, nor can they immediately precede or
+follow a period. Additionally, a space must not immediately
+precede another space or hyphen. Specifically, the following
+character combinations are prohibited: space-space,
+space-hyphen, period-space, space-period, period-apostrophe,
+apostrophe-period, leading or trailing space, and leading or
+trailing apostrophe. Although an extended file name is limited
+to 255 characters, a path name is still limited to 256
+characters.
+
+The value of C<$^O> on VOS is "VOS". To determine the
+architecture that you are running on without resorting to loading
+all of C<%Config> you can examine the content of the @INC array
+like so:
if ($^O =~ /VOS/) {
print "I'm on a Stratus box!\n";
The 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 majordomo@list.stratagy.com.
+comments to the comp.sys.stratus newsgroup, or use the contact
+information located in the distribution files on the Stratus
+Anonymous FTP site.
=item *
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 ("\t" eq "\005") { print "EBCDIC may be spoken here!\n"; }
if (ord('A') == 193) { print "EBCDIC may be spoken here!\n"; }
=item *
HP 300 MPE/iX, F<README.mpeix> and Mark Bixby's web page
-http://www.bixby.org/mark/perlix.html
+http://www.bixby.org/mark/porting.html
=item *
=item -X
-C<-r>, C<-w>, and C<-x> have a limited meaning only; directories
-and applications are executable, and there are no uid/gid
-considerations. C<-o> is not supported. (S<Mac OS>)
-
C<-w> only inspects the read-only file attribute (FILE_ATTRIBUTE_READONLY),
which determines whether the directory can be deleted, not whether it can
be written to. Directories always have read and write access unless denied
C<-r>, C<-w>, C<-x>, and C<-o> tell whether the file is accessible,
which may not reflect UIC-based file protections. (VMS)
-C<-s> returns the size of the data fork, not the total size of data fork
-plus resource fork. (S<Mac OS>).
-
C<-s> by name on an open file will return the space reserved on disk,
rather than the current extent. C<-s> on an open filehandle returns the
current size. (S<RISC OS>)
C<-R>, C<-W>, C<-X>, C<-O> are indistinguishable from C<-r>, C<-w>,
-C<-x>, C<-o>. (S<Mac OS>, Win32, VMS, S<RISC OS>)
-
-C<-b>, C<-c>, C<-k>, C<-g>, C<-p>, C<-u>, C<-A> are not implemented.
-(S<Mac OS>)
+C<-x>, C<-o>. (Win32, VMS, S<RISC OS>)
C<-g>, C<-k>, C<-l>, C<-u>, C<-A> are not particularly meaningful.
(Win32, VMS, S<RISC OS>)
C<-d> is true if passed a device spec without an explicit directory.
(VMS)
-C<-T> and C<-B> are implemented, but might misclassify Mac text files
-with foreign characters; this is the case will all platforms, but may
-affect S<Mac OS> often. (S<Mac OS>)
-
C<-x> (or C<-X>) determine if a file ends in one of the executable
suffixes. C<-S> is meaningless. (Win32)
C<-x> (or C<-X>) determine if a file has an executable file type.
(S<RISC OS>)
+=item alarm
+
+Emulated using timers that must be explicitly polled whenever Perl
+wants to dispatch "safe signals" and therefore cannot interrupt
+blocking system calls. (Win32)
+
=item atan2
Due to issues with various CPUs, math libraries, compilers, and standards,
=item binmode
-Meaningless. (S<Mac OS>, S<RISC OS>)
+Meaningless. (S<RISC OS>)
Reopens file and restores pointer; if function fails, underlying
filehandle may be closed, or pointer may be in a different position.
=item chmod
-Only limited meaning. Disabling/enabling write permission is mapped to
-locking/unlocking the file. (S<Mac OS>)
-
Only good for changing "owner" read-write access, "group", and "other"
bits are meaningless. (Win32)
=item chown
-Not implemented. (
S<Mac OS>, Win32, S<Plan 9>, S<RISC OS>)
+Not implemented. (Win32, S<Plan 9>, S<RISC OS>)
Does nothing, but won't fail. (Win32)
=item chroot
-Not implemented. (
S<Mac OS>, Win32, VMS, S<Plan 9>, S<RISC OS>, VOS, VM/ESA)
+Not implemented. (Win32, VMS, S<Plan 9>, S<RISC OS>, VOS, VM/ESA)
=item crypt
=item dump
-Not useful. (S<Mac OS>, S<RISC OS>)
+Not useful. (S<RISC OS>)
Not supported. (Cygwin, Win32)
=item exec
-Not implemented. (S<Mac OS>)
-
Implemented via Spawn. (VM/ESA)
Does not automatically flush output handles on some platforms.
=item exit
-Emulates UNIX exit() (which considers C<exit 1> to indicate an error) by
+Emulates Unix exit() (which considers C<exit 1> to indicate an error) by
mapping the C<1> to SS$_ABORT (C<44>). This behavior may be overridden
with the pragma C<use vmsish 'exit'>. As with the CRTL's exit()
function, C<exit 0> is also mapped to an exit status of SS$_NORMAL
=item flock
-Not implemented (S<Mac OS>, VMS, S<RISC OS>, VOS).
+Not implemented (VMS, S<RISC OS>, VOS).
Available only on Windows NT (not on Windows 95). (Win32)
=item fork
-Not implemented. (S<Mac OS>, AmigaOS, S<RISC OS>, VM/ESA, VMS)
+Not implemented. (AmigaOS, S<RISC OS>, VM/ESA, VMS)
Emulated using multiple interpreters. See L<perlfork>. (Win32)
=item getlogin
-Not implemented. (S<Mac OS>, S<RISC OS>)
+Not implemented. (S<RISC OS>)
=item getpgrp
-Not implemented. (S<Mac OS>, Win32, VMS, S<RISC OS>)
+Not implemented. (Win32, VMS, S<RISC OS>)
=item getppid
-Not implemented. (S<Mac OS>, Win32, S<RISC OS>)
+Not implemented. (Win32, S<RISC OS>)
=item getpriority
-Not implemented. (S<Mac OS>, Win32, VMS, S<RISC OS>, VOS, VM/ESA)
+Not implemented. (Win32, VMS, S<RISC OS>, VOS, VM/ESA)
=item getpwnam
-Not implemented. (S<Mac OS>, Win32)
+Not implemented. (Win32)
Not useful. (S<RISC OS>)
=item getgrnam
-Not implemented. (S<Mac OS>, Win32, VMS, S<RISC OS>)
+Not implemented. (Win32, VMS, S<RISC OS>)
=item getnetbyname
-Not implemented. (
S<Mac OS>, Win32, S<Plan 9>)
+Not implemented. (Win32, S<Plan 9>)
=item getpwuid
-Not implemented. (S<Mac OS>, Win32)
+Not implemented. (Win32)
Not useful. (S<RISC OS>)
=item getgrgid
-Not implemented. (S<Mac OS>, Win32, VMS, S<RISC OS>)
+Not implemented. (Win32, VMS, S<RISC OS>)
=item getnetbyaddr
-Not implemented. (
S<Mac OS>, Win32, S<Plan 9>)
+Not implemented. (Win32, S<Plan 9>)
=item getprotobynumber
-Not implemented. (S<Mac OS>)
-
=item getservbyport
-Not implemented. (S<Mac OS>)
-
=item getpwent
-Not implemented. (S<Mac OS>, Win32, VM/ESA)
+Not implemented. (Win32, VM/ESA)
=item getgrent
-Not implemented. (S<Mac OS>, Win32, VMS, VM/ESA)
+Not implemented. (Win32, VMS, VM/ESA)
=item gethostbyname
C<gethostbyname('localhost')> does not work everywhere: you may have
-to use C<gethostbyname('127.0.0.1')>. (S<Mac OS>, S<Irix 5>)
+to use C<gethostbyname('127.0.0.1')>. (S<Irix 5>)
=item gethostent
-Not implemented. (S<Mac OS>, Win32)
+Not implemented. (Win32)
=item getnetent
-Not implemented. (
S<Mac OS>, Win32, S<Plan 9>)
+Not implemented. (Win32, S<Plan 9>)
=item getprotoent
-Not implemented. (
S<Mac OS>, Win32, S<Plan 9>)
+Not implemented. (Win32, S<Plan 9>)
=item getservent
=item sethostent
-Not implemented. (
S<Mac OS>, Win32, S<Plan 9>, S<RISC OS>)
+Not implemented. (Win32, S<Plan 9>, S<RISC OS>)
=item setnetent
-Not implemented. (
S<Mac OS>, Win32, S<Plan 9>, S<RISC OS>)
+Not implemented. (Win32, S<Plan 9>, S<RISC OS>)
=item setprotoent
-Not implemented. (
S<Mac OS>, Win32, S<Plan 9>, S<RISC OS>)
+Not implemented. (Win32, S<Plan 9>, S<RISC OS>)
=item setservent
=item endpwent
-Not implemented. (S<Mac OS>, MPE/iX, VM/ESA, Win32)
+Not implemented. (MPE/iX, VM/ESA, Win32)
=item endgrent
-Not implemented. (S<Mac OS>, MPE/iX, S<RISC OS>, VM/ESA, VMS, Win32)
+Not implemented. (MPE/iX, S<RISC OS>, VM/ESA, VMS, Win32)
=item endhostent
-Not implemented. (S<Mac OS>, Win32)
+Not implemented. (Win32)
=item endnetent
-Not implemented. (
S<Mac OS>, Win32, S<Plan 9>)
+Not implemented. (Win32, S<Plan 9>)
=item endprotoent
-Not implemented. (
S<Mac OS>, Win32, S<Plan 9>)
+Not implemented. (Win32, S<Plan 9>)
=item endservent
it will become inaccurate as the time gets larger. This is a bug and
will be fixed in the future.
+On VOS, time values are 32-bit quantities.
+
=item ioctl FILEHANDLE,FUNCTION,SCALAR
Not implemented. (VMS)
=item kill
-C<kill(0, LIST)> is implemented for the sake of taint checking;
-use with other signals is unimplemented. (S<Mac OS>)
-
Not implemented, hence not useful for taint checking. (S<RISC OS>)
C<kill()> doesn't have the semantics of C<raise()>, i.e. it doesn't send
=item link
-Not implemented. (S<Mac OS>, MPE/iX, S<RISC OS>)
+Not implemented. (MPE/iX, S<RISC OS>, VOS)
Link count not updated because hard links are not quite that hard
(They are sort of half-way between hard and soft links). (AmigaOS)
=item localtime
-localtime() has the same range as L<gmtime>, but because time zone
+localtime() has the same range as L</gmtime>, but because time zone
rules change its accuracy for historical and future times may degrade
but usually by no more than an hour.
=item msgrcv
-Not implemented. (
S<Mac OS>, Win32, VMS, S<Plan 9>, S<RISC OS>, VOS)
+Not implemented. (Win32, VMS, S<Plan 9>, S<RISC OS>, VOS)
=item open
-The C<|> variants are supported only if ToolServer is installed.
-(S<Mac OS>)
-
-open to C<|-> and C<-|> are unsupported. (S<Mac OS>, Win32, S<RISC OS>)
+open to C<|-> and C<-|> are unsupported. (Win32, S<RISC OS>)
Opening a process does not automatically flush output handles on some
platforms. (SunOS, Solaris, HP-UX)
Can't move directories between directories on different logical volumes. (Win32)
+=item rewinddir
+
+Will not cause readdir() to re-read the directory stream. The entries
+already read before the rewinddir() call will just be returned again
+from a cache buffer. (Win32)
+
=item select
Only implemented on sockets. (Win32, VMS)
=item semop
-Not implemented. (S<Mac OS>, Win32, VMS, S<RISC OS>, VOS)
+Not implemented. (Win32, VMS, S<RISC OS>)
=item setgrent
-Not implemented. (S<Mac OS>, MPE/iX, VMS, Win32, S<RISC OS>, VOS)
+Not implemented. (MPE/iX, VMS, Win32, S<RISC OS>)
=item setpgrp
-Not implemented. (S<Mac OS>, Win32, VMS, S<RISC OS>, VOS)
+Not implemented. (Win32, VMS, S<RISC OS>, VOS)
=item setpriority
-Not implemented. (S<Mac OS>, Win32, VMS, S<RISC OS>, VOS)
+Not implemented. (Win32, VMS, S<RISC OS>, VOS)
=item setpwent
-Not implemented. (S<Mac OS>, MPE/iX, Win32, S<RISC OS>, VOS)
+Not implemented. (MPE/iX, Win32, S<RISC OS>)
=item setsockopt
=item shmwrite
-Not implemented. (S<Mac OS>, Win32, VMS, S<RISC OS>, VOS)
+Not implemented. (Win32, VMS, S<RISC OS>, VOS)
=item sockatmark
A relatively recent addition to socket functions, may not
-be implemented even in UNIX platforms.
+be implemented even in Unix platforms.
=item socketpair
-Not implemented. (S<RISC OS>, VOS, VM/ESA)
+Not implemented. (S<RISC OS>, VM/ESA)
+
+Available on OpenVOS Release 17.0 or later. (VOS)
Available on 64 bit OpenVMS 8.2 and later. (VMS)
as '', so numeric comparison or manipulation of these fields may cause
'not numeric' warnings.
-mtime and atime are the same thing, and ctime is creation time instead of
-inode change time. (S<Mac OS>).
-
ctime not supported on UFS (S<Mac OS X>).
ctime is creation time instead of inode change time (Win32).
=item syscall
-Not implemented. (S<Mac OS>, Win32, VMS, S<RISC OS>, VOS, VM/ESA)
+Not implemented. (Win32, VMS, S<RISC OS>, VOS, VM/ESA)
=item sysopen
=item system
-Only implemented if ToolServer is installed. (S<Mac OS>)
-
As an optimization, may not call the command shell specified in
C<$ENV{PERL5SHELL}>. C<system(1, @args)> spawns an external
process and immediately returns its process designator, without
=item times
-Only the first entry returned is nonzero. (S<Mac OS>)
-
"cumulative" times will be bogus. On anything other than Windows NT
or Windows 2000, "system" time will be bogus, and "user" time is
actually the time returned by the clock() function in the C runtime
=item utime
-Only the modification time is updated. (S<BeOS>, S<Mac OS>, VMS, S<RISC OS>)
+Only the modification time is updated. (S<BeOS>, VMS, S<RISC OS>)
May not behave as expected. Behavior depends on the C runtime
library's implementation of utime(), and the filesystem being
=item waitpid
-Not implemented. (S<Mac OS>)
-
Can only be applied to process handles returned for processes spawned
using C<system(1, ...)> or pseudo processes created with C<fork()>. (Win32)
=head1 Supported Platforms
-As of July 2002 (the Perl release 5.8.0), the following platforms are
+The following platforms are known to build Perl 5.12 (as of April 2010,
+its release date) from the standard source code distribution available
+at http://www.cpan.org/src
+
+=over
+
+=item Linux (x86, ARM, IA64)
+
+=item HP-UX
+
+=item AIX
+
+=item Win32
+
+=over
+
+=item Windows 2000
+
+=item Windows XP
+
+=item Windows Server 2003
+
+=item Windows Vista
+
+=item Windows Server 2008
+
+=item Windows 7
+
+=back
+
+=item Cygwin
+
+=item Solaris (x86, SPARC)
+
+=item OpenVMS
+
+=over
+
+=item Alpha (7.2 and later)
+
+=item I64 (8.2 and later)
+
+=back
+
+=item Symbian
+
+=item NetBSD
+
+=item FreeBSD
+
+=item Haiku
+
+=item Irix (6.5. What else?)
+
+=item OpenBSD
+
+=item Dragonfly BSD
+
+=item QNX Neutrino RTOS (6.5.0)
+
+=item MirOS BSD
+
+Caveats:
+
+=over
+
+=item time_t issues that may or may not be fixed
+
+=back
+
+
+=item Symbian (Series 60 v3, 3.2 and 5 - what else?)
+
+=item Stratus VOS / OpenVOS
+
+=item AIX
+
+=back
+
+=head1 EOL Platforms (Perl 5.12)
+
+The following platforms were supported by a previous version of
+Perl but have been officially removed from Perl's source code
+as of 5.12:
+
+=over
+
+=item Atari MiNT
+
+=item Apollo Domain/OS
+
+=item Apple Mac OS 8/9
+
+=item Tenon Machten
+
+=back
+
+The following platforms may still work as of Perl 5.12, but Perl's
+developers have made an explicit decision to discontinue support for
+them:
+
+=over
+
+=item Windows 95
+
+=item Windows 98
+
+=item Windows ME
+
+=item Windows NT4
+
+=back
+
+=head1 Supported Platforms (Perl 5.8)
+
+As of July 2002 (the Perl release 5.8.0), the following platforms were
able to build Perl from the standard source code distribution
-available at http://www.cpan.org/src/index.html
+available at http://www.cpan.org/src/
AIX
BeOS
https://perl5.git.perl.org / perl5.git / blobdiff