EditPageHistoryDiffInfoLikePages

Annotated edit history of perlport(1) version 2, including all changes. View license author blame.

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