EditPageHistoryDiffInfoLikePages

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

Rev	Author	#	Line
1	perry	1	PERL5005DELTA
		2	!!!PERL5005DELTA
		3	NAME
		4	DESCRIPTION
		5	About the new versioning system
		6	Incompatible Changes
		7	Core Changes
		8	Supported Platforms
		9	Modules and Pragmata
		10	Utility Changes
		11	Documentation Changes
		12	New Diagnostics
		13	Obsolete Diagnostics
		14	Configuration Changes
		15	BUGS
		16	SEE ALSO
		17	HISTORY
		18	----
		19	!!NAME
		20
		21
		22	perldelta - what's new for perl5.005
		23	!!DESCRIPTION
		24
		25
		26	This document describes differences between the 5.004
		27	release and this one.
		28	!!About the new versioning system
		29
		30
		31	Perl is now developed on two tracks: a maintenance track
		32	that makes small, safe updates to released production
		33	versions with emphasis on compatibility; and a development
		34	track that pursues more aggressive evolution. Maintenance
		35	releases (which should be considered production quality)
		36	have subversion numbers that run from 1 to
		37	49, and development releases (which should be
		38	considered ``alpha'' quality) run from 50 to
		39	99.
		40
		41
		42	Perl 5.005 is the combined product of the new dual-track
		43	development scheme.
		44	!!Incompatible Changes
		45
		46
		47	__WARNING: This version is not binary
		48	compatible with Perl 5.004.__
		49
		50
		51	Starting with Perl 5.004_50 there were many deep and
		52	far-reaching changes to the language internals. If you have
		53	dynamically loaded extensions that you built under perl
		54	5.003 or 5.004, you can continue to use them with 5.004, but
		55	you will need to rebuild and reinstall those extensions to
		56	use them 5.005. See ''INSTALL'' for
		57	detailed instructions on how to upgrade.
		58
		59
		60	__Default installation structure has
		61	changed__
		62
		63
		64	The new Configure defaults are designed to allow a smooth
		65	upgrade from 5.004 to 5.005, but you should read
		66	''INSTALL'' for a detailed discussion of
		67	the changes in order to adapt them to your
		68	system.
		69
		70
		71	__Perl Source Compatibility__
		72
		73
		74	When none of the experimental features are enabled, there
		75	should be very few user-visible Perl source compatibility
		76	issues.
		77
		78
		79	If threads are enabled, then some caveats apply. @_
		80	and $_ become lexical variables. The effect of this
		81	should be largely transparent to the user, but there are
		82	some boundary conditions under which user will need to be
		83	aware of the issues. For example, local(@_) results
		84	in a ``Can't localize lexical variable @_ ...''
		85	message. This may be enabled in a future
		86	version.
		87
		88
		89	Some new keywords have been introduced. These are generally
		90	expected to have very little impact on compatibility. See
		91	INIT keyword
		92	lock keyword
		93	qr.
		94
		95
		96	Certain barewords are now reserved. Use of these will
		97	provoke a warning if you have asked for them with the
		98	-w switch. See our is now a reserved
		99	word
		100
		101
		102	__C Source Compatibility__
		103
		104
		105	There have been a large number of changes in the internals
		106	to support the new features in this release.
		107
		108
		109	Core sources now require ANSI C
		110	compiler
		111
		112
		113	An ANSI C compiler is now __required__ to
		114	build perl. See ''INSTALL'' .
		115
		116
		117	All Perl global variables must now be referenced with an
		118	explicit prefix
		119
		120
		121	All Perl global variables that are visible for use by
		122	extensions now have a PL_ prefix. New extensions
		123	should not refer to perl globals by their
		124	unqualified names. To preserve sanity, we provide limited
		125	backward compatibility for globals that are being widely
		126	used like sv_undef and na (which should
		127	now be written as PL_sv_undef, PL_na
		128	etc.)
		129
		130
		131	If you find that your XS extension does not
		132	compile anymore because a perl global is not visible, try
		133	adding a PL_ prefix to the global and
		134	rebuild.
		135
		136
		137	It is strongly recommended that all functions in the Perl
		138	API that don't begin with perl be
		139	referenced with a Perl_ prefix. The bare function
		140	names without the Perl_ prefix are supported with
		141	macros, but this support may cease in a future
		142	release.
		143
		144
		145	See `` API LISTING '' in
		146	perlguts.
		147
		148
		149	Enabling threads has source compatibility
		150	issues
		151
		152
		153	Perl built with threading enabled requires extensions to use
		154	the new dTHR macro to initialize the handle to
		155	access per-thread data. If you see a compiler error that
		156	talks about the variable thr not being declared
		157	(when building a module that has XS code),
		158	you need to add dTHR; at the beginning of the block
		159	that elicited the error.
		160
		161
		162	The API function
		163	perl_get_sv( should be used
		164	instead of directly accessing perl globals as
		165	GvSV(errgv). The API call is
		166	backward compatible with existing perls and provides source
		167	compatibility with threading is enabled.
		168
		169
		170	See ``C Source Compatibility'' for more
		171	information.
		172
		173
		174	__Binary Compatibility__
		175
		176
		177	This version is NOT binary compatible with
		178	older versions. All extensions will need to be recompiled.
		179	Further binaries built with threads enabled are incompatible
		180	with binaries built without. This should largely be
		181	transparent to the user, as all binary incompatible
		182	configurations have their own unique architecture name, and
		183	extension binaries get installed at unique locations. This
		184	allows coexistence of several configurations in the same
		185	directory hierarchy. See ''INSTALL''
		186	.
		187
		188
		189	__Security fixes may affect compatibility__
		190
		191
		192	A few taint leaks and taint omissions have been corrected.
		193	This may lead to ``failure'' of scripts that used to work
		194	with older versions. Compiling with -DINCOMPLETE_TAINTS
		195	provides a perl with minimal amounts of changes to the
		196	tainting behavior. But note that the resulting perl will
		197	have known insecurities.
		198
		199
		200	Oneliners with the -e switch do not create
		201	temporary files anymore.
		202
		203
		204	__Relaxed new mandatory warnings introduced in
		205	5.004__
		206
		207
		208	Many new warnings that were introduced in 5.004 have been
		209	made optional. Some of these warnings are still present, but
		210	perl's new features make them less often a problem. See
		211	``New Diagnostics''.
		212
		213
		214	__Licensing__
		215
		216
		217	Perl has a new Social Contract for contributors. See
		218	''Porting/Contract''.
		219
		220
		221	The license included in much of the Perl documentation has
		222	changed. Most of the Perl documentation was previously under
		223	the implicit GNU General Public License or
		224	the Artistic License (at the user's choice). Now much of the
		225	documentation unambiguously states the terms under which it
		226	may be distributed. Those terms are in general much less
		227	restrictive than the GNU GPL . See perl and
		228	the individual perl man pages listed therein.
		229	!!Core Changes
		230
		231
		232	__Threads__
		233
		234
		235	WARNING: Threading is considered an
		236	__experimental__ feature. Details of the implementation
		237	may change without notice. There are known limitations and
		238	some bugs. These are expected to be fixed in future
		239	versions.
		240
		241
		242	See ''README .threads''.
		243
		244
		245	__Compiler__
		246
		247
		248	WARNING: The Compiler and related tools are
		249	considered __experimental__. Features may change without
		250	notice, and there are known limitations and bugs. Since the
		251	compiler is fully external to perl, the default
		252	configuration will build and install it.
		253
		254
		255	The Compiler produces three different types of
		256	transformations of a perl program. The C backend generates C
		257	code that captures perl's state just before execution
		258	begins. It eliminates the compile-time overheads of the
		259	regular perl interpreter, but the run-time performance
		260	remains comparatively the same. The CC
		261	backend generates optimized C code equivalent to the code
		262	path at run-time. The CC backend has greater
		263	potential for big optimizations, but only a few
		264	optimizations are implemented currently. The Bytecode
		265	backend generates a platform independent bytecode
		266	representation of the interpreter's state just before
		267	execution. Thus, the Bytecode back end also eliminates much
		268	of the compilation overhead of the interpreter.
		269
		270
		271	The compiler comes with several valuable
		272	utilities.
		273
		274
		275	B::Lint is an experimental module to detect and
		276	warn about suspicious code, especially the cases that the
		277	-w switch does not detect.
		278
		279
		280	B::Deparse can be used to demystify perl code, and
		281	understand how perl optimizes certain
		282	constructs.
		283
		284
		285	B::Xref generates cross reference reports of all
		286	definition and use of variables, subroutines and formats in
		287	a program.
		288
		289
		290	B::Showlex show the lexical variables used by a
		291	subroutine or file at a glance.
		292
		293
		294	perlcc is a simple frontend for compiling
		295	perl.
		296
		297
		298	See ext/B/README, B, and the respective compiler
		299	modules.
		300
		301
		302	__Regular Expressions__
		303
		304
		305	Perl's regular expression engine has been seriously
		306	overhauled, and many new constructs are supported. Several
		307	bugs have been fixed.
		308
		309
		310	Here is an itemized summary:
		311
		312
		313	Many new and improved optimizations
		314
		315
		316	Changes in the RE engine:
		317
		318
		319	Unneeded nodes removed;
		320	Substrings merged together;
		321	New types of nodes to process (SUBEXPR)* and similar expressions
		322	quickly, used if the SUBEXPR has no side effects and matches
		323	strings of the same length;
		324	Better optimizations by lookup for constant substrings;
		325	Better search for constants substrings anchored by $ ;
		326	Changes in Perl code using RE engine:
		327
		328
		329	More optimizations to s/longer/short/;
		330	study() was not working;
		331	/blah/ may be optimized to an analogue of index() if $
		332
		333
		334	Many bug fixes
		335
		336
		337	Note that only the major bug fixes are listed here. See
		338	''Changes'' for others.
		339
		340
		341	Backtracking might not restore start of $3.
		342	No feedback if max count for * or + on
		343
		344
		345	New regular expression constructs
		346
		347
		348	The following new syntax elements are
		349	supported:
		350
		351
		352	(?
		353
		354
		355	New operator for precompiled regular
		356	expressions
		357
		358
		359	See ``/qr.
		360
		361
		362	Other improvements
		363
		364
		365	Better debugging output (possibly with colors),
		366	even from non-debugging Perl;
		367	RE engine code now looks like C, not like assembler;
		368	Behaviour of RE modifiable by `use re' directive;
		369	Improved documentation;
		370	Test suite significantly extended;
		371	Syntax [[:^upper:] etc., reserved inside character classes;
		372
		373
		374	Incompatible changes
		375
		376
		377	(?i) localized inside enclosing group;
		378	$( is not interpolated into RE any more;
		379	/RE/g may match at the same position (with non-zero length)
		380	after a zero-length match (bug fix).
		381
		382
		383	See perlre and perlop.
		384
		385
		386	__Improved__ ''malloc()''
		387
		388
		389	See banner at the beginning of malloc.c for
		390	details.
		391
		392
		393	__Quicksort is internally implemented__
		394
		395
		396	Perl now contains its own highly optimized ''qsort()''
		397	routine. The new ''qsort()'' is resistant to inconsistent
		398	comparison functions, so Perl's sort() will not
		399	provoke coredumps any more when given poorly written sort
		400	subroutines. (Some C library qsort()s that were
		401	being used before used to have this problem.) In our
		402	testing, the new qsort() required the minimal
		403	number of pair-wise compares on average, among all known
		404	qsort() implementations.
		405
		406
		407	See perlfunc/sort.
		408
		409
		410	__Reliable signals__
		411
		412
		413	Perl's signal handling is susceptible to random crashes,
		414	because signals arrive asynchronously, and the Perl runtime
		415	is not reentrant at arbitrary times.
		416
		417
		418	However, one experimental implementation of reliable signals
		419	is available when threads are enabled. See
		420	Thread::Signal. Also see
		421	''INSTALL'' for how to build a Perl
		422	capable of threads.
		423
		424
		425	__Reliable stack pointers__
		426
		427
		428	The internals now reallocate the perl stack only at
		429	predictable times. In particular, magic calls never trigger
		430	reallocations of the stack, because all reentrancy of the
		431	runtime is handled using a ``stack of stacks''. This should
		432	improve reliability of cached stack pointers in the
		433	internals and in XSUBs.
		434
		435
		436	__More generous treatment of carriage
		437	returns__
		438
		439
		440	Perl used to complain if it encountered literal carriage
		441	returns in scripts. Now they are mostly treated like
		442	whitespace within program text. Inside string literals and
		443	here documents, literal carriage returns are ignored if they
		444	occur paired with linefeeds, or get interpreted as
		445	whitespace if they stand alone. This behavior means that
		446	literal carriage returns in files should be avoided. You can
		447	get the older, more compatible (but less generous) behavior
		448	by defining the preprocessor symbol PERL_STRICT_CR
		449	when building perl. Of course, all this has nothing whatever
		450	to do with how escapes like r are handled within
		451	strings.
		452
		453
		454	Note that this doesn't somehow magically allow you to keep
		455	all text files in DOS format. The generous
		456	treatment only applies to files that perl itself parses. If
		457	your C compiler doesn't allow carriage returns in files, you
		458	may still be unable to build modules that need a C
		459	compiler.
		460
		461
		462	__Memory leaks__
		463
		464
		465	substr, pos and vec don't leak
		466	memory anymore when used in lvalue context. Many small leaks
		467	that impacted applications that embed multiple interpreters
		468	have been fixed.
		469
		470
		471	__Better support for multiple interpreters__
		472
		473
		474	The build-time option -DMULTIPLICITY has had many
		475	of the details reworked. Some previously global variables
		476	that should have been per-interpreter now are. With care,
		477	this allows interpreters to call each other. See the
2	perry	478	!PerlInterp extension on CPAN
1	perry	479	.
		480
		481
		482	__Behavior of__ ''local()'' __on array and hash
		483	elements is now well-defined__
		484
		485
		486	See ``Temporary Values via ''local()'''' in
		487	perlsub.
		488
		489
		490	%! __is transparently tied to the Errno
		491	module__
		492
		493
		494	See perlvar, and Errno.
		495
		496
		497	__Pseudo-hashes are supported__
		498
		499
		500	See perlref.
		501
		502
		503	EXPR foreach EXPR __is supported__
		504
		505
		506	See perlsyn.
		507
		508
		509	__Keywords can be globally overridden__
		510
		511
		512	See perlsub.
		513
		514
		515	$^E __is meaningful on Win32__
		516
		517
		518	See perlvar.
		519
		520
		521	foreach (1..1000000) __optimized__
		522
		523
		524	foreach (1..1000000) is now optimized into a
		525	counting loop. It does not try to allocate a 1000000-size
		526	list anymore.
		527
		528
		529	Foo:: __can be used as implicitly quoted package
		530	name__
		531
		532
		533	Barewords caused unintuitive behavior when a subroutine with
		534	the same name as a package happened to be defined. Thus,
		535	new Foo @args, use the result of the call to
		536	Foo() instead of Foo being treated as a
		537	literal. The recommended way to write barewords in the
		538	indirect object slot is new Foo:: @args. Note that
		539	the method new() is called with a first argument of
		540	Foo, not Foo:: when you do
		541	that.
		542
		543
		544	exists $Foo::{Bar::} __tests existence of a
		545	package__
		546
		547
		548	It was impossible to test for the existence of a package
		549	without actually creating it before. Now exists
		550	$Foo::{Bar::} can be used to test if the
		551	Foo::Bar namespace has been created.
		552
		553
		554	__Better locale support__
		555
		556
		557	See perllocale.
		558
		559
		560	__Experimental support for 64-bit
		561	platforms__
		562
		563
		564	Perl5 has always had 64-bit support on systems with 64-bit
		565	longs. Starting with 5.005, the beginnings of experimental
		566	support for systems with 32-bit long and 64-bit 'long long'
		567	integers has been added. If you add -DUSE_LONG_LONG to your
		568	ccflags in config.sh (or manually define it in perl.h) then
		569	perl will be built with 'long long' support. There will be
		570	many compiler warnings, and the resultant perl may not work
		571	on all systems. There are many other issues related to
		572	third-party extensions and libraries. This option exists to
		573	allow people to work on those issues.
		574
		575
		576	''prototype()'' __returns useful results on
		577	builtins__
		578
		579
		580	See ``prototype'' in perlfunc.
		581
		582
		583	__Extended support for exception handling__
		584
		585
		586	die() now accepts a reference value, and
		587	$@ gets set to that value in exception traps. This
		588	makes it possible to propagate exception objects. This is an
		589	undocumented __experimental__ feature.
		590
		591
		592	__Re-blessing in__ ''DESTROY ()''
		593	__supported for chaining__ ''DESTROY
		594	()'' __methods__
		595
		596
		597	See ``Destructors'' in perlobj.
		598
		599
		600	__All__ printf __format conversions are handled
		601	internally__
		602
		603
		604	See ``printf'' in perlfunc.
		605
		606
		607	__New__ INIT __keyword__
		608
		609
		610	INIT subs are like BEGIN and END,
		611	but they get run just before the perl runtime begins
		612	execution. e.g., the Perl Compiler makes use of
		613	INIT blocks to initialize and resolve pointers to
		614	XSUBs.
		615
		616
		617	__New__ lock __keyword__
		618
		619
		620	The lock keyword is the fundamental synchronization
		621	primitive in threaded perl. When threads are not enabled, it
		622	is currently a noop.
		623
		624
		625	To minimize impact on source compatibility this keyword is
		626	``weak'', i.e., any user-defined subroutine of the same name
		627	overrides it, unless a use Thread has been
		628	seen.
		629
		630
		631	__New__ qr// __operator__
		632
		633
		634	The qr// operator, which is syntactically similar
		635	to the other quote-like operators, is used to create
		636	precompiled regular expressions. This compiled form can now
		637	be explicitly passed around in variables, and interpolated
		638	in other regular expressions. See perlop.
		639
		640
		641	our __is now a reserved word__
		642
		643
		644	Calling a subroutine with the name our will now
		645	provoke a warning when using the -w
		646	switch.
		647
		648
		649	__Tied arrays are now fully supported__
		650
		651
		652	See Tie::Array.
		653
		654
		655	__Tied handles support is better__
		656
		657
		658	Several missing hooks have been added. There is also a new
		659	base class for TIEARRAY implementations. See
		660	Tie::Array.
		661
		662
		663	__4th argument to substr__
		664
		665
		666	''substr()'' can now both return and replace in one
		667	operation. The optional 4th argument is the replacement
		668	string. See ``substr'' in perlfunc.
		669
		670
		671	__Negative LENGTH argument to
		672	splice__
		673
		674
		675	''splice()'' with a negative LENGTH
		676	argument now work similar to what the LENGTH
		677	did for ''substr()''. Previously a negative
		678	LENGTH was treated as 0. See ``splice'' in
		679	perlfunc.
		680
		681
		682	__Magic lvalues are now more magical__
		683
		684
		685	When you say something like substr($x, 5) =
		686	, the scalar returned by ''substr()''
		687	is special, in that any modifications to it affect
		688	$x. (This is called a 'magic lvalue' because an
		689	'lvalue' is something on the left side of an assignment.)
		690	Normally, this is exactly what you would expect to happen,
		691	but Perl uses the same magic if you use ''substr()'',
		692	''pos()'', or ''vec()'' in a context where they might
		693	be modified, like taking a reference with \ or as
		694	an argument to a sub that modifies @_. In previous
		695	versions, this 'magic' only went one way, but now changes to
		696	the scalar the magic refers to ($x in the above example)
		697	affect the magic lvalue too. For instance, this code now
		698	acts differently:
		699
		700
		701	$x =
		702	In previous versions, this would print ``hello'', but it now prints ``g'bye''.
		703
		704
		705	____
		706
		707
		708	If $/ is a reference to an integer, or a scalar
		709	that holds an integer,
		710	!!Supported Platforms
		711
		712
		713	Configure has many incremental improvements. Site-wide
		714	policy for building perl can now be made persistent, via
		715	Policy.sh. Configure also records the command-line arguments
		716	used in ''config.sh''.
		717
		718
		719	__New Platforms__
		720
		721
		722	BeOS is now supported. See ''README
		723	.beos''.
		724
		725
		726	DOS is now supported under the
		727	DJGPP tools. See ''README
		728	.dos'' (installed as perldos on some
		729	systems).
		730
		731
		732	MiNT is now supported. See ''README
		733	.mint''.
		734
		735
		736	MPE/iX is now supported. See ''README
		737	.mpeix''.
		738
		739
		740	MVS (aka OS390 , aka Open
		741	Edition) is now supported. See ''README
		742	.os390'' (installed as perlos390 on some
		743	systems).
		744
		745
		746	Stratus VOS is now supported. See
		747	''README .vos''.
		748
		749
		750	__Changes in existing support__
		751
		752
		753	Win32 support has been vastly enhanced. Support for Perl
		754	Object, a C ++ encapsulation of Perl.
		755	GCC and EGCS are now supported
		756	on Win32. See ''README .win32'', aka
		757	perlwin32.
		758
		759
		760	VMS configuration system has been rewritten.
		761	See ''README .vms'' (installed as
		762	README_vms on some systems).
		763
		764
		765	The hints files for most Unix platforms have seen
		766	incremental improvements.
		767	!!Modules and Pragmata
		768
		769
		770	__New Modules__
		771
		772
		773	B
		774
		775
		776	Perl compiler and tools. See B.
		777
		778
		779	Data::Dumper
		780
		781
		782	A module to pretty print Perl data. See
		783	Data::Dumper.
		784
		785
		786	Dumpvalue
		787
		788
		789	A module to dump perl values to the screen. See
		790	Dumpvalue.
		791
		792
		793	Errno
		794
		795
		796	A module to look up errors more conveniently. See
		797	Errno.
		798
		799
		800	File::Spec
		801
		802
		803	A portable API for file
		804	operations.
		805
		806
2	perry	807	!ExtUtils::Installed
1	perry	808
		809
		810	Query and manage installed modules.
		811
		812
2	perry	813	!ExtUtils::Packlist
1	perry	814
		815
		816	Manipulate .packlist files.
		817
		818
		819	Fatal
		820
		821
		822	Make functions/builtins succeed or die.
		823
		824
		825	IPC::SysV
		826
		827
		828	Constants and other support infrastructure for System V
		829	IPC operations in perl.
		830
		831
		832	Test
		833
		834
		835	A framework for writing testsuites.
		836
		837
		838	Tie::Array
		839
		840
		841	Base class for tied arrays.
		842
		843
		844	Tie::Handle
		845
		846
		847	Base class for tied handles.
		848
		849
		850	Thread
		851
		852
		853	Perl thread creation, manipulation, and
		854	support.
		855
		856
		857	attrs
		858
		859
		860	Set subroutine attributes.
		861
		862
		863	fields
		864
		865
		866	Compile-time class fields.
		867
		868
		869	re
		870
		871
		872	Various pragmata to control behavior of regular
		873	expressions.
		874
		875
		876	__Changes in existing modules__
		877
		878
		879	Benchmark
		880
		881
		882	You can now run tests for ''x'' seconds instead of
		883	guessing the right number of tests to run.
		884
		885
		886	Keeps better time.
		887
		888
		889	Carp
		890
		891
		892	Carp has a new function ''cluck()''. ''cluck()''
		893	warns, like ''carp()'', but also adds a stack backtrace
		894	to the error message, like ''confess()''.
		895
		896
		897	CGI
		898
		899
		900	CGI has been updated to version
		901	2.42.
		902
		903
		904	Fcntl
		905
		906
		907	More Fcntl constants added: F_SETLK64, F_SETLKW64,
		908	O_LARGEFILE for large (more than 4G) file access (the 64-bit
		909	support is not yet working, though, so no need to get overly
		910	excited), Free/Net/OpenBSD locking behaviour flags F_FLOCK,
		911	F_POSIX, Linux F_SHLCK, and O_ACCMODE: the mask of O_RDONLY,
		912	O_WRONLY, and O_RDWR.
		913
		914
		915	Math::Complex
		916
		917
		918	The accessors methods Re, Im, arg, abs, rho, theta, methods
		919	can ($z-Re()'') now also act as mutators
		920	($z-''Re''(3)).
		921
		922
		923	Math::Trig
		924
		925
		926	A little bit of radial trigonometry (cylindrical and
		927	spherical) added, for example the great circle
		928	distance.
		929
		930
		931	POSIX
		932
		933
		934	POSIX now has its own platform-specific hints
		935	files.
		936
		937
		938	DB_File
		939
		940
		941	DB_File supports version 2.x of Berkeley DB .
		942	See ext/DB_File/Changes.
		943
		944
2	perry	945	!MakeMaker
1	perry	946
		947
2	perry	948	!MakeMaker now supports writing empty makefiles, provides a
1	perry	949	way to specify that site ''umask()'' policy should be
		950	honored. There is also better support for manipulation of
		951	.packlist files, and getting information about installed
		952	modules.
		953
		954
		955	Extensions that have both architecture-dependent and
		956	architecture-independent files are now always installed
		957	completely in the architecture-dependent locations.
		958	Previously, the shareable parts were shared both across
		959	architectures and across perl versions and were therefore
		960	liable to be overwritten with newer versions that might have
		961	subtle incompatibilities.
		962
		963
		964	CPAN
		965
		966
		967	See CPAN
		968	.
		969
		970
		971	Cwd
		972
		973
		974	Cwd::cwd is faster on most platforms.
		975	!!Utility Changes
		976
		977
		978	h2ph and related utilities have been vastly
		979	overhauled.
		980
		981
		982	perlcc, a new experimental front end for the
		983	compiler is available.
		984
		985
		986	The crude GNU configure emulator is
		987	now called configure.gnu to avoid trampling on
		988	Configure under case-insensitive
		989	filesystems.
		990
		991
		992	perldoc used to be rather slow. The slower features
		993	are now optional. In particular, case-insensitive searches
		994	need the -i switch, and recursive searches need
		995	-r. You can set these switches in the
		996	PERLDOC environment variable to get the old
		997	behavior.
		998	!!Documentation Changes
		999
		1000
		1001	Config.pm now has a glossary of variables.
		1002
		1003
		1004	''Porting/patching.pod'' has detailed instructions on how
		1005	to create and submit patches for perl.
		1006
		1007
		1008	perlport specifies guidelines on how to write
		1009	portably.
		1010
		1011
		1012	perlmodinstall describes how to fetch and install modules
		1013	from CPAN sites.
		1014
		1015
		1016	Some more Perl traps are documented now. See
		1017	perltrap.
		1018
		1019
		1020	perlopentut gives a tutorial on using
		1021	''open()''.
		1022
		1023
		1024	perlreftut gives a tutorial on references.
		1025
		1026
		1027	perlthrtut gives a tutorial on threads.
		1028	!!New Diagnostics
		1029
		1030
		1031	Ambiguous call resolved as CORE::%s(), qualify as such or
		1032	use
		1033
		1034
		1035	(W) A subroutine you have declared has the same name as a
		1036	Perl keyword, and you have used the name without
		1037	qualification for calling one or the other. Perl decided to
		1038	call the builtin because the subroutine is not
		1039	imported.
		1040
		1041
		1042	To force interpretation as a subroutine call, either put an
		1043	ampersand before the subroutine name, or qualify the name
		1044	with its package. Alternatively, you can import the
		1045	subroutine (or pretend that it's imported with the use
		1046	subs pragma).
		1047
		1048
		1049	To silently interpret it as the Perl operator, use the
		1050	CORE:: prefix on the operator (e.g.
		1051	CORE::log($x)) or by declaring the subroutine to be
		1052	an object method (see attrs).
		1053
		1054
		1055	Bad index while coercing array into hash
		1056
		1057
		1058	(F) The index looked up in the hash found as the 0'th
		1059	element of a pseudo-hash is not legal. Index values must be
		1060	at 1 or greater. See perlref.
		1061
		1062
		1063	Bareword ``%s'' refers to nonexistent package
		1064
		1065
		1066	(W) You used a qualified bareword of the form
		1067	Foo::, but the compiler saw no other uses of that
		1068	namespace before that point. Perhaps you need to predeclare
		1069	a package?
		1070
		1071
		1072	Can't call method ``%s'' on an undefined value
		1073
		1074
		1075	(F) You used the syntax of a method call, but the slot
		1076	filled by the object reference or package name contains an
		1077	undefined value. Something like this will reproduce the
		1078	error:
		1079
		1080
		1081	$BADREF = 42;
		1082	process $BADREF 1,2,3;
		1083	$BADREF-
		1084
		1085
		1086	Can't check filesystem of script ``%s'' for
		1087	nosuid
		1088
		1089
		1090	(P) For some reason you can't check the filesystem of the
		1091	script for nosuid.
		1092
		1093
		1094	Can't coerce array into hash
		1095
		1096
		1097	(F) You used an array where a hash was expected, but the
		1098	array has no information on how to map from keys to array
		1099	indices. You can do that only with arrays that have a hash
		1100	reference at index 0.
		1101
		1102
		1103	Can't goto subroutine from an eval-string
		1104
		1105
		1106	(F) The ``goto subroutine'' call can't be used to jump out
		1107	of an eval ``string''. (You can use it to jump out of an
		1108	eval { BLOCK }, but you probably don't want
		1109	to.)
		1110
		1111
		1112	Can't localize pseudo-hash element
		1113
		1114
		1115	(F) You said something like local $ar-,
		1116	where $ar is a reference to a pseudo-hash. That
		1117	hasn't been implemented yet, but you can get a similar
		1118	effect by localizing the corresponding array element
		1119	directly -- local
		1120	$ar-.
		1121
		1122
		1123	Can't use %%! because Errno.pm is not available
		1124
		1125
		1126	(F) The first time the %! hash is used, perl automatically
		1127	loads the Errno.pm module. The Errno module is expected to
		1128	tie the %! hash to provide symbolic names for $!
		1129	errno values.
		1130
		1131
		1132	Cannot find an opnumber for ``%s''
		1133
		1134
		1135	(F) A string of a form CORE::word was given to
		1136	''prototype()'', but there is no builtin with the name
		1137	word.
		1138
		1139
		1140	Character class syntax [[. .] is reserved for future
		1141	extensions
		1142
		1143
		1144	(W) Within regular expression character classes ([[]) the
		1145	syntax beginning with ``[[.'' and ending with ``.]'' is
		1146	reserved for future extensions. If you need to represent
		1147	those character sequences inside a regular expression
		1148	character class, just quote the square brackets with the
		1149	backslash: ``[[.'' and ``.]''.
		1150
		1151
		1152	Character class syntax [[: :] is reserved for future
		1153	extensions
		1154
		1155
		1156	(W) Within regular expression character classes ([[]) the
		1157	syntax beginning with ``[[:'' and ending with ``:]'' is
		1158	reserved for future extensions. If you need to represent
		1159	those character sequences inside a regular expression
		1160	character class, just quote the square brackets with the
		1161	backslash: ``[[:'' and ``:]''.
		1162
		1163
		1164	Character class syntax [[= =] is reserved for future
		1165	extensions
		1166
		1167
		1168	(W) Within regular expression character classes ([[]) the
		1169	syntax beginning with ``[[='' and ending with ``=]'' is
		1170	reserved for future extensions. If you need to represent
		1171	those character sequences inside a regular expression
		1172	character class, just quote the square brackets with the
		1173	backslash: ``[[='' and ``=]''.
		1174
		1175
		1176	%s: Eval-group in insecure regular expression
		1177
		1178
		1179	(F) Perl detected tainted data when trying to compile a
		1180	regular expression that contains the (?{ ... })
		1181	zero-width assertion, which is unsafe. See ``(?{ code })''
		1182	in perlre, and perlsec.
		1183
		1184
		1185	%s: Eval-group not allowed, use re 'eval'
		1186
		1187
		1188	(F) A regular expression contained the (?{ ... })
		1189	zero-width assertion, but that construct is only allowed
		1190	when the use re 'eval' pragma is in effect. See
		1191	``(?{ code })'' in perlre.
		1192
		1193
		1194	%s: Eval-group not allowed at run time
		1195
		1196
		1197	(F) Perl tried to compile a regular expression containing
		1198	the (?{ ... }) zero-width assertion at run time, as
		1199	it would when the pattern contains interpolated values.
		1200	Since that is a security risk, it is not allowed. If you
		1201	insist, you may still do this by explicitly building the
		1202	pattern from an interpolated string at run time and using
		1203	that in an ''eval()''. See ``(?{ code })'' in
		1204	perlre.
		1205
		1206
		1207	Explicit blessing to '' (assuming package main)
		1208
		1209
		1210	(W) You are blessing a reference to a zero length string.
		1211	This has the effect of blessing the reference into the
		1212	package main. This is usually not what you want. Consider
		1213	providing a default target package, e.g. bless($ref,
2	perry	1214	$p '!MyPackage');
1	perry	1215
		1216
		1217	Illegal hex digit ignored
		1218
		1219
		1220	(W) You may have tried to use a character other than 0 - 9
		1221	or A - F in a hexadecimal number. Interpretation of the
		1222	hexadecimal number stopped before the illegal
		1223	character.
		1224
		1225
		1226	No such array field
		1227
		1228
		1229	(F) You tried to access an array as a hash, but the field
		1230	name used is not defined. The hash at index 0 should map all
		1231	valid field names to array indices for that to
		1232	work.
		1233
		1234
		1235	No such field ``%s'' in variable %s of type
		1236	%s
		1237
		1238
		1239	(F) You tried to access a field of a typed variable where
		1240	the type does not know about the field name. The field names
		1241	are looked up in the %FIELDS hash in the type
		1242	package at compile time. The %FIELDS hash is
		1243	usually set up with the 'fields' pragma.
		1244
		1245
		1246	Out of memory during ridiculously large request
		1247
		1248
		1249	(F) You can't allocate more than 2^31+``small amount''
		1250	bytes. This error is most likely to be caused by a typo in
		1251	the Perl program. e.g., $arr[[time] instead of
		1252	$arr[[$time].
		1253
		1254
		1255	Range iterator outside integer range
		1256
		1257
		1258	(F) One (or both) of the numeric arguments to the range
		1259	operator ``..'' are outside the range which can be
		1260	represented by integers internally. One possible workaround
		1261	is to force Perl to use magical string increment by
		1262	prepending ``0'' to your numbers.
		1263
		1264
		1265	Recursive inheritance detected while looking for method '%s'
		1266	%s
		1267
		1268
		1269	(F) More than 100 levels of inheritance were encountered
		1270	while invoking a method. Probably indicates an unintended
		1271	loop in your inheritance hierarchy.
		1272
		1273
		1274	Reference found where even-sized list expected
		1275
		1276
		1277	(W) You gave a single reference where Perl was expecting a
		1278	list with an even number of elements (for assignment to a
		1279	hash). This usually means that you used the anon hash
		1280	constructor when you meant to use parens. In any case, a
		1281	hash requires key/value __pairs__.
		1282
		1283
		1284	%hash = { one =
		1285
		1286
		1287	Undefined value assigned to typeglob
		1288
		1289
		1290	(W) An undefined value was assigned to a typeglob, a la
		1291	*foo = undef. This does nothing. It's possible that
		1292	you really mean undef *foo.
		1293
		1294
		1295	Use of reserved word ``%s'' is deprecated
		1296
		1297
		1298	(D) The indicated bareword is a reserved word. Future
		1299	versions of perl may use it as a keyword, so you're better
		1300	off either explicitly quoting the word in a manner
		1301	appropriate for its context of use, or using a different
		1302	name altogether. The warning can be suppressed for
		1303	subroutine names by either adding a prefix,
		1304	or using a package qualifier, e.g. , or
		1305	Foo::our().
		1306
		1307
		1308	perl: warning: Setting locale failed.
		1309
		1310
		1311	(S) The whole warning message will look something
		1312	like:
		1313
		1314
		1315	perl: warning: Setting locale failed.
		1316	perl: warning: Please check that your locale settings:
		1317	LC_ALL =
		1318	Exactly what were the failed locale settings varies. In the above the settings were that the LC_ALL was ``En_US'' and the LANG had no value. This error means that Perl detected that you and/or your system administrator have set up the so-called variable system but Perl could not use those settings. This was not dead serious, fortunately: there is a ``default locale'' called ``C'' that Perl can and will use, the script will be run. Before you really fix the problem, however, you will get the same error message each time you run Perl. How to really fix the problem can be found in `` LOCALE PROBLEMS '' in perllocale.
		1319	!!Obsolete Diagnostics
		1320
		1321
		1322	Can't ''mktemp()''
		1323
		1324
		1325	(F) The ''mktemp()'' routine failed for some reason while
		1326	trying to process a __-e__ switch. Maybe your /tmp
		1327	partition is full, or clobbered.
		1328
		1329
		1330	Removed because __-e__ doesn't use temporary files any
		1331	more.
		1332
		1333
		1334	Can't write to temp file for __-e__:
		1335	%s
		1336
		1337
		1338	(F) The write routine failed for some reason while trying to
		1339	process a __-e__ switch. Maybe your /tmp partition is
		1340	full, or clobbered.
		1341
		1342
		1343	Removed because __-e__ doesn't use temporary files any
		1344	more.
		1345
		1346
		1347	Cannot open temporary file
		1348
		1349
		1350	(F) The create routine failed for some reason while trying
		1351	to process a __-e__ switch. Maybe your /tmp partition is
		1352	full, or clobbered.
		1353
		1354
		1355	Removed because __-e__ doesn't use temporary files any
		1356	more.
		1357
		1358
		1359	regexp too big
		1360
		1361
		1362	(F) The current implementation of regular expressions uses
		1363	shorts as address offsets within a string. Unfortunately
		1364	this means that if the regular expression compiles to longer
		1365	than 32767, it'll blow up. Usually when you want a regular
		1366	expression this big, there is a better way to do it with
		1367	multiple statements. See perlre.
		1368	!!Configuration Changes
		1369
		1370
		1371	You can use ``Configure -Uinstallusrbinperl'' which causes
		1372	installperl to skip installing perl also as /usr/bin/perl.
		1373	This is useful if you prefer not to modify /usr/bin for some
		1374	reason or another but harmful because many scripts assume to
		1375	find Perl in /usr/bin/perl.
		1376	!!BUGS
		1377
		1378
		1379	If you find what you think is a bug, you might check the
		1380	headers of recently posted articles in the
		1381	comp.lang.perl.misc newsgroup. There may also be information
		1382	at http://www.perl.com/perl/, the Perl Home
		1383	Page.
		1384
		1385
		1386	If you believe you have an unreported bug, please run the
		1387	__perlbug__ program included with your release. Make sure
		1388	you trim your bug down to a tiny but sufficient test case.
		1389	Your bug report, along with the output of perl -V,
		1390	will be sent off to perlbug@perl.com''
		1391	''
		1392	!!SEE ALSO
		1393
		1394
		1395	The ''Changes'' file for exhaustive details on what
		1396	changed.
		1397
		1398
		1399	The ''INSTALL'' file for how to build
		1400	Perl.
		1401
		1402
		1403	The ''README'' file for general
		1404	stuff.
		1405
		1406
		1407	The ''Artistic'' and ''Copying'' files for copyright
		1408	information.
		1409	!!HISTORY
		1410
		1411
		1412	Written by Gurusamy Sarathy
		1413	gsar@activestate.com''
		1414	''
		1415
		1416
		1417	Send omissions or corrections to
		1418	perlbug@perl.com''''
		1419	----