3 perlport - Writing portable Perl
7 Perl runs on numerous operating systems. While most of them share
8 much in common, they also have their own unique features.
10 This document is meant to help you to find out what constitutes portable
11 Perl code. That way once you make a decision to write portably,
12 you know where the lines are drawn, and you can stay within them.
14 There is a tradeoff between taking full advantage of one particular
15 type of computer and taking advantage of a full range of them.
16 Naturally, as you broaden your range and become more diverse, the
17 common factors drop, and you are left with an increasingly smaller
18 area of common ground in which you can operate to accomplish a
19 particular task. Thus, when you begin attacking a problem, it is
20 important to consider under which part of the tradeoff curve you
21 want to operate. Specifically, you must decide whether it is
22 important that the task that you are coding have the full generality
23 of being portable, or whether to just get the job done right now.
24 This is the hardest choice to be made. The rest is easy, because
25 Perl provides many choices, whichever way you want to approach your
28 Looking at it another way, writing portable code is usually about
29 willfully limiting your available choices. Naturally, it takes
30 discipline and sacrifice to do that. The product of portability
31 and convenience may be a constant. You have been warned.
33 Be aware of two important points:
37 =item Not all Perl programs have to be portable
39 There is no reason you should not use Perl as a language to glue Unix
40 tools together, or to prototype a Macintosh application, or to manage the
41 Windows registry. If it makes no sense to aim for portability for one
42 reason or another in a given program, then don't bother.
44 =item Nearly all of Perl already I<is> portable
46 Don't be fooled into thinking that it is hard to create portable Perl
47 code. It isn't. Perl tries its level-best to bridge the gaps between
48 what's available on different platforms, and all the means available to
49 use those features. Thus almost all Perl code runs on any machine
50 without modification. But there are some significant issues in
51 writing portable code, and this document is entirely about those issues.
55 Here's the general rule: When you approach a task commonly done
56 using a whole range of platforms, think about writing portable
57 code. That way, you don't sacrifice much by way of the implementation
58 choices you can avail yourself of, and at the same time you can give
59 your users lots of platform choices. On the other hand, when you have to
60 take advantage of some unique feature of a particular platform, as is
61 often the case with systems programming (whether for Unix, Windows,
62 S<Mac OS>, VMS, etc.), consider writing platform-specific code.
64 When the code will run on only two or three operating systems, you
65 may need to consider only the differences of those particular systems.
66 The important thing is to decide where the code will run and to be
67 deliberate in your decision.
69 The material below is separated into three main sections: main issues of
70 portability (L<"ISSUES">, platform-specific issues (L<"PLATFORMS">, and
71 built-in perl functions that behave differently on various ports
72 (L<"FUNCTION IMPLEMENTATIONS">.
74 This information should not be considered complete; it includes possibly
75 transient information about idiosyncrasies of some of the ports, almost
76 all of which are in a state of constant evolution. Thus, this material
77 should be considered a perpetual work in progress
78 (E<lt>IMG SRC="yellow_sign.gif" ALT="Under Construction"E<gt>).
84 In most operating systems, lines in files are terminated by newlines.
85 Just what is used as a newline may vary from OS to OS. Unix
86 traditionally uses C<\012>, one type of DOSish I/O uses C<\015\012>,
87 and S<Mac OS> uses C<\015>.
89 Perl uses C<\n> to represent the "logical" newline, where what is
90 logical may depend on the platform in use. In MacPerl, C<\n> always
91 means C<\015>. In DOSish perls, C<\n> usually means C<\012>, but
92 when accessing a file in "text" mode, STDIO translates it to (or
93 from) C<\015\012>, depending on whether your reading or writing.
94 Unix does the same thing on ttys in canonical mode. C<\015\012>
95 is commonly referred to as CRLF.
97 Because of the "text" mode translation, DOSish perls have limitations
98 in using C<seek> and C<tell> on a file accessed in "text" mode.
99 Stick to C<seek>-ing to locations you got from C<tell> (and no
100 others), and you are usually free to use C<seek> and C<tell> even
101 in "text" mode. Using C<seek> or C<tell> or other file operations
102 may be non-portable. If you use C<binmode> on a file, however, you
103 can usually C<seek> and C<tell> with arbitrary values in safety.
105 A common misconception in socket programming is that C<\n> eq C<\012>
106 everywhere. When using protocols such as common Internet protocols,
107 C<\012> and C<\015> are called for specifically, and the values of
108 the logical C<\n> and C<\r> (carriage return) are not reliable.
110 print SOCKET "Hi there, client!\r\n"; # WRONG
111 print SOCKET "Hi there, client!\015\012"; # RIGHT
113 However, using C<\015\012> (or C<\cM\cJ>, or C<\x0D\x0A>) can be tedious
114 and unsightly, as well as confusing to those maintaining the code. As
115 such, the Socket module supplies the Right Thing for those who want it.
117 use Socket qw(:DEFAULT :crlf);
118 print SOCKET "Hi there, client!$CRLF" # RIGHT
120 When reading from a socket, remember that the default input record
121 separator C<$/> is C<\n>, but robust socket code will recognize as
122 either C<\012> or C<\015\012> as end of line:
128 Because both CRLF and LF end in LF, the input record separator can
129 be set to LF and any CR stripped later. Better to write:
131 use Socket qw(:DEFAULT :crlf);
132 local($/) = LF; # not needed if $/ is already \012
135 s/$CR?$LF/\n/; # not sure if socket uses LF or CRLF, OK
136 # s/\015?\012/\n/; # same thing
139 This example is preferred over the previous one--even for Unix
140 platforms--because now any C<\015>'s (C<\cM>'s) are stripped out
141 (and there was much rejoicing).
143 Similarly, functions that return text data--such as a function that
144 fetches a web page--should sometimes translate newlines before
145 returning the data, if they've not yet been translated to the local
146 newline representation. A single line of code will often suffice:
148 $data =~ s/\015?\012/\n/g;
151 Some of this may be confusing. Here's a handy reference to the ASCII CR
152 and LF characters. You can print it out and stick it in your wallet.
154 LF == \012 == \x0A == \cJ == ASCII 10
155 CR == \015 == \x0D == \cM == ASCII 13
158 ---------------------------
161 \n * | LF | CRLF | CR |
162 \r * | CR | CR | LF |
163 ---------------------------
166 The Unix column assumes that you are not accessing a serial line
167 (like a tty) in canonical mode. If you are, then CR on input becomes
168 "\n", and "\n" on output becomes CRLF.
170 These are just the most common definitions of C<\n> and C<\r> in Perl.
171 There may well be others.
173 =head2 Numbers endianness and Width
175 Different CPUs store integers and floating point numbers in different
176 orders (called I<endianness>) and widths (32-bit and 64-bit being the
177 most common today). This affects your programs when they attempt to transfer
178 numbers in binary format from one CPU architecture to another,
179 usually either "live" via network connection, or by storing the
180 numbers to secondary storage such as a disk file or tape.
182 Conflicting storage orders make utter mess out of the numbers. If a
183 little-endian host (Intel, Alpha) stores 0x12345678 (305419896 in
184 decimal), a big-endian host (Motorola, MIPS, Sparc, PA) reads it as
185 0x78563412 (2018915346 in decimal). To avoid this problem in network
186 (socket) connections use the C<pack> and C<unpack> formats C<n>
187 and C<N>, the "network" orders. These are guaranteed to be portable.
189 Differing widths can cause truncation even between platforms of equal
190 endianness. The platform of shorter width loses the upper parts of the
191 number. There is no good solution for this problem except to avoid
192 transferring or storing raw binary numbers.
194 One can circumnavigate both these problems in two ways. Either
195 transfer and store numbers always in text format, instead of raw
196 binary, or else consider using modules like Data::Dumper (included in
197 the standard distribution as of Perl 5.005) and Storable. Keeping
198 all data as text significantly simplifies matters.
200 =head2 Files and Filesystems
202 Most platforms these days structure files in a hierarchical fashion.
203 So, it is reasonably safe to assume that all platforms support the
204 notion of a "path" to uniquely identify a file on the system. How
205 that path is really written, though, differs considerably.
207 Atlhough similar, file path specifications differ between Unix,
208 Windows, S<Mac OS>, OS/2, VMS, VOS, S<RISC OS>, and probably others.
209 Unix, for example, is one of the few OSes that has the elegant idea
210 of a single root directory.
212 DOS, OS/2, VMS, VOS, and Windows can work similarly to Unix with C</>
213 as path separator, or in their own idiosyncratic ways (such as having
214 several root directories and various "unrooted" device files such NIL:
217 S<Mac OS> uses C<:> as a path separator instead of C</>.
219 The filesystem may support neither hard links (C<link>) nor
220 symbolic links (C<symlink>, C<readlink>, C<lstat>).
222 The filesystem may support neither access timestamp nor change
223 timestamp (meaning that about the only portable timestamp is the
224 modification timestamp), or one second granularity of any timestamps
225 (e.g. the FAT filesystem limits the time granularity to two seconds).
227 VOS perl can emulate Unix filenames with C</> as path separator. The
228 native pathname characters greater-than, less-than, number-sign, and
229 percent-sign are always accepted.
231 S<RISC OS> perl can emulate Unix filenames with C</> as path
232 separator, or go native and use C<.> for path separator and C<:> to
233 signal filesystems and disk names.
235 If all this is intimidating, have no (well, maybe only a little)
236 fear. There are modules that can help. The File::Spec modules
237 provide methods to do the Right Thing on whatever platform happens
238 to be running the program.
240 use File::Spec::Functions;
241 chdir(updir()); # go up one directory
242 $file = catfile(curdir(), 'temp', 'file.txt');
243 # on Unix and Win32, './temp/file.txt'
244 # on Mac OS, ':temp:file.txt'
246 File::Spec is available in the standard distribution as of version
249 In general, production code should not have file paths hardcoded.
250 Making them user-supplied or read from a configuration file is
251 better, keeping in mind that file path syntax varies on different
254 This is especially noticeable in scripts like Makefiles and test suites,
255 which often assume C</> as a path separator for subdirectories.
257 Also of use is File::Basename from the standard distribution, which
258 splits a pathname into pieces (base filename, full path to directory,
261 Even when on a single platform (if you can call Unix a single platform),
262 remember not to count on the existence or the contents of particular
263 system-specific files or directories, like F</etc/passwd>,
264 F</etc/sendmail.conf>, F</etc/resolv.conf>, or even F</tmp/>. For
265 example, F</etc/passwd> may exist but not contain the encrypted
266 passwords, because the system is using some form of enhanced security.
267 Or it may not contain all the accounts, because the system is using NIS.
268 If code does need to rely on such a file, include a description of the
269 file and its format in the code's documentation, then make it easy for
270 the user to override the default location of the file.
272 Don't assume a text file will end with a newline. They should,
275 Do not have two files of the same name with different case, like
276 F<test.pl> and F<Test.pl>, as many platforms have case-insensitive
277 filenames. Also, try not to have non-word characters (except for C<.>)
278 in the names, and keep them to the 8.3 convention, for maximum
279 portability, onerous a burden though this may appear.
281 Likewise, when using the AutoSplit module, try to keep your functions to
282 8.3 naming and case-insensitive conventions; or, at the least,
283 make it so the resulting files have a unique (case-insensitively)
286 Whitespace in filenames is tolerated on most systems, but not all.
287 Many systems (DOS, VMS) cannot have more than one C<.> in their filenames.
289 Don't assume C<E<gt>> won't be the first character of a filename.
290 Always use C<E<lt>> explicitly to open a file for reading,
291 unless you want the user to be able to specify a pipe open.
293 open(FILE, "< $existing_file") or die $!;
295 If filenames might use strange characters, it is safest to open it
296 with C<sysopen> instead of C<open>. C<open> is magic and can
297 translate characters like C<E<gt>>, C<E<lt>>, and C<|>, which may
298 be the wrong thing to do. (Sometimes, though, it's the right thing.)
300 =head2 System Interaction
302 Not all platforms provide a command line. These are usually platforms
303 that rely primarily on a Graphical User Interface (GUI) for user
304 interaction. A program requiring a command line interface might
305 not work everywhere. This is probably for the user of the program
306 to deal with, so don't stay up late worrying about it.
308 Some platforms can't delete or rename files held open by the system.
309 Remember to C<close> files when you are done with them. Don't
310 C<unlink> or C<rename> an open file. Don't C<tie> or C<open> a
311 file already tied or opened; C<untie> or C<close> it first.
313 Don't open the same file more than once at a time for writing, as some
314 operating systems put mandatory locks on such files.
316 Don't count on a specific environment variable existing in C<%ENV>.
317 Don't count on C<%ENV> entries being case-sensitive, or even
320 Don't count on signals for anything.
322 Don't count on filename globbing. Use C<opendir>, C<readdir>, and
325 Don't count on per-program environment variables, or per-program current
328 Don't count on specific values of C<$!>.
330 =head2 Interprocess Communication (IPC)
332 In general, don't directly access the system in code meant to be
333 portable. That means, no C<system>, C<exec>, C<fork>, C<pipe>,
334 C<``>, C<qx//>, C<open> with a C<|>, nor any of the other things
335 that makes being a perl hacker worth being.
337 Commands that launch external processes are generally supported on
338 most platforms (though many of them do not support any type of
339 forking). The problem with using them arises from what you invoke
340 them on. External tools are often named differently on different
341 platforms, may not be available in the same location, migth accept
342 different arguments, can behave differently, and often present their
343 results in a platform-dependent way. Thus, you should seldom depend
344 on them to produce consistent results. (Then again, if you're calling
345 I<netstat -a>, you probably don't expect it to run on both Unix and CP/M.)
347 One especially common bit of Perl code is opening a pipe to B<sendmail>:
349 open(MAIL, '|/usr/lib/sendmail -t')
350 or die "cannot fork sendmail: $!";
352 This is fine for systems programming when sendmail is known to be
353 available. But it is not fine for many non-Unix systems, and even
354 some Unix systems that may not have sendmail installed. If a portable
355 solution is needed, see the various distributions on CPAN that deal
356 with it. Mail::Mailer and Mail::Send in the MailTools distribution are
357 commonly used, and provide several mailing methods, including mail,
358 sendmail, and direct SMTP (via Net::SMTP) if a mail transfer agent is
359 not available. Mail::Sendmail is a standalone module that provides
360 simple, platform-independent mailing.
362 The Unix System V IPC (C<msg*(), sem*(), shm*()>) is not available
363 even on all Unix platforms.
365 The rule of thumb for portable code is: Do it all in portable Perl, or
366 use a module (that may internally implement it with platform-specific
367 code, but expose a common interface).
369 =head2 External Subroutines (XS)
371 XS code can usually be made to work with any platform, but dependent
372 libraries, header files, etc., might not be readily available or
373 portable, or the XS code itself might be platform-specific, just as Perl
374 code might be. If the libraries and headers are portable, then it is
375 normally reasonable to make sure the XS code is portable, too.
377 A different type of portability issue arises when writing XS code:
378 availability of a C compiler on the end-user's system. C brings
379 with it its own portability issues, and writing XS code will expose
380 you to some of those. Writing purely in Perl is an easier way to
383 =head2 Standard Modules
385 In general, the standard modules work across platforms. Notable
386 exceptions are the CPAN module (which currently makes connections to external
387 programs that may not be available), platform-specific modules (like
388 ExtUtils::MM_VMS), and DBM modules.
390 There is no one DBM module available on all platforms.
391 SDBM_File and the others are generally available on all Unix and DOSish
392 ports, but not in MacPerl, where only NBDM_File and DB_File are
395 The good news is that at least some DBM module should be available, and
396 AnyDBM_File will use whichever module it can find. Of course, then
397 the code needs to be fairly strict, dropping to the greatest common
398 factor (e.g., not exceeding 1K for each record), so that it will
399 work with any DBM module. See L<AnyDBM_File> for more details.
403 The system's notion of time of day and calendar date is controlled in
404 widely different ways. Don't assume the timezone is stored in C<$ENV{TZ}>,
405 and even if it is, don't assume that you can control the timezone through
408 Don't assume that the epoch starts at 00:00:00, January 1, 1970,
409 because that is OS- and implementation-specific. It is better to store a date
410 in an unambiguous representation. The ISO-8601 standard defines
411 "YYYY-MM-DD" as the date format. A text representation (like "1987-12-18")
412 can be easily converted into an OS-specific value using a module like
413 Date::Parse. An array of values, such as those returned by
414 C<localtime>, can be converted to an OS-specific representation using
417 When calculating specific times, such as for tests in time or date modules,
418 it may be appropriate to calculate an offset for the epoch.
421 $offset = Time::Local::timegm(0, 0, 0, 1, 0, 70);
423 The value for C<$offset> in Unix will be C<0>, but in Mac OS will be
424 some large number. C<$offset> can then be added to a Unix time value
425 to get what should be the proper value on any system.
427 =head2 Character sets and character encoding
429 Assume little about character sets. Assume nothing about
430 numerical values (C<ord>, C<chr>) of characters. Do not
431 assume that the alphabetic characters are encoded contiguously (in
432 the numeric sense). Do not assume anything about the ordering of the
433 characters. The lowercase letters may come before or after the
434 uppercase letters; the lowercase and uppercase may be interlaced so
435 that both `a' and `A' come before `b'; the accented and other
436 international characters may be interlaced so that E<auml> comes
439 =head2 Internationalisation
441 If you may assume POSIX (a rather large assumption), you may read
442 more about the POSIX locale system from L<perllocale>. The locale
443 system at least attempts to make things a little bit more portable,
444 or at least more convenient and native-friendly for non-English
445 users. The system affects character sets and encoding, and date
446 and time formatting--amongst other things.
448 =head2 System Resources
450 If your code is destined for systems with severely constrained (or
451 missing!) virtual memory systems then you want to be I<especially> mindful
452 of avoiding wasteful constructs such as:
454 # NOTE: this is no longer "bad" in perl5.005
455 for (0..10000000) {} # bad
456 for (my $x = 0; $x <= 10000000; ++$x) {} # good
458 @lines = <VERY_LARGE_FILE>; # bad
460 while (<FILE>) {$file .= $_} # sometimes bad
461 $file = join('', <FILE>); # better
463 The last two constructs may appear unintuitive to most people. The
464 first repeatedly grows a string, whereas the second allocates a
465 large chunk of memory in one go. On some systems, the second is
466 more efficient that the first.
470 Most multi-user platforms provide basic levels of security, usually
471 implemented at the filesystem level. Some, however, do
472 not--unfortunately. Thus the notion of user id, or "home" directory,
473 or even the state of being logged-in, may be unrecognizable on many
474 platforms. If you write programs that are security-conscious, it
475 is usually best to know what type of system you will be running
476 under so that you can write code explicitly for that platform (or
481 For those times when it is necessary to have platform-specific code,
482 consider keeping the platform-specific code in one place, making porting
483 to other platforms easier. Use the Config module and the special
484 variable C<$^O> to differentiate platforms, as described in
487 Be careful in the tests you supply with your module or programs.
488 Module code may be fully portable, but its tests might not be. This
489 often happens when tests spawn off other processes or call external
490 programs to aid in the testing, or when (as noted above) the tests
491 assume certain things about the filesystem and paths. Be careful
492 not to depend on a specific output style for errors, such as when
493 checking C<$!> after an system call. Some platforms expect a certain
494 output format, and perl on those platforms may have been adjusted
495 accordingly. Most specifically, don't anchor a regex when testing
500 Modules uploaded to CPAN are tested by a variety of volunteers on
501 different platforms. These CPAN testers are notified by mail of each
502 new upload, and reply to the list with PASS, FAIL, NA (not applicable to
503 this platform), or UNKNOWN (unknown), along with any relevant notations.
505 The purpose of the testing is twofold: one, to help developers fix any
506 problems in their code that crop up because of lack of testing on other
507 platforms; two, to provide users with information about whether
508 a given module works on a given platform.
512 =item Mailing list: cpan-testers@perl.org
514 =item Testing results: C<http://www.perl.org/cpan-testers/>
520 As of version 5.002, Perl is built with a C<$^O> variable that
521 indicates the operating system it was built on. This was implemented
522 to help speed up code that would otherwise have to C<use Config>
523 and use the value of C<$Config{osname}>. Of course, to get more
524 detailed information about the system, looking into C<%Config> is
525 certainly recommended.
527 C<%Config> cannot always be trusted, however, because it was built
528 at compile time. If perl was built in one place, then transferred
529 elsewhere, some values may be wrong. The values may even have been
530 edited after the fact.
534 Perl works on a bewildering variety of Unix and Unix-like platforms (see
535 e.g. most of the files in the F<hints/> directory in the source code kit).
536 On most of these systems, the value of C<$^O> (hence C<$Config{'osname'}>,
537 too) is determined by lowercasing and stripping punctuation from the first
538 field of the string returned by typing C<uname -a> (or a similar command)
539 at the shell prompt. Here, for example, are a few of the more popular
542 uname $^O $Config{'archname'}
543 --------------------------------------------
545 BSD/OS bsdos i386-bsdos
546 dgux dgux AViiON-dgux
547 DYNIX/ptx dynixptx i386-dynixptx
548 FreeBSD freebsd freebsd-i386
549 Linux linux i386-linux
550 Linux linux i586-linux
551 Linux linux ppc-linux
552 HP-UX hpux PA-RISC1.1
554 openbsd openbsd i386-openbsd
555 OSF1 dec_osf alpha-dec_osf
556 reliantunix-n svr4 RM400-svr4
557 SCO_SV sco_sv i386-sco_sv
558 SINIX-N svr4 RM400-svr4
559 sn4609 unicos CRAY_C90-unicos
560 sn6521 unicosmk t3e-unicosmk
561 sn9617 unicos CRAY_J90-unicos
562 SunOS solaris sun4-solaris
563 SunOS solaris i86pc-solaris
564 SunOS4 sunos sun4-sunos
566 Because the value of C<$Config{archname}> may depend on the
567 hardware architecture, it can vary more than the value of C<$^O>.
569 =head2 DOS and Derivatives
571 Perl has long been ported to Intel-style microcomputers running under
572 systems like PC-DOS, MS-DOS, OS/2, and most Windows platforms you can
573 bring yourself to mention (except for Windows CE, if you count that).
574 Users familiar with I<COMMAND.COM> or I<CMD.EXE> style shells should
575 be aware that each of these file specifications may have subtle
578 $filespec0 = "c:/foo/bar/file.txt";
579 $filespec1 = "c:\\foo\\bar\\file.txt";
580 $filespec2 = 'c:\foo\bar\file.txt';
581 $filespec3 = 'c:\\foo\\bar\\file.txt';
583 System calls accept either C</> or C<\> as the path separator.
584 However, many command-line utilities of DOS vintage treat C</> as
585 the option prefix, so may get confused by filenames containing C</>.
586 Aside from calling any external programs, C</> will work just fine,
587 and probably better, as it is more consistent with popular usage,
588 and avoids the problem of remembering what to backwhack and what
591 The DOS FAT filesystem can accommodate only "8.3" style filenames. Under
592 the "case-insensitive, but case-preserving" HPFS (OS/2) and NTFS (NT)
593 filesystems you may have to be careful about case returned with functions
594 like C<readdir> or used with functions like C<open> or C<opendir>.
596 DOS also treats several filenames as special, such as AUX, PRN,
597 NUL, CON, COM1, LPT1, LPT2, etc. Unfortunately, sometimes these
598 filenames won't even work if you include an explicit directory
599 prefix. It is best to avoid such filenames, if you want your code
600 to be portable to DOS and its derivatives. It's hard to know what
601 these all are, unfortunately.
603 Users of these operating systems may also wish to make use of
604 scripts such as I<pl2bat.bat> or I<pl2cmd> to
605 put wrappers around your scripts.
607 Newline (C<\n>) is translated as C<\015\012> by STDIO when reading from
608 and writing to files (see L<"Newlines">). C<binmode(FILEHANDLE)>
609 will keep C<\n> translated as C<\012> for that filehandle. Since it is a
610 no-op on other systems, C<binmode> should be used for cross-platform code
611 that deals with binary data. That's assuming you realize in advance
612 that your data is in binary. General-purpose programs should
613 often assume nothing about their data.
615 The C<$^O> variable and the C<$Config{archname}> values for various
616 DOSish perls are as follows:
618 OS $^O $Config{'archname'}
619 --------------------------------------------
623 Windows 95 MSWin32 MSWin32-x86
624 Windows 98 MSWin32 MSWin32-x86
625 Windows NT MSWin32 MSWin32-x86
626 Windows NT MSWin32 MSWin32-ALPHA
627 Windows NT MSWin32 MSWin32-ppc
633 =item The djgpp environment for DOS, C<http://www.delorie.com/djgpp/>
635 =item The EMX environment for DOS, OS/2, etc. C<emx@iaehv.nl>,
636 C<http://www.leo.org/pub/comp/os/os2/leo/gnu/emx+gcc/index.html> or
637 C<ftp://hobbes.nmsu.edu/pub/os2/dev/emx>
639 =item Build instructions for Win32, L<perlwin32>.
641 =item The ActiveState Pages, C<http://www.activestate.com/>
647 Any module requiring XS compilation is right out for most people, because
648 MacPerl is built using non-free (and non-cheap!) compilers. Some XS
649 modules that can work with MacPerl are built and distributed in binary
652 Directories are specified as:
654 volume:folder:file for absolute pathnames
655 volume:folder: for absolute pathnames
656 :folder:file for relative pathnames
657 :folder: for relative pathnames
658 :file for relative pathnames
659 file for relative pathnames
661 Files are stored in the directory in alphabetical order. Filenames are
662 limited to 31 characters, and may include any character except for
663 null and C<:>, which is reserved as the path separator.
665 Instead of C<flock>, see C<FSpSetFLock> and C<FSpRstFLock> in the
666 Mac::Files module, or C<chmod(0444, ...)> and C<chmod(0666, ...)>.
668 In the MacPerl application, you can't run a program from the command line;
669 programs that expect C<@ARGV> to be populated can be edited with something
670 like the following, which brings up a dialog box asking for the command
674 @ARGV = split /\s+/, MacPerl::Ask('Arguments?');
677 A MacPerl script saved as a "droplet" will populate C<@ARGV> with the full
678 pathnames of the files dropped onto the script.
680 Mac users can run programs under a type of command line interface
681 under MPW (Macintosh Programmer's Workshop, a free development
682 environment from Apple). MacPerl was first introduced as an MPW
683 tool, and MPW can be used like a shell:
685 perl myscript.plx some arguments
687 ToolServer is another app from Apple that provides access to MPW tools
688 from MPW and the MacPerl app, which allows MacPerl programs to use
689 C<system>, backticks, and piped C<open>.
691 "S<Mac OS>" is the proper name for the operating system, but the value
692 in C<$^O> is "MacOS". To determine architecture, version, or whether
693 the application or MPW tool version is running, check:
695 $is_app = $MacPerl::Version =~ /App/;
696 $is_tool = $MacPerl::Version =~ /MPW/;
697 ($version) = $MacPerl::Version =~ /^(\S+)/;
698 $is_ppc = $MacPerl::Architecture eq 'MacPPC';
699 $is_68k = $MacPerl::Architecture eq 'Mac68K';
701 S<Mac OS X> and S<Mac OS X Server>, based on NeXT's OpenStep OS, will
702 (in theory) be able to run MacPerl natively, under the "Classic"
703 environment. The new "Cocoa" environment (formerly called the "Yellow Box")
704 may run a slightly modified version of MacPerl, using the Carbon interfaces.
706 S<Mac OS X Server> and its Open Source version, Darwin, both run Unix
707 perl natively (with a few patches). Full support for these
708 is slated for perl5.006.
714 =item The MacPerl Pages, C<http://www.macperl.com/>.
716 =item The MacPerl mailing lists, C<http://www.macperl.org/>.
718 =item MacPerl Module Porters, C<http://pudge.net/mmp/>.
724 Perl on VMS is discussed in F<vms/perlvms.pod> in the perl distribution.
725 Perl on VMS can accept either VMS- or Unix-style file
726 specifications as in either of the following:
728 $ perl -ne "print if /perl_setup/i" SYS$LOGIN:LOGIN.COM
729 $ perl -ne "print if /perl_setup/i" /sys$login/login.com
731 but not a mixture of both as in:
733 $ perl -ne "print if /perl_setup/i" sys$login:/login.com
734 Can't open sys$login:/login.com: file specification syntax error
736 Interacting with Perl from the Digital Command Language (DCL) shell
737 often requires a different set of quotation marks than Unix shells do.
740 $ perl -e "print ""Hello, world.\n"""
743 There are several ways to wrap your perl scripts in DCL F<.COM> files, if
744 you are so inclined. For example:
746 $ write sys$output "Hello from DCL!"
748 $ then perl -x 'f$environment("PROCEDURE")
749 $ else perl -x - 'p1 'p2 'p3 'p4 'p5 'p6 'p7 'p8
750 $ deck/dollars="__END__"
753 print "Hello from Perl!\n";
758 Do take care with C<$ ASSIGN/nolog/user SYS$COMMAND: SYS$INPUT> if your
759 perl-in-DCL script expects to do things like C<$read = E<lt>STDINE<gt>;>.
761 Filenames are in the format "name.extension;version". The maximum
762 length for filenames is 39 characters, and the maximum length for
763 extensions is also 39 characters. Version is a number from 1 to
764 32767. Valid characters are C</[A-Z0-9$_-]/>.
766 VMS's RMS filesystem is case-insensitive and does not preserve case.
767 C<readdir> returns lowercased filenames, but specifying a file for
768 opening remains case-insensitive. Files without extensions have a
769 trailing period on them, so doing a C<readdir> with a file named F<A.;5>
770 will return F<a.> (though that file could be opened with
773 RMS had an eight level limit on directory depths from any rooted logical
774 (allowing 16 levels overall) prior to VMS 7.2. Hence
775 C<PERL_ROOT:[LIB.2.3.4.5.6.7.8]> is a valid directory specification but
776 C<PERL_ROOT:[LIB.2.3.4.5.6.7.8.9]> is not. F<Makefile.PL> authors might
777 have to take this into account, but at least they can refer to the former
778 as C</PERL_ROOT/lib/2/3/4/5/6/7/8/>.
780 The VMS::Filespec module, which gets installed as part of the build
781 process on VMS, is a pure Perl module that can easily be installed on
782 non-VMS platforms and can be helpful for conversions to and from RMS
785 What C<\n> represents depends on the type of file opened. It could
786 be C<\015>, C<\012>, C<\015\012>, or nothing. Reading from a file
787 translates newlines to C<\012>, unless C<binmode> was executed on that
788 handle, just like DOSish perls.
790 TCP/IP stacks are optional on VMS, so socket routines might not be
791 implemented. UDP sockets may not be supported.
793 The value of C<$^O> on OpenVMS is "VMS". To determine the architecture
794 that you are running on without resorting to loading all of C<%Config>
795 you can examine the content of the C<@INC> array like so:
797 if (grep(/VMS_AXP/, @INC)) {
798 print "I'm on Alpha!\n";
800 } elsif (grep(/VMS_VAX/, @INC)) {
801 print "I'm on VAX!\n";
804 print "I'm not so sure about where $^O is...\n";
807 On VMS, perl determines the UTC offset from the C<SYS$TIMEZONE_DIFFERENTIAL>
808 logical name. Although the VMS epoch began at 17-NOV-1858 00:00:00.00,
809 calls to C<localtime> are adjusted to count offsets from
810 01-JAN-1970 00:00:00.00, just like Unix.
818 =item vmsperl list, C<majordomo@perl.org>
820 Put the words C<subscribe vmsperl> in message body.
822 =item vmsperl on the web, C<http://www.sidhe.org/vmsperl/index.html>
828 Perl on VOS is discussed in F<README.vos> in the perl distribution.
829 Perl on VOS can accept either VOS- or Unix-style file
830 specifications as in either of the following:
832 $ perl -ne "print if /perl_setup/i" >system>notices
833 $ perl -ne "print if /perl_setup/i" /system/notices
835 or even a mixture of both as in:
837 $ perl -ne "print if /perl_setup/i" >system/notices
839 Even though VOS allows the slash character to appear in object
840 names, because the VOS port of Perl interprets it as a pathname
841 delimiting character, VOS files, directories, or links whose names
842 contain a slash character cannot be processed. Such files must be
843 renamed before they can be processed by Perl.
845 The following C functions are unimplemented on VOS, and any attempt by
846 Perl to use them will result in a fatal error message and an immediate
847 exit from Perl: dup, do_aspawn, do_spawn, fork, waitpid. Once these
848 functions become available in the VOS POSIX.1 implementation, you can
849 either recompile and rebind Perl, or you can download a newer port from
852 The value of C<$^O> on VOS is "VOS". To determine the architecture that
853 you are running on without resorting to loading all of C<%Config> you
854 can examine the content of the C<@INC> array like so:
856 if (grep(/VOS/, @INC)) {
857 print "I'm on a Stratus box!\n";
859 print "I'm not on a Stratus box!\n";
863 if (grep(/860/, @INC)) {
864 print "This box is a Stratus XA/R!\n";
866 } elsif (grep(/7100/, @INC)) {
867 print "This box is a Stratus HP 7100 or 8000!\n";
869 } elsif (grep(/8000/, @INC)) {
870 print "This box is a Stratus HP 8000!\n";
873 print "This box is a Stratus 68K...\n";
882 =item VOS mailing list
884 There is no specific mailing list for Perl on VOS. You can post
885 comments to the comp.sys.stratus newsgroup, or subscribe to the general
886 Stratus mailing list. Send a letter with "Subscribe Info-Stratus" in
887 the message body to majordomo@list.stratagy.com.
889 =item VOS Perl on the web at C<http://ftp.stratus.com/pub/vos/vos.html>
893 =head2 EBCDIC Platforms
895 Recent versions of Perl have been ported to platforms such as OS/400 on
896 AS/400 minicomputers as well as OS/390 & VM/ESA for IBM Mainframes. Such
897 computers use EBCDIC character sets internally (usually Character Code
898 Set ID 00819 for OS/400 and IBM-1047 for OS/390 & VM/ESA). On
899 the mainframe perl currently works under the "Unix system services
900 for OS/390" (formerly known as OpenEdition) and VM/ESA OpenEdition.
902 As of R2.5 of USS for OS/390 and Version 2.3 of VM/ESA these Unix
903 sub-systems do not support the C<#!> shebang trick for script invocation.
904 Hence, on OS/390 and VM/ESA perl scripts can be executed with a header
905 similar to the following simple script:
908 eval 'exec /usr/local/bin/perl -S $0 ${1+"$@"}'
910 #!/usr/local/bin/perl # just a comment really
912 print "Hello from perl!\n";
914 On the AS/400, if PERL5 is in your library list, you may need
915 to wrap your perl scripts in a CL procedure to invoke them like so:
918 CALL PGM(PERL5/PERL) PARM('/QOpenSys/hello.pl')
921 This will invoke the perl script F<hello.pl> in the root of the
922 QOpenSys file system. On the AS/400 calls to C<system> or backticks
925 On these platforms, bear in mind that the EBCDIC character set may have
926 an effect on what happens with some perl functions (such as C<chr>,
927 C<pack>, C<print>, C<printf>, C<ord>, C<sort>, C<sprintf>, C<unpack>), as
928 well as bit-fiddling with ASCII constants using operators like C<^>, C<&>
929 and C<|>, not to mention dealing with socket interfaces to ASCII computers
932 Fortunately, most web servers for the mainframe will correctly
933 translate the C<\n> in the following statement to its ASCII equivalent
934 (C<\r> is the same under both Unix and OS/390 & VM/ESA):
936 print "Content-type: text/html\r\n\r\n";
938 The value of C<$^O> on OS/390 is "os390".
940 The value of C<$^O> on VM/ESA is "vmesa".
942 Some simple tricks for determining if you are running on an EBCDIC
943 platform could include any of the following (perhaps all):
945 if ("\t" eq "\05") { print "EBCDIC may be spoken here!\n"; }
947 if (ord('A') == 193) { print "EBCDIC may be spoken here!\n"; }
949 if (chr(169) eq 'z') { print "EBCDIC may be spoken here!\n"; }
951 One thing you may not want to rely on is the EBCDIC encoding
952 of punctuation characters since these may differ from code page to code
953 page (and once your module or script is rumoured to work with EBCDIC,
954 folks will want it to work with all EBCDIC character sets).
962 The perl-mvs@perl.org list is for discussion of porting issues as well as
963 general usage issues for all EBCDIC Perls. Send a message body of
964 "subscribe perl-mvs" to majordomo@perl.org.
966 =item AS/400 Perl information at C<http://as400.rochester.ibm.com/>
972 Because Acorns use ASCII with newlines (C<\n>) in text files as C<\012> like
973 Unix, and because Unix filename emulation is turned on by default,
974 most simple scripts will probably work "out of the box". The native
975 filesystem is modular, and individual filesystems are free to be
976 case-sensitive or insensitive, and are usually case-preserving. Some
977 native filesystems have name length limits, which file and directory
978 names are silently truncated to fit. Scripts should be aware that the
979 standard filesystem currently has a name length limit of B<10>
980 characters, with up to 77 items in a directory, but other filesystems
981 may not impose such limitations.
983 Native filenames are of the form
985 Filesystem#Special_Field::DiskName.$.Directory.Directory.File
989 Special_Field is not usually present, but may contain . and $ .
990 Filesystem =~ m|[A-Za-z0-9_]|
991 DsicName =~ m|[A-Za-z0-9_/]|
992 $ represents the root directory
993 . is the path separator
994 @ is the current directory (per filesystem but machine global)
995 ^ is the parent directory
996 Directory and File =~ m|[^\0- "\.\$\%\&:\@\\^\|\177]+|
998 The default filename translation is roughly C<tr|/.|./|;>
1000 Note that C<"ADFS::HardDisk.$.File" ne 'ADFS::HardDisk.$.File'> and that
1001 the second stage of C<$> interpolation in regular expressions will fall
1002 foul of the C<$.> if scripts are not careful.
1004 Logical paths specified by system variables containing comma-separated
1005 search lists are also allowed; hence C<System:Modules> is a valid
1006 filename, and the filesystem will prefix C<Modules> with each section of
1007 C<System$Path> until a name is made that points to an object on disk.
1008 Writing to a new file C<System:Modules> would be allowed only if
1009 C<System$Path> contains a single item list. The filesystem will also
1010 expand system variables in filenames if enclosed in angle brackets, so
1011 C<E<lt>System$DirE<gt>.Modules> would look for the file
1012 S<C<$ENV{'System$Dir'} . 'Modules'>>. The obvious implication of this is
1013 that B<fully qualified filenames can start with C<E<lt>E<gt>>> and should
1014 be protected when C<open> is used for input.
1016 Because C<.> was in use as a directory separator and filenames could not
1017 be assumed to be unique after 10 characters, Acorn implemented the C
1018 compiler to strip the trailing C<.c> C<.h> C<.s> and C<.o> suffix from
1019 filenames specified in source code and store the respective files in
1020 subdirectories named after the suffix. Hence files are translated:
1023 C:foo.h C:h.foo (logical path variable)
1024 sys/os.h sys.h.os (C compiler groks Unix-speak)
1025 10charname.c c.10charname
1026 10charname.o o.10charname
1027 11charname_.c c.11charname (assuming filesystem truncates at 10)
1029 The Unix emulation library's translation of filenames to native assumes
1030 that this sort of translation is required, and it allows a user-defined list
1031 of known suffixes that it will transpose in this fashion. This may
1032 seem transparent, but consider that with these rules C<foo/bar/baz.h>
1033 and C<foo/bar/h/baz> both map to C<foo.bar.h.baz>, and that C<readdir> and
1034 C<glob> cannot and do not attempt to emulate the reverse mapping. Other
1035 C<.>'s in filenames are translated to C</>.
1037 As implied above, the environment accessed through C<%ENV> is global, and
1038 the convention is that program specific environment variables are of the
1039 form C<Program$Name>. Each filesystem maintains a current directory,
1040 and the current filesystem's current directory is the B<global> current
1041 directory. Consequently, sociable programs don't change the current
1042 directory but rely on full pathnames, and programs (and Makefiles) cannot
1043 assume that they can spawn a child process which can change the current
1044 directory without affecting its parent (and everyone else for that
1047 Because native operating system filehandles are global and are currently
1048 allocated down from 255, with 0 being a reserved value, the Unix emulation
1049 library emulates Unix filehandles. Consequently, you can't rely on
1050 passing C<STDIN>, C<STDOUT>, or C<STDERR> to your children.
1052 The desire of users to express filenames of the form
1053 C<E<lt>Foo$DirE<gt>.Bar> on the command line unquoted causes problems,
1054 too: C<``> command output capture has to perform a guessing game. It
1055 assumes that a string C<E<lt>[^E<lt>E<gt>]+\$[^E<lt>E<gt>]E<gt>> is a
1056 reference to an environment variable, whereas anything else involving
1057 C<E<lt>> or C<E<gt>> is redirection, and generally manages to be 99%
1058 right. Of course, the problem remains that scripts cannot rely on any
1059 Unix tools being available, or that any tools found have Unix-like command
1062 Extensions and XS are, in theory, buildable by anyone using free
1063 tools. In practice, many don't, as users of the Acorn platform are
1064 used to binary distributions. MakeMaker does run, but no available
1065 make currently copes with MakeMaker's makefiles; even if and when
1066 this should be fixed, the lack of a Unix-like shell will cause
1067 problems with makefile rules, especially lines of the form C<cd
1068 sdbm && make all>, and anything using quoting.
1070 "S<RISC OS>" is the proper name for the operating system, but the value
1071 in C<$^O> is "riscos" (because we don't like shouting).
1075 Perl has been ported to many platforms that do not fit into any of
1076 the categories listed above. Some, such as AmigaOS, Atari MiNT,
1077 BeOS, HP MPE/iX, QNX, Plan 9, and VOS, have been well-integrated
1078 into the standard Perl source code kit. You may need to see the
1079 F<ports/> directory on CPAN for information, and possibly binaries,
1080 for the likes of: aos, Atari ST, lynxos, riscos, Novell Netware,
1081 Tandem Guardian, I<etc.> (Yes, we know that some of these OSes may
1082 fall under the Unix category, but we are not a standards body.)
1088 =item Atari, Guido Flohr's page C<http://stud.uni-sb.de/~gufl0000/>
1090 =item HP 300 MPE/iX C<http://www.cccd.edu/~markb/perlix.html>
1092 =item Novell Netware
1094 A free perl5-based PERL.NLM for Novell Netware is available in
1095 precompiled binary and source code form from C<http://www.novell.com/>
1096 as well as from CPAN.
1100 =head1 FUNCTION IMPLEMENTATIONS
1102 Listed below are functions that are either completely unimplemented
1103 or else have been implemented differently on various platforms.
1104 Following each description will be, in parentheses, a list of
1105 platforms that the description applies to.
1107 The list may well be incomplete, or even wrong in some places. When
1108 in doubt, consult the platform-specific README files in the Perl
1109 source distribution, and any other documentation resources accompanying
1112 Be aware, moreover, that even among Unix-ish systems there are variations.
1114 For many functions, you can also query C<%Config>, exported by
1115 default from the Config module. For example, to check whether the
1116 platform has the C<lstat> call, check C<$Config{d_lstat}>. See
1117 L<Config> for a full description of available variables.
1119 =head2 Alphabetical Listing of Perl Functions
1129 C<-r>, C<-w>, and C<-x> have a limited meaning only; directories
1130 and applications are executable, and there are no uid/gid
1131 considerations. C<-o> is not supported. (S<Mac OS>)
1133 C<-r>, C<-w>, C<-x>, and C<-o> tell whether the file is accessible,
1134 which may not reflect UIC-based file protections. (VMS)
1136 C<-s> returns the size of the data fork, not the total size of data fork
1137 plus resource fork. (S<Mac OS>).
1139 C<-s> by name on an open file will return the space reserved on disk,
1140 rather than the current extent. C<-s> on an open filehandle returns the
1141 current size. (S<RISC OS>)
1143 C<-R>, C<-W>, C<-X>, C<-O> are indistinguishable from C<-r>, C<-w>,
1144 C<-x>, C<-o>. (S<Mac OS>, Win32, VMS, S<RISC OS>)
1146 C<-b>, C<-c>, C<-k>, C<-g>, C<-p>, C<-u>, C<-A> are not implemented.
1149 C<-g>, C<-k>, C<-l>, C<-p>, C<-u>, C<-A> are not particularly meaningful.
1150 (Win32, VMS, S<RISC OS>)
1152 C<-d> is true if passed a device spec without an explicit directory.
1155 C<-T> and C<-B> are implemented, but might misclassify Mac text files
1156 with foreign characters; this is the case will all platforms, but may
1157 affect S<Mac OS> often. (S<Mac OS>)
1159 C<-x> (or C<-X>) determine if a file ends in one of the executable
1160 suffixes. C<-S> is meaningless. (Win32)
1162 C<-x> (or C<-X>) determine if a file has an executable file type.
1165 =item binmode FILEHANDLE
1167 Meaningless. (S<Mac OS>, S<RISC OS>)
1169 Reopens file and restores pointer; if function fails, underlying
1170 filehandle may be closed, or pointer may be in a different position.
1173 The value returned by C<tell> may be affected after the call, and
1174 the filehandle may be flushed. (Win32)
1178 Only limited meaning. Disabling/enabling write permission is mapped to
1179 locking/unlocking the file. (S<Mac OS>)
1181 Only good for changing "owner" read-write access, "group", and "other"
1182 bits are meaningless. (Win32)
1184 Only good for changing "owner" and "other" read-write access. (S<RISC OS>)
1186 Access permissions are mapped onto VOS access-control list changes. (VOS)
1190 Not implemented. (S<Mac OS>, Win32, Plan9, S<RISC OS>, VOS)
1192 Does nothing, but won't fail. (Win32)
1194 =item chroot FILENAME
1198 Not implemented. (S<Mac OS>, Win32, VMS, Plan9, S<RISC OS>, VOS, VM/ESA)
1200 =item crypt PLAINTEXT,SALT
1202 May not be available if library or source was not provided when building
1205 Not implemented. (VOS)
1209 Not implemented. (VMS, Plan9, VOS)
1211 =item dbmopen HASH,DBNAME,MODE
1213 Not implemented. (VMS, Plan9, VOS)
1217 Not useful. (S<Mac OS>, S<RISC OS>)
1219 Not implemented. (Win32)
1221 Invokes VMS debugger. (VMS)
1225 Not implemented. (S<Mac OS>)
1227 Implemented via Spawn. (VM/ESA)
1229 =item fcntl FILEHANDLE,FUNCTION,SCALAR
1231 Not implemented. (Win32, VMS)
1233 =item flock FILEHANDLE,OPERATION
1235 Not implemented (S<Mac OS>, VMS, S<RISC OS>, VOS).
1237 Available only on Windows NT (not on Windows 95). (Win32)
1241 Not implemented. (S<Mac OS>, Win32, AmigaOS, S<RISC OS>, VOS, VM/ESA)
1245 Not implemented. (S<Mac OS>, S<RISC OS>)
1249 Not implemented. (S<Mac OS>, Win32, VMS, S<RISC OS>, VOS)
1253 Not implemented. (S<Mac OS>, Win32, VMS, S<RISC OS>)
1255 =item getpriority WHICH,WHO
1257 Not implemented. (S<Mac OS>, Win32, VMS, S<RISC OS>, VOS, VM/ESA)
1261 Not implemented. (S<Mac OS>, Win32)
1263 Not useful. (S<RISC OS>)
1267 Not implemented. (S<Mac OS>, Win32, VMS, S<RISC OS>)
1269 =item getnetbyname NAME
1271 Not implemented. (S<Mac OS>, Win32, Plan9)
1275 Not implemented. (S<Mac OS>, Win32)
1277 Not useful. (S<RISC OS>)
1281 Not implemented. (S<Mac OS>, Win32, VMS, S<RISC OS>)
1283 =item getnetbyaddr ADDR,ADDRTYPE
1285 Not implemented. (S<Mac OS>, Win32, Plan9)
1287 =item getprotobynumber NUMBER
1289 Not implemented. (S<Mac OS>)
1291 =item getservbyport PORT,PROTO
1293 Not implemented. (S<Mac OS>)
1297 Not implemented. (S<Mac OS>, Win32, VM/ESA)
1301 Not implemented. (S<Mac OS>, Win32, VMS, VM/ESA)
1305 Not implemented. (S<Mac OS>, Win32)
1309 Not implemented. (S<Mac OS>, Win32, Plan9)
1313 Not implemented. (S<Mac OS>, Win32, Plan9)
1317 Not implemented. (Win32, Plan9)
1321 Not implemented. (S<Mac OS>, Win32, S<RISC OS>)
1325 Not implemented. (S<Mac OS>, Win32, VMS, S<RISC OS>)
1327 =item sethostent STAYOPEN
1329 Not implemented. (S<Mac OS>, Win32, Plan9, S<RISC OS>)
1331 =item setnetent STAYOPEN
1333 Not implemented. (S<Mac OS>, Win32, Plan9, S<RISC OS>)
1335 =item setprotoent STAYOPEN
1337 Not implemented. (S<Mac OS>, Win32, Plan9, S<RISC OS>)
1339 =item setservent STAYOPEN
1341 Not implemented. (Plan9, Win32, S<RISC OS>)
1345 Not implemented. (S<Mac OS>, Win32, VM/ESA)
1349 Not implemented. (S<Mac OS>, Win32, VMS, S<RISC OS>, VM/ESA)
1353 Not implemented. (S<Mac OS>, Win32)
1357 Not implemented. (S<Mac OS>, Win32, Plan9)
1361 Not implemented. (S<Mac OS>, Win32, Plan9)
1365 Not implemented. (Plan9, Win32)
1367 =item getsockopt SOCKET,LEVEL,OPTNAME
1369 Not implemented. (S<Mac OS>, Plan9)
1375 Globbing built-in, but only C<*> and C<?> metacharacters are supported.
1378 Features depend on external perlglob.exe or perlglob.bat. May be
1379 overridden with something like File::DosGlob, which is recommended.
1382 Globbing built-in, but only C<*> and C<?> metacharacters are supported.
1383 Globbing relies on operating system calls, which may return filenames
1384 in any order. As most filesystems are case-insensitive, even "sorted"
1385 filenames will not be in case-sensitive order. (S<RISC OS>)
1387 =item ioctl FILEHANDLE,FUNCTION,SCALAR
1389 Not implemented. (VMS)
1391 Available only for socket handles, and it does what the ioctlsocket() call
1392 in the Winsock API does. (Win32)
1394 Available only for socket handles. (S<RISC OS>)
1398 Not implemented, hence not useful for taint checking. (S<Mac OS>,
1401 Available only for process handles returned by the C<system(1, ...)>
1402 method of spawning a process. (Win32)
1404 =item link OLDFILE,NEWFILE
1406 Not implemented. (S<Mac OS>, Win32, VMS, S<RISC OS>)
1408 Link count not updated because hard links are not quite that hard
1409 (They are sort of half-way between hard and soft links). (AmigaOS)
1411 =item lstat FILEHANDLE
1417 Not implemented. (VMS, S<RISC OS>)
1419 Return values may be bogus. (Win32)
1421 =item msgctl ID,CMD,ARG
1423 =item msgget KEY,FLAGS
1425 =item msgsnd ID,MSG,FLAGS
1427 =item msgrcv ID,VAR,SIZE,TYPE,FLAGS
1429 Not implemented. (S<Mac OS>, Win32, VMS, Plan9, S<RISC OS>, VOS)
1431 =item open FILEHANDLE,EXPR
1433 =item open FILEHANDLE
1435 The C<|> variants are supported only if ToolServer is installed.
1438 open to C<|-> and C<-|> are unsupported. (S<Mac OS>, Win32, S<RISC OS>)
1440 =item pipe READHANDLE,WRITEHANDLE
1442 Not implemented. (S<Mac OS>)
1444 Very limited functionality. (MiNT)
1450 Not implemented. (Win32, VMS, S<RISC OS>)
1452 =item select RBITS,WBITS,EBITS,TIMEOUT
1454 Only implemented on sockets. (Win32)
1456 Only reliable on sockets. (S<RISC OS>)
1458 =item semctl ID,SEMNUM,CMD,ARG
1460 =item semget KEY,NSEMS,FLAGS
1462 =item semop KEY,OPSTRING
1464 Not implemented. (S<Mac OS>, Win32, VMS, S<RISC OS>, VOS)
1466 =item setpgrp PID,PGRP
1468 Not implemented. (S<Mac OS>, Win32, VMS, S<RISC OS>, VOS)
1470 =item setpriority WHICH,WHO,PRIORITY
1472 Not implemented. (S<Mac OS>, Win32, VMS, S<RISC OS>, VOS)
1474 =item setsockopt SOCKET,LEVEL,OPTNAME,OPTVAL
1476 Not implemented. (S<Mac OS>, Plan9)
1478 =item shmctl ID,CMD,ARG
1480 =item shmget KEY,SIZE,FLAGS
1482 =item shmread ID,VAR,POS,SIZE
1484 =item shmwrite ID,STRING,POS,SIZE
1486 Not implemented. (S<Mac OS>, Win32, VMS, S<RISC OS>, VOS)
1488 =item socketpair SOCKET1,SOCKET2,DOMAIN,TYPE,PROTOCOL
1490 Not implemented. (S<Mac OS>, Win32, VMS, S<RISC OS>, VOS, VM/ESA)
1492 =item stat FILEHANDLE
1498 mtime and atime are the same thing, and ctime is creation time instead of
1499 inode change time. (S<Mac OS>)
1501 device and inode are not meaningful. (Win32)
1503 device and inode are not necessarily reliable. (VMS)
1505 mtime, atime and ctime all return the last modification time. Device and
1506 inode are not necessarily reliable. (S<RISC OS>)
1508 =item symlink OLDFILE,NEWFILE
1510 Not implemented. (Win32, VMS, S<RISC OS>)
1514 Not implemented. (S<Mac OS>, Win32, VMS, S<RISC OS>, VOS, VM/ESA)
1516 =item sysopen FILEHANDLE,FILENAME,MODE,PERMS
1518 The traditional "0", "1", and "2" MODEs are implemented with different
1519 numeric values on some systems. The flags exported by C<Fcntl>
1520 (O_RDONLY, O_WRONLY, O_RDWR) should work everywhere though. (S<Mac
1521 OS>, OS/390, VM/ESA)
1525 Only implemented if ToolServer is installed. (S<Mac OS>)
1527 As an optimization, may not call the command shell specified in
1528 C<$ENV{PERL5SHELL}>. C<system(1, @args)> spawns an external
1529 process and immediately returns its process designator, without
1530 waiting for it to terminate. Return value may be used subsequently
1531 in C<wait> or C<waitpid>. (Win32)
1533 There is no shell to process metacharacters, and the native standard is
1534 to pass a command line terminated by "\n" "\r" or "\0" to the spawned
1535 program. Redirection such as C<E<gt> foo> is performed (if at all) by
1536 the run time library of the spawned program. C<system> I<list> will call
1537 the Unix emulation library's C<exec> emulation, which attempts to provide
1538 emulation of the stdin, stdout, stderr in force in the parent, providing
1539 the child program uses a compatible version of the emulation library.
1540 I<scalar> will call the native command line direct and no such emulation
1541 of a child Unix program will exists. Mileage B<will> vary. (S<RISC OS>)
1543 Far from being POSIX compliant. Because there may be no underlying
1544 /bin/sh tries to work around the problem by forking and execing the
1545 first token in its argument string. Handles basic redirection
1546 ("E<lt>" or "E<gt>") on its own behalf. (MiNT)
1550 Only the first entry returned is nonzero. (S<Mac OS>)
1552 "cumulative" times will be bogus. On anything other than Windows NT,
1553 "system" time will be bogus, and "user" time is actually the time
1554 returned by the clock() function in the C runtime library. (Win32)
1556 Not useful. (S<RISC OS>)
1558 =item truncate FILEHANDLE,LENGTH
1560 =item truncate EXPR,LENGTH
1562 Not implemented. (VMS)
1564 Truncation to zero-length only. (VOS)
1566 If a FILEHANDLE is supplied, it must be writable and opened in append
1567 mode (i.e., use C<open(FH, '>>filename')>
1568 or C<sysopen(FH,...,O_APPEND|O_RDWR)>. If a filename is supplied, it
1569 should not be held open elsewhere. (Win32)
1575 Returns undef where unavailable, as of version 5.005.
1577 C<umask> works but the correct permissions are set only when the file
1578 is finally closed. (AmigaOS)
1582 Only the modification time is updated. (S<Mac OS>, VMS, S<RISC OS>)
1584 May not behave as expected. Behavior depends on the C runtime
1585 library's implementation of utime(), and the filesystem being
1586 used. The FAT filesystem typically does not support an "access
1587 time" field, and it may limit timestamps to a granularity of
1588 two seconds. (Win32)
1592 =item waitpid PID,FLAGS
1594 Not implemented. (S<Mac OS>, VOS)
1596 Can only be applied to process handles returned for processes spawned
1597 using C<system(1, ...)>. (Win32)
1599 Not useful. (S<RISC OS>)
1607 =item v1.43, 24 May 1999
1609 Added a lot of cleaning up from Tom Christiansen.
1611 =item v1.42, 22 May 1999
1613 Added notes about tests, sprintf/printf, and epoch offsets.
1615 =item v1.41, 19 May 1999
1617 Lots more little changes to formatting and content.
1619 Added a bunch of <$^O> and related values
1620 for various platforms; fixed mail and web addresses, and added
1621 and changed miscellaneous notes. (Peter Prymmer)
1623 =item v1.40, 11 April 1999
1625 Miscellaneous changes.
1627 =item v1.39, 11 February 1999
1629 Changes from Jarkko and EMX URL fixes Michael Schwern. Additional
1630 note about newlines added.
1632 =item v1.38, 31 December 1998
1634 More changes from Jarkko.
1636 =item v1.37, 19 December 1998
1638 More minor changes. Merge two separate version 1.35 documents.
1640 =item v1.36, 9 September 1998
1642 Updated for Stratus VOS. Also known as version 1.35.
1644 =item v1.35, 13 August 1998
1646 Integrate more minor changes, plus addition of new sections under
1647 L<"ISSUES">: L<"Numbers endianness and Width">,
1648 L<"Character sets and character encoding">,
1649 L<"Internationalisation">.
1651 =item v1.33, 06 August 1998
1653 Integrate more minor changes.
1655 =item v1.32, 05 August 1998
1657 Integrate more minor changes.
1659 =item v1.30, 03 August 1998
1661 Major update for RISC OS, other minor changes.
1663 =item v1.23, 10 July 1998
1665 First public release with perl5.005.
1669 =head1 AUTHORS / CONTRIBUTORS
1671 Abigail E<lt>abigail@fnx.comE<gt>,
1672 Charles Bailey E<lt>bailey@newman.upenn.eduE<gt>,
1673 Graham Barr E<lt>gbarr@pobox.comE<gt>,
1674 Tom Christiansen E<lt>tchrist@perl.comE<gt>,
1675 Nicholas Clark E<lt>Nicholas.Clark@liverpool.ac.ukE<gt>,
1676 Andy Dougherty E<lt>doughera@lafcol.lafayette.eduE<gt>,
1677 Dominic Dunlop E<lt>domo@vo.luE<gt>,
1678 Neale Ferguson E<lt>neale@mailbox.tabnsw.com.auE<gt>
1679 Paul Green E<lt>Paul_Green@stratus.comE<gt>,
1680 M.J.T. Guy E<lt>mjtg@cus.cam.ac.ukE<gt>,
1681 Jarkko Hietaniemi E<lt>jhi@iki.fi<gt>,
1682 Luther Huffman E<lt>lutherh@stratcom.comE<gt>,
1683 Nick Ing-Simmons E<lt>nick@ni-s.u-net.comE<gt>,
1684 Andreas J. KE<ouml>nig E<lt>koenig@kulturbox.deE<gt>,
1685 Markus Laker E<lt>mlaker@contax.co.ukE<gt>,
1686 Andrew M. Langmead E<lt>aml@world.std.comE<gt>,
1687 Larry Moore E<lt>ljmoore@freespace.netE<gt>,
1688 Paul Moore E<lt>Paul.Moore@uk.origin-it.comE<gt>,
1689 Chris Nandor E<lt>pudge@pobox.comE<gt>,
1690 Matthias Neeracher E<lt>neeri@iis.ee.ethz.chE<gt>,
1691 Gary Ng E<lt>71564.1743@CompuServe.COME<gt>,
1692 Tom Phoenix E<lt>rootbeer@teleport.comE<gt>,
1693 Peter Prymmer E<lt>pvhp@forte.comE<gt>,
1694 Hugo van der Sanden E<lt>hv@crypt0.demon.co.ukE<gt>,
1695 Gurusamy Sarathy E<lt>gsar@umich.eduE<gt>,
1696 Paul J. Schinder E<lt>schinder@pobox.comE<gt>,
1697 Michael G Schwern E<lt>schwern@pobox.comE<gt>,
1698 Dan Sugalski E<lt>sugalskd@ous.eduE<gt>,
1699 Nathan Torkington E<lt>gnat@frii.comE<gt>.
1701 This document is maintained by Chris Nandor
1702 E<lt>pudge@pobox.comE<gt>.
1706 Version 1.43, last modified 24 May 1999