source: trunk/third/perl/pod/perlport.pod @ 17035

Revision 17035, 68.4 KB checked in by zacheiss, 23 years ago (diff)
This commit was generated by cvs2svn to compensate for changes in r17034, which included commits to RCS files with non-trunk default branches.
Line 
1=head1 NAME
2
3perlport - Writing portable Perl
4
5=head1 DESCRIPTION
6
7Perl runs on numerous operating systems.  While most of them share
8much in common, they also have their own unique features.
9
10This document is meant to help you to find out what constitutes portable
11Perl code.  That way once you make a decision to write portably,
12you know where the lines are drawn, and you can stay within them.
13
14There is a tradeoff between taking full advantage of one particular
15type of computer and taking advantage of a full range of them.
16Naturally, as you broaden your range and become more diverse, the
17common factors drop, and you are left with an increasingly smaller
18area of common ground in which you can operate to accomplish a
19particular task.  Thus, when you begin attacking a problem, it is
20important to consider under which part of the tradeoff curve you
21want to operate.  Specifically, you must decide whether it is
22important that the task that you are coding have the full generality
23of being portable, or whether to just get the job done right now.
24This is the hardest choice to be made.  The rest is easy, because
25Perl provides many choices, whichever way you want to approach your
26problem.
27
28Looking at it another way, writing portable code is usually about
29willfully limiting your available choices.  Naturally, it takes
30discipline and sacrifice to do that.  The product of portability
31and convenience may be a constant.  You have been warned.
32
33Be aware of two important points:
34
35=over 4
36
37=item Not all Perl programs have to be portable
38
39There is no reason you should not use Perl as a language to glue Unix
40tools together, or to prototype a Macintosh application, or to manage the
41Windows registry.  If it makes no sense to aim for portability for one
42reason or another in a given program, then don't bother.
43
44=item Nearly all of Perl already I<is> portable
45
46Don't be fooled into thinking that it is hard to create portable Perl
47code.  It isn't.  Perl tries its level-best to bridge the gaps between
48what's available on different platforms, and all the means available to
49use those features.  Thus almost all Perl code runs on any machine
50without modification.  But there are some significant issues in
51writing portable code, and this document is entirely about those issues.
52
53=back
54
55Here's the general rule: When you approach a task commonly done
56using a whole range of platforms, think about writing portable
57code.  That way, you don't sacrifice much by way of the implementation
58choices you can avail yourself of, and at the same time you can give
59your users lots of platform choices.  On the other hand, when you have to
60take advantage of some unique feature of a particular platform, as is
61often the case with systems programming (whether for Unix, Windows,
62S<Mac OS>, VMS, etc.), consider writing platform-specific code.
63
64When the code will run on only two or three operating systems, you
65may need to consider only the differences of those particular systems.
66The important thing is to decide where the code will run and to be
67deliberate in your decision.
68
69The material below is separated into three main sections: main issues of
70portability (L<"ISSUES">, platform-specific issues (L<"PLATFORMS">, and
71built-in perl functions that behave differently on various ports
72(L<"FUNCTION IMPLEMENTATIONS">.
73
74This information should not be considered complete; it includes possibly
75transient information about idiosyncrasies of some of the ports, almost
76all of which are in a state of constant evolution.  Thus, this material
77should be considered a perpetual work in progress
78(<IMG SRC="yellow_sign.gif" ALT="Under Construction">).
79
80=head1 ISSUES
81
82=head2 Newlines
83
84In most operating systems, lines in files are terminated by newlines.
85Just what is used as a newline may vary from OS to OS.  Unix
86traditionally uses C<\012>, one type of DOSish I/O uses C<\015\012>,
87and S<Mac OS> uses C<\015>.
88
89Perl uses C<\n> to represent the "logical" newline, where what is
90logical may depend on the platform in use.  In MacPerl, C<\n> always
91means C<\015>.  In DOSish perls, C<\n> usually means C<\012>, but
92when accessing a file in "text" mode, STDIO translates it to (or
93from) C<\015\012>, depending on whether you're reading or writing.
94Unix does the same thing on ttys in canonical mode.  C<\015\012>
95is commonly referred to as CRLF.
96
97A common cause of unportable programs is the misuse of chop() to trim
98newlines:
99
100    # XXX UNPORTABLE!
101    while(<FILE>) {
102        chop;
103        @array = split(/:/);
104        #...
105    }
106
107You can get away with this on Unix and MacOS (they have a single
108character end-of-line), but the same program will break under DOSish
109perls because you're only chop()ing half the end-of-line.  Instead,
110chomp() should be used to trim newlines.  The Dunce::Files module can
111help audit your code for misuses of chop().
112
113When dealing with binary files (or text files in binary mode) be sure
114to explicitly set $/ to the appropriate value for your file format
115before using chomp().
116
117Because of the "text" mode translation, DOSish perls have limitations
118in using C<seek> and C<tell> on a file accessed in "text" mode.
119Stick to C<seek>-ing to locations you got from C<tell> (and no
120others), and you are usually free to use C<seek> and C<tell> even
121in "text" mode.  Using C<seek> or C<tell> or other file operations
122may be non-portable.  If you use C<binmode> on a file, however, you
123can usually C<seek> and C<tell> with arbitrary values in safety.
124
125A common misconception in socket programming is that C<\n> eq C<\012>
126everywhere.  When using protocols such as common Internet protocols,
127C<\012> and C<\015> are called for specifically, and the values of
128the logical C<\n> and C<\r> (carriage return) are not reliable.
129
130    print SOCKET "Hi there, client!\r\n";      # WRONG
131    print SOCKET "Hi there, client!\015\012";  # RIGHT
132
133However, using C<\015\012> (or C<\cM\cJ>, or C<\x0D\x0A>) can be tedious
134and unsightly, as well as confusing to those maintaining the code.  As
135such, the Socket module supplies the Right Thing for those who want it.
136
137    use Socket qw(:DEFAULT :crlf);
138    print SOCKET "Hi there, client!$CRLF"      # RIGHT
139
140When reading from a socket, remember that the default input record
141separator C<$/> is C<\n>, but robust socket code will recognize as
142either C<\012> or C<\015\012> as end of line:
143
144    while (<SOCKET>) {
145        # ...
146    }
147
148Because both CRLF and LF end in LF, the input record separator can
149be set to LF and any CR stripped later.  Better to write:
150
151    use Socket qw(:DEFAULT :crlf);
152    local($/) = LF;      # not needed if $/ is already \012
153
154    while (<SOCKET>) {
155        s/$CR?$LF/\n/;   # not sure if socket uses LF or CRLF, OK
156    #   s/\015?\012/\n/; # same thing
157    }
158
159This example is preferred over the previous one--even for Unix
160platforms--because now any C<\015>'s (C<\cM>'s) are stripped out
161(and there was much rejoicing).
162
163Similarly, functions that return text data--such as a function that
164fetches a web page--should sometimes translate newlines before
165returning the data, if they've not yet been translated to the local
166newline representation.  A single line of code will often suffice:
167
168    $data =~ s/\015?\012/\n/g;
169    return $data;
170
171Some of this may be confusing.  Here's a handy reference to the ASCII CR
172and LF characters.  You can print it out and stick it in your wallet.
173
174    LF  ==  \012  ==  \x0A  ==  \cJ  ==  ASCII 10
175    CR  ==  \015  ==  \x0D  ==  \cM  ==  ASCII 13
176
177             | Unix | DOS  | Mac  |
178        ---------------------------
179        \n   |  LF  |  LF  |  CR  |
180        \r   |  CR  |  CR  |  LF  |
181        \n * |  LF  | CRLF |  CR  |
182        \r * |  CR  |  CR  |  LF  |
183        ---------------------------
184        * text-mode STDIO
185
186The Unix column assumes that you are not accessing a serial line
187(like a tty) in canonical mode.  If you are, then CR on input becomes
188"\n", and "\n" on output becomes CRLF.
189
190These are just the most common definitions of C<\n> and C<\r> in Perl.
191There may well be others.
192
193=head2 Numbers endianness and Width
194
195Different CPUs store integers and floating point numbers in different
196orders (called I<endianness>) and widths (32-bit and 64-bit being the
197most common today).  This affects your programs when they attempt to transfer
198numbers in binary format from one CPU architecture to another,
199usually either "live" via network connection, or by storing the
200numbers to secondary storage such as a disk file or tape.
201
202Conflicting storage orders make utter mess out of the numbers.  If a
203little-endian host (Intel, VAX) stores 0x12345678 (305419896 in
204decimal), a big-endian host (Motorola, Sparc, PA) reads it as
2050x78563412 (2018915346 in decimal).  Alpha and MIPS can be either:
206Digital/Compaq used/uses them in little-endian mode; SGI/Cray uses
207them in big-endian mode.  To avoid this problem in network (socket)
208connections use the C<pack> and C<unpack> formats C<n> and C<N>, the
209"network" orders.  These are guaranteed to be portable.
210
211You can explore the endianness of your platform by unpacking a
212data structure packed in native format such as:
213
214    print unpack("h*", pack("s2", 1, 2)), "\n";
215    # '10002000' on e.g. Intel x86 or Alpha 21064 in little-endian mode
216    # '00100020' on e.g. Motorola 68040
217
218If you need to distinguish between endian architectures you could use
219either of the variables set like so:
220
221    $is_big_endian   = unpack("h*", pack("s", 1)) =~ /01/;
222    $is_little_endian = unpack("h*", pack("s", 1)) =~ /^1/;
223
224Differing widths can cause truncation even between platforms of equal
225endianness.  The platform of shorter width loses the upper parts of the
226number.  There is no good solution for this problem except to avoid
227transferring or storing raw binary numbers.
228
229One can circumnavigate both these problems in two ways.  Either
230transfer and store numbers always in text format, instead of raw
231binary, or else consider using modules like Data::Dumper (included in
232the standard distribution as of Perl 5.005) and Storable.  Keeping
233all data as text significantly simplifies matters.
234
235=head2 Files and Filesystems
236
237Most platforms these days structure files in a hierarchical fashion.
238So, it is reasonably safe to assume that all platforms support the
239notion of a "path" to uniquely identify a file on the system.  How
240that path is really written, though, differs considerably.
241
242Although similar, file path specifications differ between Unix,
243Windows, S<Mac OS>, OS/2, VMS, VOS, S<RISC OS>, and probably others.
244Unix, for example, is one of the few OSes that has the elegant idea
245of a single root directory.
246
247DOS, OS/2, VMS, VOS, and Windows can work similarly to Unix with C</>
248as path separator, or in their own idiosyncratic ways (such as having
249several root directories and various "unrooted" device files such NIL:
250and LPT:).
251
252S<Mac OS> uses C<:> as a path separator instead of C</>.
253
254The filesystem may support neither hard links (C<link>) nor
255symbolic links (C<symlink>, C<readlink>, C<lstat>).
256
257The filesystem may support neither access timestamp nor change
258timestamp (meaning that about the only portable timestamp is the
259modification timestamp), or one second granularity of any timestamps
260(e.g. the FAT filesystem limits the time granularity to two seconds).
261
262VOS perl can emulate Unix filenames with C</> as path separator.  The
263native pathname characters greater-than, less-than, number-sign, and
264percent-sign are always accepted.
265
266S<RISC OS> perl can emulate Unix filenames with C</> as path
267separator, or go native and use C<.> for path separator and C<:> to
268signal filesystems and disk names.
269
270If all this is intimidating, have no (well, maybe only a little)
271fear.  There are modules that can help.  The File::Spec modules
272provide methods to do the Right Thing on whatever platform happens
273to be running the program.
274
275    use File::Spec::Functions;
276    chdir(updir());        # go up one directory
277    $file = catfile(curdir(), 'temp', 'file.txt');
278    # on Unix and Win32, './temp/file.txt'
279    # on Mac OS, ':temp:file.txt'
280    # on VMS, '[.temp]file.txt'
281
282File::Spec is available in the standard distribution as of version
2835.004_05.  File::Spec::Functions is only in File::Spec 0.7 and later,
284and some versions of perl come with version 0.6.  If File::Spec
285is not updated to 0.7 or later, you must use the object-oriented
286interface from File::Spec (or upgrade File::Spec).
287
288In general, production code should not have file paths hardcoded.
289Making them user-supplied or read from a configuration file is
290better, keeping in mind that file path syntax varies on different
291machines.
292
293This is especially noticeable in scripts like Makefiles and test suites,
294which often assume C</> as a path separator for subdirectories.
295
296Also of use is File::Basename from the standard distribution, which
297splits a pathname into pieces (base filename, full path to directory,
298and file suffix).
299
300Even when on a single platform (if you can call Unix a single platform),
301remember not to count on the existence or the contents of particular
302system-specific files or directories, like F</etc/passwd>,
303F</etc/sendmail.conf>, F</etc/resolv.conf>, or even F</tmp/>.  For
304example, F</etc/passwd> may exist but not contain the encrypted
305passwords, because the system is using some form of enhanced security.
306Or it may not contain all the accounts, because the system is using NIS.
307If code does need to rely on such a file, include a description of the
308file and its format in the code's documentation, then make it easy for
309the user to override the default location of the file.
310
311Don't assume a text file will end with a newline.  They should,
312but people forget.
313
314Do not have two files of the same name with different case, like
315F<test.pl> and F<Test.pl>, as many platforms have case-insensitive
316filenames.  Also, try not to have non-word characters (except for C<.>)
317in the names, and keep them to the 8.3 convention, for maximum
318portability, onerous a burden though this may appear.
319
320Likewise, when using the AutoSplit module, try to keep your functions to
3218.3 naming and case-insensitive conventions; or, at the least,
322make it so the resulting files have a unique (case-insensitively)
323first 8 characters.
324
325Whitespace in filenames is tolerated on most systems, but not all.
326Many systems (DOS, VMS) cannot have more than one C<.> in their filenames.
327
328Don't assume C<< > >> won't be the first character of a filename.
329Always use C<< < >> explicitly to open a file for reading,
330unless you want the user to be able to specify a pipe open.
331
332    open(FILE, "< $existing_file") or die $!;
333
334If filenames might use strange characters, it is safest to open it
335with C<sysopen> instead of C<open>.  C<open> is magic and can
336translate characters like C<< > >>, C<< < >>, and C<|>, which may
337be the wrong thing to do.  (Sometimes, though, it's the right thing.)
338
339=head2 System Interaction
340
341Not all platforms provide a command line.  These are usually platforms
342that rely primarily on a Graphical User Interface (GUI) for user
343interaction.  A program requiring a command line interface might
344not work everywhere.  This is probably for the user of the program
345to deal with, so don't stay up late worrying about it.
346
347Some platforms can't delete or rename files held open by the system.
348Remember to C<close> files when you are done with them.  Don't
349C<unlink> or C<rename> an open file.  Don't C<tie> or C<open> a
350file already tied or opened; C<untie> or C<close> it first.
351
352Don't open the same file more than once at a time for writing, as some
353operating systems put mandatory locks on such files.
354
355Don't count on a specific environment variable existing in C<%ENV>.
356Don't count on C<%ENV> entries being case-sensitive, or even
357case-preserving.  Don't try to clear %ENV by saying C<%ENV = ();>, or,
358if you really have to, make it conditional on C<$^O ne 'VMS'> since in
359VMS the C<%ENV> table is much more than a per-process key-value string
360table.
361
362Don't count on signals or C<%SIG> for anything.
363
364Don't count on filename globbing.  Use C<opendir>, C<readdir>, and
365C<closedir> instead.
366
367Don't count on per-program environment variables, or per-program current
368directories.
369
370Don't count on specific values of C<$!>.
371
372=head2 Interprocess Communication (IPC)
373
374In general, don't directly access the system in code meant to be
375portable.  That means, no C<system>, C<exec>, C<fork>, C<pipe>,
376C<``>, C<qx//>, C<open> with a C<|>, nor any of the other things
377that makes being a perl hacker worth being.
378
379Commands that launch external processes are generally supported on
380most platforms (though many of them do not support any type of
381forking).  The problem with using them arises from what you invoke
382them on.  External tools are often named differently on different
383platforms, may not be available in the same location, might accept
384different arguments, can behave differently, and often present their
385results in a platform-dependent way.  Thus, you should seldom depend
386on them to produce consistent results. (Then again, if you're calling
387I<netstat -a>, you probably don't expect it to run on both Unix and CP/M.)
388
389One especially common bit of Perl code is opening a pipe to B<sendmail>:
390
391    open(MAIL, '|/usr/lib/sendmail -t')
392        or die "cannot fork sendmail: $!";
393
394This is fine for systems programming when sendmail is known to be
395available.  But it is not fine for many non-Unix systems, and even
396some Unix systems that may not have sendmail installed.  If a portable
397solution is needed, see the various distributions on CPAN that deal
398with it.  Mail::Mailer and Mail::Send in the MailTools distribution are
399commonly used, and provide several mailing methods, including mail,
400sendmail, and direct SMTP (via Net::SMTP) if a mail transfer agent is
401not available.  Mail::Sendmail is a standalone module that provides
402simple, platform-independent mailing.
403
404The Unix System V IPC (C<msg*(), sem*(), shm*()>) is not available
405even on all Unix platforms.
406
407The rule of thumb for portable code is: Do it all in portable Perl, or
408use a module (that may internally implement it with platform-specific
409code, but expose a common interface).
410
411=head2 External Subroutines (XS)
412
413XS code can usually be made to work with any platform, but dependent
414libraries, header files, etc., might not be readily available or
415portable, or the XS code itself might be platform-specific, just as Perl
416code might be.  If the libraries and headers are portable, then it is
417normally reasonable to make sure the XS code is portable, too.
418
419A different type of portability issue arises when writing XS code:
420availability of a C compiler on the end-user's system.  C brings
421with it its own portability issues, and writing XS code will expose
422you to some of those.  Writing purely in Perl is an easier way to
423achieve portability.
424
425=head2 Standard Modules
426
427In general, the standard modules work across platforms.  Notable
428exceptions are the CPAN module (which currently makes connections to external
429programs that may not be available), platform-specific modules (like
430ExtUtils::MM_VMS), and DBM modules.
431
432There is no one DBM module available on all platforms.
433SDBM_File and the others are generally available on all Unix and DOSish
434ports, but not in MacPerl, where only NBDM_File and DB_File are
435available.
436
437The good news is that at least some DBM module should be available, and
438AnyDBM_File will use whichever module it can find.  Of course, then
439the code needs to be fairly strict, dropping to the greatest common
440factor (e.g., not exceeding 1K for each record), so that it will
441work with any DBM module.  See L<AnyDBM_File> for more details.
442
443=head2 Time and Date
444
445The system's notion of time of day and calendar date is controlled in
446widely different ways.  Don't assume the timezone is stored in C<$ENV{TZ}>,
447and even if it is, don't assume that you can control the timezone through
448that variable.
449
450Don't assume that the epoch starts at 00:00:00, January 1, 1970,
451because that is OS- and implementation-specific.  It is better to store a date
452in an unambiguous representation.  The ISO-8601 standard defines
453"YYYY-MM-DD" as the date format.  A text representation (like "1987-12-18")
454can be easily converted into an OS-specific value using a module like
455Date::Parse.  An array of values, such as those returned by
456C<localtime>, can be converted to an OS-specific representation using
457Time::Local.
458
459When calculating specific times, such as for tests in time or date modules,
460it may be appropriate to calculate an offset for the epoch.
461
462    require Time::Local;
463    $offset = Time::Local::timegm(0, 0, 0, 1, 0, 70);
464
465The value for C<$offset> in Unix will be C<0>, but in Mac OS will be
466some large number.  C<$offset> can then be added to a Unix time value
467to get what should be the proper value on any system.
468
469=head2 Character sets and character encoding
470
471Assume little about character sets.  Assume nothing about
472numerical values (C<ord>, C<chr>) of characters.  Do not
473assume that the alphabetic characters are encoded contiguously (in
474the numeric sense).  Do not assume anything about the ordering of the
475characters.  The lowercase letters may come before or after the
476uppercase letters; the lowercase and uppercase may be interlaced so
477that both `a' and `A' come before `b'; the accented and other
478international characters may be interlaced so that E<auml> comes
479before `b'.
480
481=head2 Internationalisation
482
483If you may assume POSIX (a rather large assumption), you may read
484more about the POSIX locale system from L<perllocale>.  The locale
485system at least attempts to make things a little bit more portable,
486or at least more convenient and native-friendly for non-English
487users.  The system affects character sets and encoding, and date
488and time formatting--amongst other things.
489
490=head2 System Resources
491
492If your code is destined for systems with severely constrained (or
493missing!) virtual memory systems then you want to be I<especially> mindful
494of avoiding wasteful constructs such as:
495
496    # NOTE: this is no longer "bad" in perl5.005
497    for (0..10000000) {}                       # bad
498    for (my $x = 0; $x <= 10000000; ++$x) {}   # good
499
500    @lines = <VERY_LARGE_FILE>;                # bad
501
502    while (<FILE>) {$file .= $_}               # sometimes bad
503    $file = join('', <FILE>);                  # better
504
505The last two constructs may appear unintuitive to most people.  The
506first repeatedly grows a string, whereas the second allocates a
507large chunk of memory in one go.  On some systems, the second is
508more efficient that the first.
509
510=head2 Security
511
512Most multi-user platforms provide basic levels of security, usually
513implemented at the filesystem level.  Some, however, do
514not--unfortunately.  Thus the notion of user id, or "home" directory,
515or even the state of being logged-in, may be unrecognizable on many
516platforms.  If you write programs that are security-conscious, it
517is usually best to know what type of system you will be running
518under so that you can write code explicitly for that platform (or
519class of platforms).
520
521=head2 Style
522
523For those times when it is necessary to have platform-specific code,
524consider keeping the platform-specific code in one place, making porting
525to other platforms easier.  Use the Config module and the special
526variable C<$^O> to differentiate platforms, as described in
527L<"PLATFORMS">.
528
529Be careful in the tests you supply with your module or programs.
530Module code may be fully portable, but its tests might not be.  This
531often happens when tests spawn off other processes or call external
532programs to aid in the testing, or when (as noted above) the tests
533assume certain things about the filesystem and paths.  Be careful
534not to depend on a specific output style for errors, such as when
535checking C<$!> after an system call.  Some platforms expect a certain
536output format, and perl on those platforms may have been adjusted
537accordingly.  Most specifically, don't anchor a regex when testing
538an error value.
539
540=head1 CPAN Testers
541
542Modules uploaded to CPAN are tested by a variety of volunteers on
543different platforms.  These CPAN testers are notified by mail of each
544new upload, and reply to the list with PASS, FAIL, NA (not applicable to
545this platform), or UNKNOWN (unknown), along with any relevant notations.
546
547The purpose of the testing is twofold: one, to help developers fix any
548problems in their code that crop up because of lack of testing on other
549platforms; two, to provide users with information about whether
550a given module works on a given platform.
551
552=over 4
553
554=item Mailing list: cpan-testers@perl.org
555
556=item Testing results: http://testers.cpan.org/
557
558=back
559
560=head1 PLATFORMS
561
562As of version 5.002, Perl is built with a C<$^O> variable that
563indicates the operating system it was built on.  This was implemented
564to help speed up code that would otherwise have to C<use Config>
565and use the value of C<$Config{osname}>.  Of course, to get more
566detailed information about the system, looking into C<%Config> is
567certainly recommended.
568
569C<%Config> cannot always be trusted, however, because it was built
570at compile time.  If perl was built in one place, then transferred
571elsewhere, some values may be wrong.  The values may even have been
572edited after the fact.
573
574=head2 Unix
575
576Perl works on a bewildering variety of Unix and Unix-like platforms (see
577e.g. most of the files in the F<hints/> directory in the source code kit).
578On most of these systems, the value of C<$^O> (hence C<$Config{'osname'}>,
579too) is determined either by lowercasing and stripping punctuation from the
580first field of the string returned by typing C<uname -a> (or a similar command)
581at the shell prompt or by testing the file system for the presence of
582uniquely named files such as a kernel or header file.  Here, for example,
583are a few of the more popular Unix flavors:
584
585    uname         $^O        $Config{'archname'}
586    --------------------------------------------
587    AIX           aix        aix
588    BSD/OS        bsdos      i386-bsdos
589    dgux          dgux       AViiON-dgux
590    DYNIX/ptx     dynixptx   i386-dynixptx
591    FreeBSD       freebsd    freebsd-i386   
592    Linux         linux      arm-linux
593    Linux         linux      i386-linux
594    Linux         linux      i586-linux
595    Linux         linux      ppc-linux
596    HP-UX         hpux       PA-RISC1.1
597    IRIX          irix       irix
598    Mac OS X      rhapsody   rhapsody
599    MachTen PPC   machten    powerpc-machten
600    NeXT 3        next       next-fat
601    NeXT 4        next       OPENSTEP-Mach
602    openbsd       openbsd    i386-openbsd
603    OSF1          dec_osf    alpha-dec_osf
604    reliantunix-n svr4       RM400-svr4
605    SCO_SV        sco_sv     i386-sco_sv
606    SINIX-N       svr4       RM400-svr4
607    sn4609        unicos     CRAY_C90-unicos
608    sn6521        unicosmk   t3e-unicosmk
609    sn9617        unicos     CRAY_J90-unicos
610    SunOS         solaris    sun4-solaris
611    SunOS         solaris    i86pc-solaris
612    SunOS4        sunos      sun4-sunos
613
614Because the value of C<$Config{archname}> may depend on the
615hardware architecture, it can vary more than the value of C<$^O>.
616
617=head2 DOS and Derivatives
618
619Perl has long been ported to Intel-style microcomputers running under
620systems like PC-DOS, MS-DOS, OS/2, and most Windows platforms you can
621bring yourself to mention (except for Windows CE, if you count that).
622Users familiar with I<COMMAND.COM> or I<CMD.EXE> style shells should
623be aware that each of these file specifications may have subtle
624differences:
625
626    $filespec0 = "c:/foo/bar/file.txt";
627    $filespec1 = "c:\\foo\\bar\\file.txt";
628    $filespec2 = 'c:\foo\bar\file.txt';
629    $filespec3 = 'c:\\foo\\bar\\file.txt';
630
631System calls accept either C</> or C<\> as the path separator.
632However, many command-line utilities of DOS vintage treat C</> as
633the option prefix, so may get confused by filenames containing C</>.
634Aside from calling any external programs, C</> will work just fine,
635and probably better, as it is more consistent with popular usage,
636and avoids the problem of remembering what to backwhack and what
637not to.
638
639The DOS FAT filesystem can accommodate only "8.3" style filenames.  Under
640the "case-insensitive, but case-preserving" HPFS (OS/2) and NTFS (NT)
641filesystems you may have to be careful about case returned with functions
642like C<readdir> or used with functions like C<open> or C<opendir>.
643
644DOS also treats several filenames as special, such as AUX, PRN,
645NUL, CON, COM1, LPT1, LPT2, etc.  Unfortunately, sometimes these
646filenames won't even work if you include an explicit directory
647prefix.  It is best to avoid such filenames, if you want your code
648to be portable to DOS and its derivatives.  It's hard to know what
649these all are, unfortunately.
650
651Users of these operating systems may also wish to make use of
652scripts such as I<pl2bat.bat> or I<pl2cmd> to
653put wrappers around your scripts.
654
655Newline (C<\n>) is translated as C<\015\012> by STDIO when reading from
656and writing to files (see L<"Newlines">).  C<binmode(FILEHANDLE)>
657will keep C<\n> translated as C<\012> for that filehandle.  Since it is a
658no-op on other systems, C<binmode> should be used for cross-platform code
659that deals with binary data.  That's assuming you realize in advance
660that your data is in binary.  General-purpose programs should
661often assume nothing about their data.
662
663The C<$^O> variable and the C<$Config{archname}> values for various
664DOSish perls are as follows:
665
666    OS            $^O        $Config{'archname'}
667    --------------------------------------------
668    MS-DOS        dos
669    PC-DOS        dos
670    OS/2          os2
671    Windows 95    MSWin32    MSWin32-x86
672    Windows 98    MSWin32    MSWin32-x86
673    Windows NT    MSWin32    MSWin32-x86
674    Windows NT    MSWin32    MSWin32-ALPHA
675    Windows NT    MSWin32    MSWin32-ppc
676    Cygwin        cygwin
677
678The various MSWin32 Perl's can distinguish the OS they are running on
679via the value of the fifth element of the list returned from
680Win32::GetOSVersion().  For example:
681
682    if ($^O eq 'MSWin32') {
683        my @os_version_info = Win32::GetOSVersion();
684        print +('3.1','95','NT')[$os_version_info[4]],"\n";
685    }
686
687Also see:
688
689=over 4
690
691=item *
692
693The djgpp environment for DOS, http://www.delorie.com/djgpp/
694and L<perldos>.
695
696=item *
697
698The EMX environment for DOS, OS/2, etc. emx@iaehv.nl,
699http://www.leo.org/pub/comp/os/os2/leo/gnu/emx+gcc/index.html or
700ftp://hobbes.nmsu.edu/pub/os2/dev/emx.  Also L<perlos2>.
701
702=item *
703
704Build instructions for Win32 in L<perlwin32>, or under the Cygnus environment
705in L<perlcygwin>. 
706
707=item *
708
709The C<Win32::*> modules in L<Win32>.
710
711=item *
712
713The ActiveState Pages, http://www.activestate.com/
714
715=item *
716
717The Cygwin environment for Win32; F<README.cygwin> (installed
718as L<perlcygwin>), http://www.cygwin.com/
719
720=item *
721
722The U/WIN environment for Win32,
723http://www.research.att.com/sw/tools/uwin/
724
725=item *
726
727Build instructions for OS/2, L<perlos2>
728
729=back
730
731=head2 S<Mac OS>
732
733Any module requiring XS compilation is right out for most people, because
734MacPerl is built using non-free (and non-cheap!) compilers.  Some XS
735modules that can work with MacPerl are built and distributed in binary
736form on CPAN.
737
738Directories are specified as:
739
740    volume:folder:file              for absolute pathnames
741    volume:folder:                  for absolute pathnames
742    :folder:file                    for relative pathnames
743    :folder:                        for relative pathnames
744    :file                           for relative pathnames
745    file                            for relative pathnames
746
747Files are stored in the directory in alphabetical order.  Filenames are
748limited to 31 characters, and may include any character except for
749null and C<:>, which is reserved as the path separator.
750
751Instead of C<flock>, see C<FSpSetFLock> and C<FSpRstFLock> in the
752Mac::Files module, or C<chmod(0444, ...)> and C<chmod(0666, ...)>.
753
754In the MacPerl application, you can't run a program from the command line;
755programs that expect C<@ARGV> to be populated can be edited with something
756like the following, which brings up a dialog box asking for the command
757line arguments.
758
759    if (!@ARGV) {
760        @ARGV = split /\s+/, MacPerl::Ask('Arguments?');
761    }
762
763A MacPerl script saved as a "droplet" will populate C<@ARGV> with the full
764pathnames of the files dropped onto the script.
765
766Mac users can run programs under a type of command line interface
767under MPW (Macintosh Programmer's Workshop, a free development
768environment from Apple).  MacPerl was first introduced as an MPW
769tool, and MPW can be used like a shell:
770
771    perl myscript.plx some arguments
772
773ToolServer is another app from Apple that provides access to MPW tools
774from MPW and the MacPerl app, which allows MacPerl programs to use
775C<system>, backticks, and piped C<open>.
776
777"S<Mac OS>" is the proper name for the operating system, but the value
778in C<$^O> is "MacOS".  To determine architecture, version, or whether
779the application or MPW tool version is running, check:
780
781    $is_app    = $MacPerl::Version =~ /App/;
782    $is_tool   = $MacPerl::Version =~ /MPW/;
783    ($version) = $MacPerl::Version =~ /^(\S+)/;
784    $is_ppc    = $MacPerl::Architecture eq 'MacPPC';
785    $is_68k    = $MacPerl::Architecture eq 'Mac68K';
786
787S<Mac OS X> and S<Mac OS X Server>, based on NeXT's OpenStep OS, will
788(in theory) be able to run MacPerl natively, under the "Classic"
789environment.  The new "Cocoa" environment (formerly called the "Yellow Box")
790may run a slightly modified version of MacPerl, using the Carbon interfaces.
791
792S<Mac OS X Server> and its Open Source version, Darwin, both run Unix
793perl natively (with a few patches).  Full support for these
794is slated for perl 5.6.
795
796Also see:
797
798=over 4
799
800=item *
801
802The MacPerl Pages, http://www.macperl.com/ .
803
804=item *
805
806The MacPerl mailing lists, http://www.macperl.org/ .
807
808=item *
809
810MacPerl Module Porters, http://pudge.net/mmp/ .
811
812=back
813
814=head2 VMS
815
816Perl on VMS is discussed in L<perlvms> in the perl distribution.
817Perl on VMS can accept either VMS- or Unix-style file
818specifications as in either of the following:
819
820    $ perl -ne "print if /perl_setup/i" SYS$LOGIN:LOGIN.COM
821    $ perl -ne "print if /perl_setup/i" /sys$login/login.com
822
823but not a mixture of both as in:
824
825    $ perl -ne "print if /perl_setup/i" sys$login:/login.com
826    Can't open sys$login:/login.com: file specification syntax error
827
828Interacting with Perl from the Digital Command Language (DCL) shell
829often requires a different set of quotation marks than Unix shells do.
830For example:
831
832    $ perl -e "print ""Hello, world.\n"""
833    Hello, world.
834
835There are several ways to wrap your perl scripts in DCL F<.COM> files, if
836you are so inclined.  For example:
837
838    $ write sys$output "Hello from DCL!"
839    $ if p1 .eqs. ""
840    $ then perl -x 'f$environment("PROCEDURE")
841    $ else perl -x - 'p1 'p2 'p3 'p4 'p5 'p6 'p7 'p8
842    $ deck/dollars="__END__"
843    #!/usr/bin/perl
844
845    print "Hello from Perl!\n";
846
847    __END__
848    $ endif
849
850Do take care with C<$ ASSIGN/nolog/user SYS$COMMAND: SYS$INPUT> if your
851perl-in-DCL script expects to do things like C<< $read = <STDIN>; >>.
852
853Filenames are in the format "name.extension;version".  The maximum
854length for filenames is 39 characters, and the maximum length for
855extensions is also 39 characters.  Version is a number from 1 to
85632767.  Valid characters are C</[A-Z0-9$_-]/>.
857
858VMS's RMS filesystem is case-insensitive and does not preserve case.
859C<readdir> returns lowercased filenames, but specifying a file for
860opening remains case-insensitive.  Files without extensions have a
861trailing period on them, so doing a C<readdir> with a file named F<A.;5>
862will return F<a.> (though that file could be opened with
863C<open(FH, 'A')>).
864
865RMS had an eight level limit on directory depths from any rooted logical
866(allowing 16 levels overall) prior to VMS 7.2.  Hence
867C<PERL_ROOT:[LIB.2.3.4.5.6.7.8]> is a valid directory specification but
868C<PERL_ROOT:[LIB.2.3.4.5.6.7.8.9]> is not.  F<Makefile.PL> authors might
869have to take this into account, but at least they can refer to the former
870as C</PERL_ROOT/lib/2/3/4/5/6/7/8/>.
871
872The VMS::Filespec module, which gets installed as part of the build
873process on VMS, is a pure Perl module that can easily be installed on
874non-VMS platforms and can be helpful for conversions to and from RMS
875native formats.
876
877What C<\n> represents depends on the type of file opened.  It could
878be C<\015>, C<\012>, C<\015\012>, or nothing.  The VMS::Stdio module
879provides access to the special fopen() requirements of files with unusual
880attributes on VMS.
881
882TCP/IP stacks are optional on VMS, so socket routines might not be
883implemented.  UDP sockets may not be supported.
884
885The value of C<$^O> on OpenVMS is "VMS".  To determine the architecture
886that you are running on without resorting to loading all of C<%Config>
887you can examine the content of the C<@INC> array like so:
888
889    if (grep(/VMS_AXP/, @INC)) {
890        print "I'm on Alpha!\n";
891
892    } elsif (grep(/VMS_VAX/, @INC)) {
893        print "I'm on VAX!\n";
894
895    } else {
896        print "I'm not so sure about where $^O is...\n";
897    }
898
899On VMS, perl determines the UTC offset from the C<SYS$TIMEZONE_DIFFERENTIAL>
900logical name.  Although the VMS epoch began at 17-NOV-1858 00:00:00.00,
901calls to C<localtime> are adjusted to count offsets from
90201-JAN-1970 00:00:00.00, just like Unix.
903
904Also see:
905
906=over 4
907
908=item *
909
910F<README.vms> (installed as L<README_vms>), L<perlvms>
911
912=item *
913
914vmsperl list, majordomo@perl.org
915
916(Put the words C<subscribe vmsperl> in message body.)
917
918=item *
919
920vmsperl on the web, http://www.sidhe.org/vmsperl/index.html
921
922=back
923
924=head2 VOS
925
926Perl on VOS is discussed in F<README.vos> in the perl distribution
927(installed as L<perlvos>).  Perl on VOS can accept either VOS- or
928Unix-style file specifications as in either of the following:
929
930    $ perl -ne "print if /perl_setup/i" >system>notices
931    $ perl -ne "print if /perl_setup/i" /system/notices
932
933or even a mixture of both as in:
934
935    $ perl -ne "print if /perl_setup/i" >system/notices
936
937Even though VOS allows the slash character to appear in object
938names, because the VOS port of Perl interprets it as a pathname
939delimiting character, VOS files, directories, or links whose names
940contain a slash character cannot be processed.  Such files must be
941renamed before they can be processed by Perl.  Note that VOS limits
942file names to 32 or fewer characters.
943
944See F<README.vos> for restrictions that apply when Perl is built
945with the alpha version of VOS POSIX.1 support.
946
947Perl on VOS is built without any extensions and does not support
948dynamic loading.
949
950The value of C<$^O> on VOS is "VOS".  To determine the architecture that
951you are running on without resorting to loading all of C<%Config> you
952can examine the content of the @INC array like so:
953
954    if ($^O =~ /VOS/) {
955        print "I'm on a Stratus box!\n";
956    } else {
957        print "I'm not on a Stratus box!\n";
958        die;
959    }
960
961    if (grep(/860/, @INC)) {
962        print "This box is a Stratus XA/R!\n";
963
964    } elsif (grep(/7100/, @INC)) {
965        print "This box is a Stratus HP 7100 or 8xxx!\n";
966
967    } elsif (grep(/8000/, @INC)) {
968        print "This box is a Stratus HP 8xxx!\n";
969
970    } else {
971        print "This box is a Stratus 68K!\n";
972    }
973
974Also see:
975
976=over 4
977
978=item *
979
980F<README.vos>
981
982=item *
983
984The VOS mailing list.
985
986There is no specific mailing list for Perl on VOS.  You can post
987comments to the comp.sys.stratus newsgroup, or subscribe to the general
988Stratus mailing list.  Send a letter with "Subscribe Info-Stratus" in
989the message body to majordomo@list.stratagy.com.
990
991=item *
992
993VOS Perl on the web at http://ftp.stratus.com/pub/vos/vos.html
994
995=back
996
997=head2 EBCDIC Platforms
998
999Recent versions of Perl have been ported to platforms such as OS/400 on
1000AS/400 minicomputers as well as OS/390, VM/ESA, and BS2000 for S/390
1001Mainframes.  Such computers use EBCDIC character sets internally (usually
1002Character Code Set ID 0037 for OS/400 and either 1047 or POSIX-BC for S/390
1003systems).  On the mainframe perl currently works under the "Unix system
1004services for OS/390" (formerly known as OpenEdition), VM/ESA OpenEdition, or
1005the BS200 POSIX-BC system (BS2000 is supported in perl 5.6 and greater).
1006See L<perlos390> for details. 
1007
1008As of R2.5 of USS for OS/390 and Version 2.3 of VM/ESA these Unix
1009sub-systems do not support the C<#!> shebang trick for script invocation.
1010Hence, on OS/390 and VM/ESA perl scripts can be executed with a header
1011similar to the following simple script:
1012
1013    : # use perl
1014        eval 'exec /usr/local/bin/perl -S $0 ${1+"$@"}'
1015            if 0;
1016    #!/usr/local/bin/perl     # just a comment really
1017
1018    print "Hello from perl!\n";
1019
1020OS/390 will support the C<#!> shebang trick in release 2.8 and beyond.
1021Calls to C<system> and backticks can use POSIX shell syntax on all
1022S/390 systems.
1023
1024On the AS/400, if PERL5 is in your library list, you may need
1025to wrap your perl scripts in a CL procedure to invoke them like so:
1026
1027    BEGIN
1028      CALL PGM(PERL5/PERL) PARM('/QOpenSys/hello.pl')
1029    ENDPGM
1030
1031This will invoke the perl script F<hello.pl> in the root of the
1032QOpenSys file system.  On the AS/400 calls to C<system> or backticks
1033must use CL syntax.
1034
1035On these platforms, bear in mind that the EBCDIC character set may have
1036an effect on what happens with some perl functions (such as C<chr>,
1037C<pack>, C<print>, C<printf>, C<ord>, C<sort>, C<sprintf>, C<unpack>), as
1038well as bit-fiddling with ASCII constants using operators like C<^>, C<&>
1039and C<|>, not to mention dealing with socket interfaces to ASCII computers
1040(see L<"Newlines">).
1041
1042Fortunately, most web servers for the mainframe will correctly
1043translate the C<\n> in the following statement to its ASCII equivalent
1044(C<\r> is the same under both Unix and OS/390 & VM/ESA):
1045
1046    print "Content-type: text/html\r\n\r\n";
1047
1048The values of C<$^O> on some of these platforms includes:
1049
1050    uname         $^O        $Config{'archname'}
1051    --------------------------------------------
1052    OS/390        os390      os390
1053    OS400         os400      os400
1054    POSIX-BC      posix-bc   BS2000-posix-bc
1055    VM/ESA        vmesa      vmesa
1056
1057Some simple tricks for determining if you are running on an EBCDIC
1058platform could include any of the following (perhaps all):
1059
1060    if ("\t" eq "\05")   { print "EBCDIC may be spoken here!\n"; }
1061
1062    if (ord('A') == 193) { print "EBCDIC may be spoken here!\n"; }
1063
1064    if (chr(169) eq 'z') { print "EBCDIC may be spoken here!\n"; }
1065
1066One thing you may not want to rely on is the EBCDIC encoding
1067of punctuation characters since these may differ from code page to code
1068page (and once your module or script is rumoured to work with EBCDIC,
1069folks will want it to work with all EBCDIC character sets).
1070
1071Also see:
1072
1073=over 4
1074
1075=item *
1076
1077*
1078
1079L<perlos390>, F<README.os390>, F<perlbs2000>, F<README.vmesa>,
1080L<perlebcdic>.
1081
1082=item *
1083
1084The perl-mvs@perl.org list is for discussion of porting issues as well as
1085general usage issues for all EBCDIC Perls.  Send a message body of
1086"subscribe perl-mvs" to majordomo@perl.org.
1087
1088=item  *
1089
1090AS/400 Perl information at
1091http://as400.rochester.ibm.com/
1092as well as on CPAN in the F<ports/> directory.
1093
1094=back
1095
1096=head2 Acorn RISC OS
1097
1098Because Acorns use ASCII with newlines (C<\n>) in text files as C<\012> like
1099Unix, and because Unix filename emulation is turned on by default,
1100most simple scripts will probably work "out of the box".  The native
1101filesystem is modular, and individual filesystems are free to be
1102case-sensitive or insensitive, and are usually case-preserving.  Some
1103native filesystems have name length limits, which file and directory
1104names are silently truncated to fit.  Scripts should be aware that the
1105standard filesystem currently has a name length limit of B<10>
1106characters, with up to 77 items in a directory, but other filesystems
1107may not impose such limitations.
1108
1109Native filenames are of the form
1110
1111    Filesystem#Special_Field::DiskName.$.Directory.Directory.File
1112
1113where
1114
1115    Special_Field is not usually present, but may contain . and $ .
1116    Filesystem =~ m|[A-Za-z0-9_]|
1117    DsicName   =~ m|[A-Za-z0-9_/]|
1118    $ represents the root directory
1119    . is the path separator
1120    @ is the current directory (per filesystem but machine global)
1121    ^ is the parent directory
1122    Directory and File =~ m|[^\0- "\.\$\%\&:\@\\^\|\177]+|
1123
1124The default filename translation is roughly C<tr|/.|./|;>
1125
1126Note that C<"ADFS::HardDisk.$.File" ne 'ADFS::HardDisk.$.File'> and that
1127the second stage of C<$> interpolation in regular expressions will fall
1128foul of the C<$.> if scripts are not careful.
1129
1130Logical paths specified by system variables containing comma-separated
1131search lists are also allowed; hence C<System:Modules> is a valid
1132filename, and the filesystem will prefix C<Modules> with each section of
1133C<System$Path> until a name is made that points to an object on disk.
1134Writing to a new file C<System:Modules> would be allowed only if
1135C<System$Path> contains a single item list.  The filesystem will also
1136expand system variables in filenames if enclosed in angle brackets, so
1137C<< <System$Dir>.Modules >> would look for the file
1138S<C<$ENV{'System$Dir'} . 'Modules'>>.  The obvious implication of this is
1139that B<fully qualified filenames can start with C<< <> >>> and should
1140be protected when C<open> is used for input.
1141
1142Because C<.> was in use as a directory separator and filenames could not
1143be assumed to be unique after 10 characters, Acorn implemented the C
1144compiler to strip the trailing C<.c> C<.h> C<.s> and C<.o> suffix from
1145filenames specified in source code and store the respective files in
1146subdirectories named after the suffix.  Hence files are translated:
1147
1148    foo.h           h.foo
1149    C:foo.h         C:h.foo        (logical path variable)
1150    sys/os.h        sys.h.os       (C compiler groks Unix-speak)
1151    10charname.c    c.10charname
1152    10charname.o    o.10charname
1153    11charname_.c   c.11charname   (assuming filesystem truncates at 10)
1154
1155The Unix emulation library's translation of filenames to native assumes
1156that this sort of translation is required, and it allows a user-defined list
1157of known suffixes that it will transpose in this fashion.  This may
1158seem transparent, but consider that with these rules C<foo/bar/baz.h>
1159and C<foo/bar/h/baz> both map to C<foo.bar.h.baz>, and that C<readdir> and
1160C<glob> cannot and do not attempt to emulate the reverse mapping.  Other
1161C<.>'s in filenames are translated to C</>.
1162
1163As implied above, the environment accessed through C<%ENV> is global, and
1164the convention is that program specific environment variables are of the
1165form C<Program$Name>.  Each filesystem maintains a current directory,
1166and the current filesystem's current directory is the B<global> current
1167directory.  Consequently, sociable programs don't change the current
1168directory but rely on full pathnames, and programs (and Makefiles) cannot
1169assume that they can spawn a child process which can change the current
1170directory without affecting its parent (and everyone else for that
1171matter).
1172
1173Because native operating system filehandles are global and are currently
1174allocated down from 255, with 0 being a reserved value, the Unix emulation
1175library emulates Unix filehandles.  Consequently, you can't rely on
1176passing C<STDIN>, C<STDOUT>, or C<STDERR> to your children.
1177
1178The desire of users to express filenames of the form
1179C<< <Foo$Dir>.Bar >> on the command line unquoted causes problems,
1180too: C<``> command output capture has to perform a guessing game.  It
1181assumes that a string C<< <[^<>]+\$[^<>]> >> is a
1182reference to an environment variable, whereas anything else involving
1183C<< < >> or C<< > >> is redirection, and generally manages to be 99%
1184right.  Of course, the problem remains that scripts cannot rely on any
1185Unix tools being available, or that any tools found have Unix-like command
1186line arguments.
1187
1188Extensions and XS are, in theory, buildable by anyone using free
1189tools.  In practice, many don't, as users of the Acorn platform are
1190used to binary distributions.  MakeMaker does run, but no available
1191make currently copes with MakeMaker's makefiles; even if and when
1192this should be fixed, the lack of a Unix-like shell will cause
1193problems with makefile rules, especially lines of the form C<cd
1194sdbm && make all>, and anything using quoting.
1195
1196"S<RISC OS>" is the proper name for the operating system, but the value
1197in C<$^O> is "riscos" (because we don't like shouting).
1198
1199=head2 Other perls
1200
1201Perl has been ported to many platforms that do not fit into any of
1202the categories listed above.  Some, such as AmigaOS, Atari MiNT,
1203BeOS, HP MPE/iX, QNX, Plan 9, and VOS, have been well-integrated
1204into the standard Perl source code kit.  You may need to see the
1205F<ports/> directory on CPAN for information, and possibly binaries,
1206for the likes of: aos, Atari ST, lynxos, riscos, Novell Netware,
1207Tandem Guardian, I<etc.>  (Yes, we know that some of these OSes may
1208fall under the Unix category, but we are not a standards body.)
1209
1210Some approximate operating system names and their C<$^O> values
1211in the "OTHER" category include:
1212
1213    OS            $^O        $Config{'archname'}
1214    ------------------------------------------
1215    Amiga DOS     amigaos    m68k-amigos
1216    MPE/iX        mpeix      PA-RISC1.1
1217
1218See also:
1219
1220=over 4
1221
1222=item *
1223
1224Amiga, F<README.amiga> (installed as L<perlamiga>).
1225
1226=item *
1227
1228Atari, F<README.mint> and Guido Flohr's web page
1229http://stud.uni-sb.de/~gufl0000/
1230
1231=item *
1232
1233Be OS, F<README.beos>
1234
1235=item *
1236
1237HP 300 MPE/iX, F<README.mpeix> and Mark Bixby's web page
1238http://www.bixby.org/mark/perlix.html
1239
1240=item *
1241
1242A free perl5-based PERL.NLM for Novell Netware is available in
1243precompiled binary and source code form from http://www.novell.com/
1244as well as from CPAN.
1245
1246=item  *
1247
1248Plan 9, F<README.plan9>
1249
1250=back
1251
1252=head1 FUNCTION IMPLEMENTATIONS
1253
1254Listed below are functions that are either completely unimplemented
1255or else have been implemented differently on various platforms.
1256Following each description will be, in parentheses, a list of
1257platforms that the description applies to.
1258
1259The list may well be incomplete, or even wrong in some places.  When
1260in doubt, consult the platform-specific README files in the Perl
1261source distribution, and any other documentation resources accompanying
1262a given port.
1263
1264Be aware, moreover, that even among Unix-ish systems there are variations.
1265
1266For many functions, you can also query C<%Config>, exported by
1267default from the Config module.  For example, to check whether the
1268platform has the C<lstat> call, check C<$Config{d_lstat}>.  See
1269L<Config> for a full description of available variables.
1270
1271=head2 Alphabetical Listing of Perl Functions
1272
1273=over 8
1274
1275=item -X FILEHANDLE
1276
1277=item -X EXPR
1278
1279=item -X
1280
1281C<-r>, C<-w>, and C<-x> have a limited meaning only; directories
1282and applications are executable, and there are no uid/gid
1283considerations.  C<-o> is not supported.  (S<Mac OS>)
1284
1285C<-r>, C<-w>, C<-x>, and C<-o> tell whether the file is accessible,
1286which may not reflect UIC-based file protections.  (VMS)
1287
1288C<-s> returns the size of the data fork, not the total size of data fork
1289plus resource fork.  (S<Mac OS>).
1290
1291C<-s> by name on an open file will return the space reserved on disk,
1292rather than the current extent.  C<-s> on an open filehandle returns the
1293current size.  (S<RISC OS>)
1294
1295C<-R>, C<-W>, C<-X>, C<-O> are indistinguishable from C<-r>, C<-w>,
1296C<-x>, C<-o>. (S<Mac OS>, Win32, VMS, S<RISC OS>)
1297
1298C<-b>, C<-c>, C<-k>, C<-g>, C<-p>, C<-u>, C<-A> are not implemented.
1299(S<Mac OS>)
1300
1301C<-g>, C<-k>, C<-l>, C<-p>, C<-u>, C<-A> are not particularly meaningful.
1302(Win32, VMS, S<RISC OS>)
1303
1304C<-d> is true if passed a device spec without an explicit directory.
1305(VMS)
1306
1307C<-T> and C<-B> are implemented, but might misclassify Mac text files
1308with foreign characters; this is the case will all platforms, but may
1309affect S<Mac OS> often.  (S<Mac OS>)
1310
1311C<-x> (or C<-X>) determine if a file ends in one of the executable
1312suffixes.  C<-S> is meaningless.  (Win32)
1313
1314C<-x> (or C<-X>) determine if a file has an executable file type.
1315(S<RISC OS>)
1316
1317=item alarm SECONDS
1318
1319=item alarm
1320
1321Not implemented. (Win32)
1322
1323=item binmode FILEHANDLE
1324
1325Meaningless.  (S<Mac OS>, S<RISC OS>)
1326
1327Reopens file and restores pointer; if function fails, underlying
1328filehandle may be closed, or pointer may be in a different position.
1329(VMS)
1330
1331The value returned by C<tell> may be affected after the call, and
1332the filehandle may be flushed. (Win32)
1333
1334=item chmod LIST
1335
1336Only limited meaning.  Disabling/enabling write permission is mapped to
1337locking/unlocking the file. (S<Mac OS>)
1338
1339Only good for changing "owner" read-write access, "group", and "other"
1340bits are meaningless. (Win32)
1341
1342Only good for changing "owner" and "other" read-write access. (S<RISC OS>)
1343
1344Access permissions are mapped onto VOS access-control list changes. (VOS)
1345
1346=item chown LIST
1347
1348Not implemented. (S<Mac OS>, Win32, Plan9, S<RISC OS>, VOS)
1349
1350Does nothing, but won't fail. (Win32)
1351
1352=item chroot FILENAME
1353
1354=item chroot
1355
1356Not implemented. (S<Mac OS>, Win32, VMS, Plan9, S<RISC OS>, VOS, VM/ESA)
1357
1358=item crypt PLAINTEXT,SALT
1359
1360May not be available if library or source was not provided when building
1361perl. (Win32)
1362
1363Not implemented. (VOS)
1364
1365=item dbmclose HASH
1366
1367Not implemented. (VMS, Plan9, VOS)
1368
1369=item dbmopen HASH,DBNAME,MODE
1370
1371Not implemented. (VMS, Plan9, VOS)
1372
1373=item dump LABEL
1374
1375Not useful. (S<Mac OS>, S<RISC OS>)
1376
1377Not implemented. (Win32)
1378
1379Invokes VMS debugger. (VMS)
1380
1381=item exec LIST
1382
1383Not implemented. (S<Mac OS>)
1384
1385Implemented via Spawn. (VM/ESA)
1386
1387Does not automatically flush output handles on some platforms.
1388(SunOS, Solaris, HP-UX)
1389
1390=item fcntl FILEHANDLE,FUNCTION,SCALAR
1391
1392Not implemented. (Win32, VMS)
1393
1394=item flock FILEHANDLE,OPERATION
1395
1396Not implemented (S<Mac OS>, VMS, S<RISC OS>, VOS).
1397
1398Available only on Windows NT (not on Windows 95). (Win32)
1399
1400=item fork
1401
1402Not implemented. (S<Mac OS>, AmigaOS, S<RISC OS>, VOS, VM/ESA)
1403
1404Emulated using multiple interpreters.  See L<perlfork>.  (Win32)
1405
1406Does not automatically flush output handles on some platforms.
1407(SunOS, Solaris, HP-UX)
1408
1409=item getlogin
1410
1411Not implemented. (S<Mac OS>, S<RISC OS>)
1412
1413=item getpgrp PID
1414
1415Not implemented. (S<Mac OS>, Win32, VMS, S<RISC OS>, VOS)
1416
1417=item getppid
1418
1419Not implemented. (S<Mac OS>, Win32, VMS, S<RISC OS>)
1420
1421=item getpriority WHICH,WHO
1422
1423Not implemented. (S<Mac OS>, Win32, VMS, S<RISC OS>, VOS, VM/ESA)
1424
1425=item getpwnam NAME
1426
1427Not implemented. (S<Mac OS>, Win32)
1428
1429Not useful. (S<RISC OS>)
1430
1431=item getgrnam NAME
1432
1433Not implemented. (S<Mac OS>, Win32, VMS, S<RISC OS>)
1434
1435=item getnetbyname NAME
1436
1437Not implemented. (S<Mac OS>, Win32, Plan9)
1438
1439=item getpwuid UID
1440
1441Not implemented. (S<Mac OS>, Win32)
1442
1443Not useful. (S<RISC OS>)
1444
1445=item getgrgid GID
1446
1447Not implemented. (S<Mac OS>, Win32, VMS, S<RISC OS>)
1448
1449=item getnetbyaddr ADDR,ADDRTYPE
1450
1451Not implemented. (S<Mac OS>, Win32, Plan9)
1452
1453=item getprotobynumber NUMBER
1454
1455Not implemented. (S<Mac OS>)
1456
1457=item getservbyport PORT,PROTO
1458
1459Not implemented. (S<Mac OS>)
1460
1461=item getpwent
1462
1463Not implemented. (S<Mac OS>, Win32, VM/ESA)
1464
1465=item getgrent
1466
1467Not implemented. (S<Mac OS>, Win32, VMS, VM/ESA)
1468
1469=item gethostent
1470
1471Not implemented. (S<Mac OS>, Win32)
1472
1473=item getnetent
1474
1475Not implemented. (S<Mac OS>, Win32, Plan9)
1476
1477=item getprotoent
1478
1479Not implemented. (S<Mac OS>, Win32, Plan9)
1480
1481=item getservent
1482
1483Not implemented. (Win32, Plan9)
1484
1485=item setpwent
1486
1487Not implemented. (S<Mac OS>, Win32, S<RISC OS>)
1488
1489=item setgrent
1490
1491Not implemented. (S<Mac OS>, Win32, VMS, S<RISC OS>)
1492
1493=item sethostent STAYOPEN
1494
1495Not implemented. (S<Mac OS>, Win32, Plan9, S<RISC OS>)
1496
1497=item setnetent STAYOPEN
1498
1499Not implemented. (S<Mac OS>, Win32, Plan9, S<RISC OS>)
1500
1501=item setprotoent STAYOPEN
1502
1503Not implemented. (S<Mac OS>, Win32, Plan9, S<RISC OS>)
1504
1505=item setservent STAYOPEN
1506
1507Not implemented. (Plan9, Win32, S<RISC OS>)
1508
1509=item endpwent
1510
1511Not implemented. (S<Mac OS>, MPE/iX, VM/ESA, Win32)
1512
1513=item endgrent
1514
1515Not implemented. (S<Mac OS>, MPE/iX, S<RISC OS>, VM/ESA, VMS, Win32)
1516
1517=item endhostent
1518
1519Not implemented. (S<Mac OS>, Win32)
1520
1521=item endnetent
1522
1523Not implemented. (S<Mac OS>, Win32, Plan9)
1524
1525=item endprotoent
1526
1527Not implemented. (S<Mac OS>, Win32, Plan9)
1528
1529=item endservent
1530
1531Not implemented. (Plan9, Win32)
1532
1533=item getsockopt SOCKET,LEVEL,OPTNAME
1534
1535Not implemented. (S<Mac OS>, Plan9)
1536
1537=item glob EXPR
1538
1539=item glob
1540
1541Globbing built-in, but only C<*> and C<?> metacharacters are supported.
1542(S<Mac OS>)
1543
1544This operator is implemented via the File::Glob extension on most
1545platforms.  See L<File::Glob> for portability information.
1546
1547=item ioctl FILEHANDLE,FUNCTION,SCALAR
1548
1549Not implemented. (VMS)
1550
1551Available only for socket handles, and it does what the ioctlsocket() call
1552in the Winsock API does. (Win32)
1553
1554Available only for socket handles. (S<RISC OS>)
1555
1556=item kill SIGNAL, LIST
1557
1558Not implemented, hence not useful for taint checking. (S<Mac OS>,
1559S<RISC OS>)
1560
1561C<kill()> doesn't have the semantics of C<raise()>, i.e. it doesn't send
1562a signal to the identified process like it does on Unix platforms.
1563Instead C<kill($sig, $pid)> terminates the process identified by $pid,
1564and makes it exit immediately with exit status $sig.  As in Unix, if
1565$sig is 0 and the specified process exists, it returns true without
1566actually terminating it. (Win32)
1567
1568=item link OLDFILE,NEWFILE
1569
1570Not implemented. (S<Mac OS>, MPE/iX, VMS, S<RISC OS>)
1571
1572Link count not updated because hard links are not quite that hard
1573(They are sort of half-way between hard and soft links). (AmigaOS)
1574
1575Hard links are implemented on Win32 (Windows NT and Windows 2000)
1576under NTFS only.
1577
1578=item lstat FILEHANDLE
1579
1580=item lstat EXPR
1581
1582=item lstat
1583
1584Not implemented. (VMS, S<RISC OS>)
1585
1586Return values (especially for device and inode) may be bogus. (Win32)
1587
1588=item msgctl ID,CMD,ARG
1589
1590=item msgget KEY,FLAGS
1591
1592=item msgsnd ID,MSG,FLAGS
1593
1594=item msgrcv ID,VAR,SIZE,TYPE,FLAGS
1595
1596Not implemented. (S<Mac OS>, Win32, VMS, Plan9, S<RISC OS>, VOS)
1597
1598=item open FILEHANDLE,EXPR
1599
1600=item open FILEHANDLE
1601
1602The C<|> variants are supported only if ToolServer is installed.
1603(S<Mac OS>)
1604
1605open to C<|-> and C<-|> are unsupported. (S<Mac OS>, Win32, S<RISC OS>)
1606
1607Opening a process does not automatically flush output handles on some
1608platforms.  (SunOS, Solaris, HP-UX)
1609
1610=item pipe READHANDLE,WRITEHANDLE
1611
1612Not implemented. (S<Mac OS>)
1613
1614Very limited functionality. (MiNT)
1615
1616=item readlink EXPR
1617
1618=item readlink
1619
1620Not implemented. (Win32, VMS, S<RISC OS>)
1621
1622=item select RBITS,WBITS,EBITS,TIMEOUT
1623
1624Only implemented on sockets. (Win32)
1625
1626Only reliable on sockets. (S<RISC OS>)
1627
1628Note that the C<socket FILEHANDLE> form is generally portable.
1629
1630=item semctl ID,SEMNUM,CMD,ARG
1631
1632=item semget KEY,NSEMS,FLAGS
1633
1634=item semop KEY,OPSTRING
1635
1636Not implemented. (S<Mac OS>, Win32, VMS, S<RISC OS>, VOS)
1637
1638=item setgrent
1639
1640Not implemented. (MPE/iX, Win32)
1641
1642=item setpgrp PID,PGRP
1643
1644Not implemented. (S<Mac OS>, Win32, VMS, S<RISC OS>, VOS)
1645
1646=item setpriority WHICH,WHO,PRIORITY
1647
1648Not implemented. (S<Mac OS>, Win32, VMS, S<RISC OS>, VOS)
1649
1650=item setpwent
1651
1652Not implemented. (MPE/iX, Win32)
1653
1654=item setsockopt SOCKET,LEVEL,OPTNAME,OPTVAL
1655
1656Not implemented. (S<Mac OS>, Plan9)
1657
1658=item shmctl ID,CMD,ARG
1659
1660=item shmget KEY,SIZE,FLAGS
1661
1662=item shmread ID,VAR,POS,SIZE
1663
1664=item shmwrite ID,STRING,POS,SIZE
1665
1666Not implemented. (S<Mac OS>, Win32, VMS, S<RISC OS>, VOS)
1667
1668=item socketpair SOCKET1,SOCKET2,DOMAIN,TYPE,PROTOCOL
1669
1670Not implemented. (S<Mac OS>, Win32, VMS, S<RISC OS>, VOS, VM/ESA)
1671
1672=item stat FILEHANDLE
1673
1674=item stat EXPR
1675
1676=item stat
1677
1678Platforms that do not have rdev, blksize, or blocks will return these
1679as '', so numeric comparison or manipulation of these fields may cause
1680'not numeric' warnings.
1681
1682mtime and atime are the same thing, and ctime is creation time instead of
1683inode change time. (S<Mac OS>)
1684
1685device and inode are not meaningful.  (Win32)
1686
1687device and inode are not necessarily reliable.  (VMS)
1688
1689mtime, atime and ctime all return the last modification time.  Device and
1690inode are not necessarily reliable.  (S<RISC OS>)
1691
1692dev, rdev, blksize, and blocks are not available.  inode is not
1693meaningful and will differ between stat calls on the same file.  (os2)
1694
1695=item symlink OLDFILE,NEWFILE
1696
1697Not implemented. (Win32, VMS, S<RISC OS>)
1698
1699=item syscall LIST
1700
1701Not implemented. (S<Mac OS>, Win32, VMS, S<RISC OS>, VOS, VM/ESA)
1702
1703=item sysopen FILEHANDLE,FILENAME,MODE,PERMS
1704
1705The traditional "0", "1", and "2" MODEs are implemented with different
1706numeric values on some systems.  The flags exported by C<Fcntl>
1707(O_RDONLY, O_WRONLY, O_RDWR) should work everywhere though.  (S<Mac
1708OS>, OS/390, VM/ESA)
1709
1710=item system LIST
1711
1712Only implemented if ToolServer is installed. (S<Mac OS>)
1713
1714As an optimization, may not call the command shell specified in
1715C<$ENV{PERL5SHELL}>.  C<system(1, @args)> spawns an external
1716process and immediately returns its process designator, without
1717waiting for it to terminate.  Return value may be used subsequently
1718in C<wait> or C<waitpid>.  Failure to spawn() a subprocess is indicated
1719by setting $? to "255 << 8".  C<$?> is set in a way compatible with
1720Unix (i.e. the exitstatus of the subprocess is obtained by "$? >> 8",
1721as described in the documentation).  (Win32)
1722
1723There is no shell to process metacharacters, and the native standard is
1724to pass a command line terminated by "\n" "\r" or "\0" to the spawned
1725program.  Redirection such as C<< > foo >> is performed (if at all) by
1726the run time library of the spawned program.  C<system> I<list> will call
1727the Unix emulation library's C<exec> emulation, which attempts to provide
1728emulation of the stdin, stdout, stderr in force in the parent, providing
1729the child program uses a compatible version of the emulation library.
1730I<scalar> will call the native command line direct and no such emulation
1731of a child Unix program will exists.  Mileage B<will> vary.  (S<RISC OS>)
1732
1733Far from being POSIX compliant.  Because there may be no underlying
1734/bin/sh tries to work around the problem by forking and execing the
1735first token in its argument string.  Handles basic redirection
1736("<" or ">") on its own behalf. (MiNT)
1737
1738Does not automatically flush output handles on some platforms.
1739(SunOS, Solaris, HP-UX)
1740
1741=item times
1742
1743Only the first entry returned is nonzero. (S<Mac OS>)
1744
1745"cumulative" times will be bogus.  On anything other than Windows NT
1746or Windows 2000, "system" time will be bogus, and "user" time is
1747actually the time returned by the clock() function in the C runtime
1748library. (Win32)
1749
1750Not useful. (S<RISC OS>)
1751
1752=item truncate FILEHANDLE,LENGTH
1753
1754=item truncate EXPR,LENGTH
1755
1756Not implemented. (VMS)
1757
1758Truncation to zero-length only. (VOS)
1759
1760If a FILEHANDLE is supplied, it must be writable and opened in append
1761mode (i.e., use C<open(FH, '>>filename')>
1762or C<sysopen(FH,...,O_APPEND|O_RDWR)>.  If a filename is supplied, it
1763should not be held open elsewhere. (Win32)
1764
1765=item umask EXPR
1766
1767=item umask
1768
1769Returns undef where unavailable, as of version 5.005.
1770
1771C<umask> works but the correct permissions are set only when the file
1772is finally closed. (AmigaOS)
1773
1774=item utime LIST
1775
1776Only the modification time is updated. (S<Mac OS>, VMS, S<RISC OS>)
1777
1778May not behave as expected.  Behavior depends on the C runtime
1779library's implementation of utime(), and the filesystem being
1780used.  The FAT filesystem typically does not support an "access
1781time" field, and it may limit timestamps to a granularity of
1782two seconds. (Win32)
1783
1784=item wait
1785
1786=item waitpid PID,FLAGS
1787
1788Not implemented. (S<Mac OS>, VOS)
1789
1790Can only be applied to process handles returned for processes spawned
1791using C<system(1, ...)> or pseudo processes created with C<fork()>. (Win32)
1792
1793Not useful. (S<RISC OS>)
1794
1795=back
1796
1797=head1 CHANGES
1798
1799=over 4
1800
1801=item v1.48, 02 February 2001
1802
1803Various updates from perl5-porters over the past year, supported
1804platforms update from Jarkko Hietaniemi.
1805
1806=item v1.47, 22 March 2000
1807
1808Various cleanups from Tom Christiansen, including migration of
1809long platform listings from L<perl>.
1810
1811=item v1.46, 12 February 2000
1812
1813Updates for VOS and MPE/iX. (Peter Prymmer)  Other small changes.
1814
1815=item v1.45, 20 December 1999
1816
1817Small changes from 5.005_63 distribution, more changes to EBCDIC info.
1818
1819=item v1.44, 19 July 1999
1820
1821A bunch of updates from Peter Prymmer for C<$^O> values,
1822endianness, File::Spec, VMS, BS2000, OS/400.
1823
1824=item v1.43, 24 May 1999
1825
1826Added a lot of cleaning up from Tom Christiansen.
1827
1828=item v1.42, 22 May 1999
1829
1830Added notes about tests, sprintf/printf, and epoch offsets.
1831
1832=item v1.41, 19 May 1999
1833
1834Lots more little changes to formatting and content.
1835
1836Added a bunch of C<$^O> and related values
1837for various platforms; fixed mail and web addresses, and added
1838and changed miscellaneous notes.  (Peter Prymmer)
1839
1840=item v1.40, 11 April 1999
1841
1842Miscellaneous changes.
1843
1844=item v1.39, 11 February 1999
1845
1846Changes from Jarkko and EMX URL fixes Michael Schwern.  Additional
1847note about newlines added.
1848
1849=item v1.38, 31 December 1998
1850
1851More changes from Jarkko.
1852
1853=item v1.37, 19 December 1998
1854
1855More minor changes.  Merge two separate version 1.35 documents.
1856
1857=item v1.36, 9 September 1998
1858
1859Updated for Stratus VOS.  Also known as version 1.35.
1860
1861=item v1.35, 13 August 1998
1862
1863Integrate more minor changes, plus addition of new sections under
1864L<"ISSUES">: L<"Numbers endianness and Width">,
1865L<"Character sets and character encoding">,
1866L<"Internationalisation">.
1867
1868=item v1.33, 06 August 1998
1869
1870Integrate more minor changes.
1871
1872=item v1.32, 05 August 1998
1873
1874Integrate more minor changes.
1875
1876=item v1.30, 03 August 1998
1877
1878Major update for RISC OS, other minor changes.
1879
1880=item v1.23, 10 July 1998
1881
1882First public release with perl5.005.
1883
1884=back
1885
1886=head1 Supported Platforms
1887
1888As of early 2001 (the Perl release 5.6.1), the following platforms are
1889able to build Perl from the standard source code distribution
1890available at http://www.perl.com/CPAN/src/index.html
1891
1892        AIX
1893        AmigaOS
1894        Darwin          (Rhapsody)
1895        DG/UX
1896        DOS DJGPP       1)
1897        DYNIX/ptx
1898        EPOC
1899        FreeBSD
1900        HP-UX
1901        IRIX
1902        Linux
1903        MachTen
1904        MacOS Classic   2)
1905        NonStop-UX
1906        ReliantUNIX     (SINIX)
1907        OpenBSD
1908        OpenVMS         (VMS)
1909        OS/2
1910        OS X
1911        QNX
1912        Solaris
1913        Tru64 UNIX      (DEC OSF/1, Digital UNIX)
1914        UNICOS
1915        UNICOS/mk
1916        VOS
1917        Win32/NT/2K     3)
1918
1919        1) in DOS mode either the DOS or OS/2 ports can be used
1920        2) Mac OS Classic (pre-X) is almost 5.6.1-ready; building from
1921           the source does work with 5.6.1, but additional MacOS specific
1922           source code is needed for a complete build.  Contact the mailing
1923           list macperl-porters@macperl.org for more information.
1924        3) compilers: Borland, Cygwin, Mingw32 EGCS/GCC, VC++
1925
1926The following platforms worked for the previous release (5.6.0),
1927but we did not manage to test these in time for the 5.6.1 release.
1928There is a very good chance that these will work fine with 5.6.1.
1929
1930        DomainOS
1931        Hurd
1932        LynxOS
1933        MinGW
1934        MPE/iX
1935        NetBSD
1936        PowerMAX
1937        SCO SV
1938        SunOS
1939        SVR4
1940        Unixware
1941        Windows 3.1
1942        Windows 95
1943        Windows 98
1944        Windows Me
1945
1946The following platform worked for the 5.005_03 major release but not
19475.6.0.  Standardization on UTF-8 as the internal string representation
1948in 5.6.0 and 5.6.1 has introduced incompatibilities in this EBCDIC
1949platform.  While Perl 5.6.1 will build on this platform some
1950regression tests may fail and the C<use utf8;> pragma typically
1951introduces text handling errors.  UTF-8 support for this platform may
1952be enabled in a future release:
1953
1954        OS/390  1)
1955
1956        1) previously known as MVS, about to become z/OS.
1957
1958Strongly related to the OS/390 platform by also being EBCDIC-based
1959mainframe platforms are the following platforms:
1960
1961        POSIX-BC        (BS2000)
1962        VM/ESA
1963
1964These are also expected to work, albeit with no UTF-8 support, under 5.6.1
1965for the same reasons as OS/390.  Contact the mailing list perl-mvs@perl.org
1966for more details.
1967
1968The following platforms have been known to build Perl from source in
1969the past (5.005_03 and earlier), but we haven't been able to verify
1970their status for the current release, either because the
1971hardware/software platforms are rare or because we don't have an
1972active champion on these platforms--or both.  They used to work,
1973though, so go ahead and try compiling them, and let perlbug@perl.org
1974of any trouble.
1975
1976        3b1
1977        A/UX
1978        BeOS
1979        BSD/OS
1980        ConvexOS
1981        CX/UX
1982        DC/OSx
1983        DDE SMES
1984        DOS EMX
1985        Dynix
1986        EP/IX
1987        ESIX
1988        FPS
1989        GENIX
1990        Greenhills
1991        ISC
1992        MachTen 68k
1993        MiNT
1994        MPC
1995        NEWS-OS
1996        NextSTEP
1997        OpenSTEP
1998        Opus
1999        Plan 9
2000        PowerUX
2001        RISC/os
2002        SCO ODT/OSR     
2003        Stellar
2004        SVR2
2005        TI1500
2006        TitanOS
2007        Ultrix
2008        Unisys Dynix
2009        Unixware
2010        UTS
2011
2012Support for the following platform is planned for a future Perl release:
2013
2014        Netware
2015
2016The following platforms have their own source code distributions and
2017binaries available via http://www.perl.com/CPAN/ports/index.html:
2018
2019                                Perl release
2020
2021        Netware                 5.003_07
2022        OS/400                  5.005_02
2023        Tandem Guardian         5.004
2024
2025The following platforms have only binaries available via
2026http://www.perl.com/CPAN/ports/index.html :
2027
2028                                Perl release
2029
2030        Acorn RISCOS            5.005_02
2031        AOS                     5.002
2032        LynxOS                  5.004_02
2033
2034Although we do suggest that you always build your own Perl from
2035the source code, both for maximal configurability and for security,
2036in case you are in a hurry you can check
2037http://www.perl.com/CPAN/ports/index.html for binary distributions.
2038
2039=head1 SEE ALSO
2040
2041L<perlaix>, L<perlamiga>, L<perlcygwin>, L<perldos>, L<perlepoc>,
2042L<perlebcdic>, L<perlhpux>, L<perlos2>, L<perlos390>, L<perlbs2000>,
2043L<perlwin32>, L<perlvms>, L<perlvos>, and L<Win32>.
2044
2045=head1 AUTHORS / CONTRIBUTORS
2046
2047Abigail <abigail@fnx.com>,
2048Charles Bailey <bailey@newman.upenn.edu>,
2049Graham Barr <gbarr@pobox.com>,
2050Tom Christiansen <tchrist@perl.com>,
2051Nicholas Clark <Nicholas.Clark@liverpool.ac.uk>,
2052Thomas Dorner <Thomas.Dorner@start.de>,
2053Andy Dougherty <doughera@lafcol.lafayette.edu>,
2054Dominic Dunlop <domo@vo.lu>,
2055Neale Ferguson <neale@mailbox.tabnsw.com.au>,
2056David J. Fiander <davidf@mks.com>,
2057Paul Green <Paul_Green@stratus.com>,
2058M.J.T. Guy <mjtg@cus.cam.ac.uk>,
2059Jarkko Hietaniemi <jhi@iki.fi>,
2060Luther Huffman <lutherh@stratcom.com>,
2061Nick Ing-Simmons <nick@ni-s.u-net.com>,
2062Andreas J. KE<ouml>nig <koenig@kulturbox.de>,
2063Markus Laker <mlaker@contax.co.uk>,
2064Andrew M. Langmead <aml@world.std.com>,
2065Larry Moore <ljmoore@freespace.net>,
2066Paul Moore <Paul.Moore@uk.origin-it.com>,
2067Chris Nandor <pudge@pobox.com>,
2068Matthias Neeracher <neeri@iis.ee.ethz.ch>,
2069Gary Ng <71564.1743@CompuServe.COM>,
2070Tom Phoenix <rootbeer@teleport.com>,
2071AndrE<eacute> Pirard <A.Pirard@ulg.ac.be>,
2072Peter Prymmer <pvhp@forte.com>,
2073Hugo van der Sanden <hv@crypt0.demon.co.uk>,
2074Gurusamy Sarathy <gsar@activestate.com>,
2075Paul J. Schinder <schinder@pobox.com>,
2076Michael G Schwern <schwern@pobox.com>,
2077Dan Sugalski <sugalskd@ous.edu>,
2078Nathan Torkington <gnat@frii.com>.
2079
2080This document is maintained by Chris Nandor
2081<pudge@pobox.com>.
2082
2083=head1 VERSION
2084
2085Version 1.47, last modified 22 March 2000
Note: See TracBrowser for help on using the repository browser.