<LI><A HREF="#warning: this version is not binary compatible with perl 5.004.">WARNING: This version is not binary compatible with Perl 5.004.</A></LI>
<LI><A HREF="#default installation structure has changed">Default installation structure has changed</A></LI>
<LI><A HREF="#more generous treatment of carriage returns">More generous treatment of carriage returns</A></LI>
<LI><A HREF="#memory leaks">Memory leaks</A></LI>
<LI><A HREF="#better support for multiple interpreters">Better support for multiple interpreters</A></LI>
<LI><A HREF="#behavior of local() on array and hash elements is now welldefined">Behavior of <A HREF="../../lib/Pod/perlfunc.html#item_local"><CODE>local()</CODE></A> on array and hash elements is now well-defined</A></LI>
<LI><A HREF="#%! is transparently tied to the errno module"><CODE>%!</CODE> is transparently tied to the <A HREF="../../lib/Errno.html">the Errno manpage</A> module</A></LI>
<LI><A HREF="#pseudohashes are supported">Pseudo-hashes are supported</A></LI>
<LI><A HREF="#expr foreach expr is supported"><CODE>EXPR foreach EXPR</CODE> is supported</A></LI>
<LI><A HREF="#keywords can be globally overridden">Keywords can be globally overridden</A></LI>
<LI><A HREF="#$^e is meaningful on win32"><CODE>$^E</CODE> is meaningful on Win32</A></LI>
<LI><A HREF="#experimental support for 64bit platforms">Experimental support for 64-bit platforms</A></LI>
<LI><A HREF="#prototype() returns useful results on builtins"><A HREF="../../lib/Pod/perlfunc.html#item_prototype"><CODE>prototype()</CODE></A> returns useful results on builtins</A></LI>
<LI><A HREF="#extended support for exception handling">Extended support for exception handling</A></LI>
<LI><A HREF="#reblessing in destroy() supported for chaining destroy() methods">Re-blessing in <CODE>DESTROY()</CODE> supported for chaining <CODE>DESTROY()</CODE> methods</A></LI>
<LI><A HREF="#all printf format conversions are handled internally">All <A HREF="../../lib/Pod/perlfunc.html#item_printf"><CODE>printf</CODE></A> format conversions are handled internally</A></LI>
<P>There have been a large number of changes in the internals to support
the new features in this release.</P>
<DL>
<DT><STRONG><A NAME="item_Core_sources_now_require_ANSI_C_compiler">Core sources now require ANSI C compiler</A></STRONG><BR>
<DD>
An ANSI C compiler is now <STRONG>required</STRONG> to build perl. See <EM>INSTALL</EM>.
<P></P>
<DT><STRONG><A NAME="item_All_Perl_global_variables_must_now_be_referenced_w">All Perl global variables must now be referenced with an explicit prefix</A></STRONG><BR>
<DD>
All Perl global variables that are visible for use by extensions now
have a <CODE>PL_</CODE> prefix. New extensions should <CODE>not</CODE> refer to perl globals
by their unqualified names. To preserve sanity, we provide limited
backward compatibility for globals that are being widely used like
<CODE>sv_undef</CODE> and <CODE>na</CODE> (which should now be written as <CODE>PL_sv_undef</CODE>,
<CODE>PL_na</CODE> etc.)
<P>If you find that your XS extension does not compile anymore because a
perl global is not visible, try adding a <CODE>PL_</CODE> prefix to the global
and rebuild.</P>
<P>It is strongly recommended that all functions in the Perl API that don't
begin with <CODE>perl</CODE> be referenced with a <CODE>Perl_</CODE> prefix. The bare function
names without the <CODE>Perl_</CODE> prefix are supported with macros, but this
support may cease in a future release.</P>
<P>See <A HREF="../../lib/Pod/perlguts.html#api listing">API LISTING in the perlguts manpage</A>.</P>
<P></P>
<DT><STRONG><A NAME="item_Enabling_threads_has_source_compatibility_issues">Enabling threads has source compatibility issues</A></STRONG><BR>
<DD>
Perl built with threading enabled requires extensions to use the new
<CODE>dTHR</CODE> macro to initialize the handle to access per-thread data.
If you see a compiler error that talks about the variable <CODE>thr</CODE> not
being declared (when building a module that has XS code), you need
to add <CODE>dTHR;</CODE> at the beginning of the block that elicited the error.
<P>The API function <CODE>perl_get_sv("@",FALSE)</CODE> should be used instead of
directly accessing perl globals as <CODE>GvSV(errgv)</CODE>. The API call is
backward compatible with existing perls and provides source compatibility
with threading is enabled.</P>
<P>See <A HREF="#c source compatibility">C Source Compatibility</A> for more information.</P>
<P>The internals now reallocate the perl stack only at predictable times.
In particular, magic calls never trigger reallocations of the stack,
because all reentrancy of the runtime is handled using a ``stack of stacks''.
This should improve reliability of cached stack pointers in the internals
and in XSUBs.</P>
<P>
<H2><A NAME="more generous treatment of carriage returns">More generous treatment of carriage returns</A></H2>
<P>Perl used to complain if it encountered literal carriage returns in
scripts. Now they are mostly treated like whitespace within program text.
Inside string literals and here documents, literal carriage returns are
ignored if they occur paired with linefeeds, or get interpreted as whitespace
if they stand alone. This behavior means that literal carriage returns
in files should be avoided. You can get the older, more compatible (but
less generous) behavior by defining the preprocessor symbol
<CODE>PERL_STRICT_CR</CODE> when building perl. Of course, all this has nothing
whatever to do with how escapes like <CODE>\r</CODE> are handled within strings.</P>
<P>Note that this doesn't somehow magically allow you to keep all text files
in DOS format. The generous treatment only applies to files that perl
itself parses. If your C compiler doesn't allow carriage returns in
files, you may still be unable to build modules that need a C compiler.</P>
<P>
<H2><A NAME="memory leaks">Memory leaks</A></H2>
<P><A HREF="../../lib/Pod/perlfunc.html#item_substr"><CODE>substr</CODE></A>, <A HREF="../../lib/Pod/perlfunc.html#item_pos"><CODE>pos</CODE></A> and <A HREF="../../lib/Pod/perlfunc.html#item_vec"><CODE>vec</CODE></A> don't leak memory anymore when used in lvalue
context. Many small leaks that impacted applications that embed multiple
interpreters have been fixed.</P>
<P>
<H2><A NAME="better support for multiple interpreters">Better support for multiple interpreters</A></H2>
<P>The build-time option <CODE>-DMULTIPLICITY</CODE> has had many of the details
reworked. Some previously global variables that should have been
per-interpreter now are. With care, this allows interpreters to call
each other. See the <CODE>PerlInterp</CODE> extension on CPAN.</P>
<P>
<H2><A NAME="behavior of local() on array and hash elements is now welldefined">Behavior of <A HREF="../../lib/Pod/perlfunc.html#item_local"><CODE>local()</CODE></A> on array and hash elements is now well-defined</A></H2>
<P>See <A HREF="../../lib/Pod/perlsub.html#temporary values via local()">Temporary Values via local() in the perlsub manpage</A>.</P>
<P>
<H2><A NAME="%! is transparently tied to the errno module"><CODE>%!</CODE> is transparently tied to the <A HREF="../../lib/Errno.html">the Errno manpage</A> module</A></H2>
<P>See <A HREF="../../lib/Pod/perlvar.html">the perlvar manpage</A>, and <A HREF="../../lib/Errno.html">the Errno manpage</A>.</P>
<P>
<H2><A NAME="pseudohashes are supported">Pseudo-hashes are supported</A></H2>
<H2><A NAME="experimental support for 64bit platforms">Experimental support for 64-bit platforms</A></H2>
<P>Perl5 has always had 64-bit support on systems with 64-bit longs.
Starting with 5.005, the beginnings of experimental support for systems
with 32-bit long and 64-bit 'long long' integers has been added.
If you add -DUSE_LONG_LONG to your ccflags in config.sh (or manually
define it in perl.h) then perl will be built with 'long long' support.
There will be many compiler warnings, and the resultant perl may not
work on all systems. There are many other issues related to
third-party extensions and libraries. This option exists to allow
people to work on those issues.</P>
<P>
<H2><A NAME="prototype() returns useful results on builtins"><A HREF="../../lib/Pod/perlfunc.html#item_prototype"><CODE>prototype()</CODE></A> returns useful results on builtins</A></H2>
<P>See <A HREF="../../lib/Pod/perlfunc.html#prototype">prototype in the perlfunc manpage</A>.</P>
<P>
<H2><A NAME="extended support for exception handling">Extended support for exception handling</A></H2>
<P><A HREF="../../lib/Pod/perlfunc.html#item_die"><CODE>die()</CODE></A> now accepts a reference value, and <CODE>$@</CODE> gets set to that
value in exception traps. This makes it possible to propagate
exception objects. This is an undocumented <STRONG>experimental</STRONG> feature.</P>
<P>
<H2><A NAME="reblessing in destroy() supported for chaining destroy() methods">Re-blessing in <CODE>DESTROY()</CODE> supported for chaining <CODE>DESTROY()</CODE> methods</A></H2>
<P>See <A HREF="../../lib/Pod/perlobj.html#destructors">Destructors in the perlobj manpage</A>.</P>
<P>
<H2><A NAME="all printf format conversions are handled internally">All <A HREF="../../lib/Pod/perlfunc.html#item_printf"><CODE>printf</CODE></A> format conversions are handled internally</A></H2>
<P>See <A HREF="../../lib/Pod/perlfunc.html#printf">printf in the perlfunc manpage</A>.</P>
<P><EM>Porting/patching.pod</EM> has detailed instructions on how to create and
submit patches for perl.</P>
<P><A HREF="../../lib/Pod/perlport.html">the perlport manpage</A> specifies guidelines on how to write portably.</P>
<P><A HREF="../../lib/Pod/perlmodinstall.html">the perlmodinstall manpage</A> describes how to fetch and install modules from <A HREF="#item_CPAN"><CODE>CPAN</CODE></A>
sites.</P>
<P>Some more Perl traps are documented now. See <A HREF="../../lib/Pod/perltrap.html">the perltrap manpage</A>.</P>
<P><A HREF="../../lib/Pod/perlopentut.html">the perlopentut manpage</A> gives a tutorial on using open().</P>
<P><A HREF="../../lib/Pod/perlreftut.html">the perlreftut manpage</A> gives a tutorial on references.</P>
<P><A HREF="../../lib/Pod/perlthrtut.html">the perlthrtut manpage</A> gives a tutorial on threads.</P>
(F) You said something like <CODE>local $ar->{'key'}</CODE>, where $ar is
a reference to a pseudo-hash. That hasn't been implemented yet, but
you can get a similar effect by localizing the corresponding array
element directly -- <CODE>local $ar->[$ar->[0]{'key'}]</CODE>.
<P></P>
<DT><STRONG><A NAME="item_Can%27t_use_%25%25%21_because_Errno%2Epm_is_not_av">Can't use %%! because Errno.pm is not available</A></STRONG><BR>
<DD>
(F) The first time the %! hash is used, perl automatically loads the
Errno.pm module. The Errno module is expected to tie the %! hash to
provide symbolic names for <CODE>$!</CODE> errno values.
<P></P>
<DT><STRONG><A NAME="item_Cannot_find_an_opnumber_for_%22%25s%22">Cannot find an opnumber for ``%s''</A></STRONG><BR>
<DD>
(F) A string of a form <CODE>CORE::word</CODE> was given to prototype(), but
there is no builtin with the name <CODE>word</CODE>.
<P></P>
<DT><STRONG><A NAME="item_Character_class_syntax_%5B%2E_%2E%5D_is_reserved_f">Character class syntax [. .] is reserved for future extensions</A></STRONG><BR>
<DD>
(W) Within regular expression character classes ([]) the syntax beginning
with ``[.'' and ending with ``.]'' is reserved for future extensions.
If you need to represent those character sequences inside a regular
expression character class, just quote the square brackets with the
backslash: ``\[.'' and ``.\]''.
<P></P>
<DT><STRONG><A NAME="item_Character_class_syntax_%5B%3A_%3A%5D_is_reserved_f">Character class syntax [: :] is reserved for future extensions</A></STRONG><BR>
<DD>
(W) Within regular expression character classes ([]) the syntax beginning
with ``[:'' and ending with ``:]'' is reserved for future extensions.
If you need to represent those character sequences inside a regular
expression character class, just quote the square brackets with the
backslash: ``\[:'' and ``:\]''.
<P></P>
<DT><STRONG><A NAME="item_Character_class_syntax_%5B%3D_%3D%5D_is_reserved_f">Character class syntax [= =] is reserved for future extensions</A></STRONG><BR>
<DD>
(W) Within regular expression character classes ([]) the syntax
beginning with ``[='' and ending with ``=]'' is reserved for future extensions.
If you need to represent those character sequences inside a regular
expression character class, just quote the square brackets with the
backslash: ``\[='' and ``=\]''.
<P></P>
<DT><STRONG><A NAME="item_%s:">%s: Eval-group in insecure regular expression</A></STRONG><BR>
<DD>
(F) Perl detected tainted data when trying to compile a regular expression
that contains the <CODE>(?{ ... })</CODE> zero-width assertion, which is unsafe.
See <A HREF="../../lib/Pod/perlre.html#({ code })">(?{ code }) in the perlre manpage</A>, and <A HREF="../../lib/Pod/perlsec.html">the perlsec manpage</A>.
<P></P>
<DT><STRONG>%s: Eval-group not allowed, use re 'eval'</STRONG><BR>
<DD>
(F) A regular expression contained the <CODE>(?{ ... })</CODE> zero-width assertion,
but that construct is only allowed when the <CODE>use re 'eval'</CODE> pragma is
in effect. See <A HREF="../../lib/Pod/perlre.html#({ code })">(?{ code }) in the perlre manpage</A>.
<P></P>
<DT><STRONG>%s: Eval-group not allowed at run time</STRONG><BR>
<DD>
(F) Perl tried to compile a regular expression containing the <CODE>(?{ ... })</CODE>
zero-width assertion at run time, as it would when the pattern contains
interpolated values. Since that is a security risk, it is not allowed.
If you insist, you may still do this by explicitly building the pattern
from an interpolated string at run time and using that in an eval().
See <A HREF="../../lib/Pod/perlre.html#({ code })">(?{ code }) in the perlre manpage</A>.
<P></P>
<DT><STRONG><A NAME="item_Explicit_blessing_to_%27%27_%28assuming_package_ma">Explicit blessing to '' (assuming package main)</A></STRONG><BR>
<DD>
(W) You are blessing a reference to a zero length string. This has
the effect of blessing the reference into the package main. This is
usually not what you want. Consider providing a default target
(F) One (or both) of the numeric arguments to the range operator ``..''
are outside the range which can be represented by integers internally.
One possible workaround is to force Perl to use magical string
increment by prepending ``0'' to your numbers.
<P></P>
<DT><STRONG><A NAME="item_Recursive_inheritance_detected_while_looking_for_m">Recursive inheritance detected while looking for method '%s' in package '%s'</A></STRONG><BR>
<DD>
(F) More than 100 levels of inheritance were encountered while invoking a
method. Probably indicates an unintended loop in your inheritance hierarchy.
<P></P>
<DT><STRONG><A NAME="item_Reference_found_where_even%2Dsized_list_expected">Reference found where even-sized list expected</A></STRONG><BR>
<DD>
(W) You gave a single reference where Perl was expecting a list with
an even number of elements (for assignment to a hash). This
usually means that you used the anon hash constructor when you meant
to use parens. In any case, a hash requires key/value <STRONG>pairs</STRONG>.
<PRE>
%hash = { one => 1, two => 2, }; # WRONG
%hash = [ qw/ an anon array / ]; # WRONG
%hash = ( one => 1, two => 2, ); # right
%hash = qw( one 1 two 2 ); # also fine</PRE>
<P></P>
<DT><STRONG><A NAME="item_Undefined_value_assigned_to_typeglob">Undefined value assigned to typeglob</A></STRONG><BR>
<DD>
(W) An undefined value was assigned to a typeglob, a la <CODE>*foo = undef</CODE>.
This does nothing. It's possible that you really mean <CODE>undef *foo</CODE>.
<P></P>
<DT><STRONG><A NAME="item_Use_of_reserved_word_%22%25s%22_is_deprecated">Use of reserved word ``%s'' is deprecated</A></STRONG><BR>
<DD>
(D) The indicated bareword is a reserved word. Future versions of perl
may use it as a keyword, so you're better off either explicitly quoting
the word in a manner appropriate for its context of use, or using a
different name altogether. The warning can be suppressed for subroutine
names by either adding a <CODE>&</CODE> prefix, or using a package qualifier,
e.g. <A HREF="../../lib/Pod/perlfunc.html#item_our"><CODE>&our()</CODE></A>, or <A HREF="../../lib/Pod/perlfunc.html#item_our"><CODE>Foo::our()</CODE></A>.
