X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=pod%2Fperldelta.pod;h=88eeffc9c6308bc9967021cdf1c11efbe0452009;hb=08cd895235a7add1a6101888189211e99f27e0dd;hp=86781389b53308b7ba4118b15c37011f728f1c04;hpb=a43a7b9b40bf89fadd8851b90ce97e573bb2509a;p=p5sagit%2Fp5-mst-13.2.git diff --git a/pod/perldelta.pod b/pod/perldelta.pod index 8678138..88eeffc 100644 --- a/pod/perldelta.pod +++ b/pod/perldelta.pod @@ -1,16 +1,124 @@ =head1 NAME -perldelta - what's new for perl5.006 (as of 5.005_54) +perldelta - what's new for perl v5.6 (as of v5.005_62) =head1 DESCRIPTION +This is an unsupported alpha release, meant for intrepid Perl developers +only. The included sources may not even build correctly on some platforms. +Subscribing to perl5-porters is the best way to monitor and contribute +to the progress of development releases (see www.perl.org for info). + This document describes differences between the 5.005 release and this one. =head1 Incompatible Changes =head2 Perl Source Incompatibilities -None known at this time. +Beware that any new warnings that have been added are B considered +incompatible changes. + +Since all new warnings must be explicitly requested via the C<-w> +switch or the C pragma, it is ultimately the programmer's +responsibility to ensure that warnings are enabled judiciously. + +=over 4 + +=item Treatment of list slices of undef has changed + +When taking a slice of a literal list (as opposed to a slice of +an array or hash), Perl used to return an empty list if the +result happened to be composed of all undef values. + +The new behavior is to produce an empty list if (and only if) +the original list was empty. Consider the following example: + + @a = (1,undef,undef,2)[2,1,2]; + +The old behavior would have resulted in @a having no elements. +The new behavior ensures it has three undefined elements. + +Note in particular that the behavior of slices of the following +cases remains unchanged: + + @a = ()[1,2]; + @a = (getpwent)[7,0]; + @a = (anything_returning_empty_list())[2,1,2]; + @a = @b[2,1,2]; + @a = @c{'a','b','c'}; + +See L. + +=item Possibly changed pseudo-random number generator + +In 5.005_0x and earlier, perl's rand() function used the C library +rand(3) function. As of 5.005_52, Configure tests for drand48(), +random(), and rand() (in that order) and picks the first one it finds. +Perl programs that depend on reproducing a specific set of pseudo-random +numbers will now likely produce different output. + +=item Hashing function for hash keys has changed + +Perl hashes are not order preserving. The apparently random order +encountered when iterating on the contents of a hash is determined +by the hashing algorithm used. To improve the distribution of lower +bits in the hashed value, the algorithm has changed slightly as of +5.005_52. When iterating over hashes, this may yield a random order +that is B from that of previous versions. + +=item C fails on read only values + +Using the C operator on a readonly value (such as $1) has +the same effect as assigning C to the readonly value--it +throws an exception. + +=item Close-on-exec bit may be set on pipe() handles + +On systems that support a close-on-exec flag on filehandles, the +flag will be set for any handles created by pipe(), if that is +warranted by the value of $^F that may be in effect. Earlier +versions neglected to set the flag for handles created with +pipe(). See L and L. + +=item Writing C<"$$1"> to mean C<"${$}1"> is unsupported + +Perl 5.004 deprecated the interpretation of C<$$1> and +similar within interpolated strings to mean C<$$ . "1">, +but still allowed it. + +In Perl 5.6 and later, C<"$$1"> always means C<"${$1}">. + +=item values(%h) and C<\(%h)> operate on aliases to values, not copies + +each(), values() and hashes in a list context return the actual +values in the hash, instead of copies (as they used to in earlier +versions). Typical idioms for using these constructs copy the +returned values, but this is can make a significant difference when +creating references to the returned values. + +Keys in the hash are still returned as copies when iterating on +a hash. + +=item vec(EXPR,OFFSET,BITS) enforces powers-of-two BITS + +vec() generates a run-time error if the BITS argument is not +a valid power-of-two integer. + +=item Text of some diagnostic output has changed + +Most references to internal Perl operations in diagnostics +have been changed to be more descriptive. This may be an +issue for programs that may incorrectly rely on the exact +text of diagnostics for proper functioning. + +=item C<%@> has been removed + +The undocumented special variable C<%@> that used to accumulate +"background" errors (such as those that happen in DESTROY()) +has been removed, because it could potentially result in memory +leaks. + +=back =head2 C Source Incompatibilities @@ -19,73 +127,733 @@ None known at this time. =item C Release 5.005 grandfathered old global symbol names by providing preprocessor -macros for extension source compatibility. As of release 5.006, these +macros for extension source compatibility. As of release 5.6, these preprocessor definitions are not available by default. You need to explicitly -compile perl with C<-DPERL_POLLUTE> in order to get these definitions. +compile perl with C<-DPERL_POLLUTE> to get these definitions. For +extensions still using the old symbols, this option can be +specified via MakeMaker: + + perl Makefile.PL POLLUTE=1 + +=item C + +This new build option provides a set of macros for all API functions +such that an implicit interpreter/thread context argument is passed to +every API function. As a result of this, something like C +amounts to a macro invocation that actually translates to something like +C. While this is generally expected +to not have any significant source compatibility issues, the difference +between a macro and a real function call will need to be considered. + +This means that there B a source compatibility issue as a result of +this if your extensions attempt to use pointers to any of the Perl API +functions. + +Note that the above issue is not relevant to the default build of +Perl, whose interfaces continue to match those of prior versions +(but subject to the other options described here). + +PERL_IMPLICIT_CONTEXT is automatically enabled whenever Perl is built +with one of -Dusethreads, -Dusemultiplicity, or both. + +See L for detailed information on the +ramifications of building Perl using this option. + +=item C + +Enabling Perl's malloc in release 5.005 and earlier caused +the namespace of system versions of the malloc family of functions to +be usurped by the Perl versions, since by default they used the +same names. + +Besides causing problems on platforms that do not allow these functions to +be cleanly replaced, this also meant that the system versions could not +be called in programs that used Perl's malloc. Previous versions of Perl +have allowed this behaviour to be suppressed with the HIDEMYMALLOC and +EMBEDMYMALLOC preprocessor definitions. + +As of release 5.6, Perl's malloc family of functions have default names +distinct from the system versions. You need to explicitly compile perl with +C<-DPERL_POLLUTE_MALLOC> to get the older behaviour. HIDEMYMALLOC +and EMBEDMYMALLOC have no effect, since the behaviour they enabled is now +the default. + +Note that these functions do B constitute Perl's memory allocation API. +See L for further information about that. =item C and C Issues The C global is now thread local, so a C declaration is needed -in the scope in which it appears. XSUBs should handle this automatically, +in the scope in which the global appears. XSUBs should handle this automatically, but if you have used C in support functions, you either need to change the C to a local variable (which is recommended), or put in a C. =back +=head2 Compatible C Source API Changes + +=over + +=item C is now C + +The cpp macros C, C, and C +are now available by default from perl.h, and reflect the base revision, +patchlevel, and subversion respectively. C had no +prior equivalent, while C and C were +previously available as C and C. + +The new names cause less pollution of the B namespace and reflect what +the numbers have come to stand for in common practice. For compatibility, +the old names are still supported when F is explicitly +included (as required before), so there is no source incompatibility +from the change. + +=item Support for C++ exceptions + +change#3386, also needs perlguts documentation +[TODO - Chip Salzenberg ] + +=back + =head2 Binary Incompatibilities -This release is not binary compatible with the 5.005 release and its -maintenance versions. +The default build of this release is binary compatible with the 5.005 +release or its maintenance versions. + +The usethreads or usemultiplicity builds are B binary compatible +with the corresponding builds in 5.005. + +=head1 Installation and Configuration Improvements + +=head2 New Configure flags + +The following new flags may be enabled on the Configure command line +by running Configure with C<-Dflag>. + + usemultiplicity + + uselongdouble + usemorebits + uselargefiles + +=head2 -Dusethreads and -Duse64bits now more daring + +The Configure options enabling the use of threads and the use of +64-bitness are now more daring in the sense that they no more have +an explicit list of operating systems of known threads/64-bit +capabilities. In other words: if your operating system has the +necessary APIs, you should be able just to go ahead and use them. +See also L<"64-bit support">. + +=head2 Long Doubles + +Some platforms have "long doubles", floating point numbers of even +larger range than ordinary "doubles". To enable using ng doubles for +Perl's scalars, use -Duselongdouble. + +=head2 -Dusemorebits + +You can enable both -Duse64bits and -Dlongdouble by -Dusemorebits. +See also L<"64-bit support">. + +=head2 -Duselargefiles + +Some platforms support large files, files larger than two gigabytes. +See L<"Large file support"> for more information. + +=head2 installusrbinperl + +You can use "Configure -Uinstallusrbinperl" which causes installperl +to skip installing perl also as /usr/bin/perl. This is useful if you +prefer not to modify /usr/bin for some reason or another but harmful +because many scripts assume to find Perl in /usr/bin/perl. + +=head2 SOCKS support + +You can use "Configure -Dusesocks" which causes Perl to probe +for the SOCKS proxy protocol library, http://www.socks.nec.com/ + +=head2 C<-A> flag + +You can "post-edit" the Configure variables using the Configure C<-A> +flag. The editing happens immediately after the platform specific +hints files have been processed but before the actual configuration +process starts. Run C to find out the full C<-A> syntax. + +=head2 New Installation Scheme + +vendorprefix et al +[TODO - Andy Dougherty ] =head1 Core Changes +=head2 Unicode and UTF-8 support + +Perl can optionally use UTF-8 as its internal representation for character +strings. The C pragma enables this support in the current lexical +scope. See L for more information. + +=head2 Lexically scoped warning categories + +You can now control the granularity of warnings emitted by perl at a finer +level using the C pragma. See L and L +for details. + +=head2 Lvalue subroutines + +WARNING: This is an experimental feature. + +change#4081 +[TODO - Ilya Zakharevich , +Tuomas Lukka )] + +=head2 "our" declarations + +An "our" declaration introduces a value that can be best understood +as a lexically scoped symbolic alias to a global variable in the +current package. This is mostly useful as an alternative to the +C pragma, but also provides the opportunity to introduce +typing and other attributes for such variables. See L. + +=head2 Weak references + +WARNING: This is an experimental feature. + +change#3385, also need perlguts documentation + +[TODO - Tuomas Lukka ] + =head2 Binary numbers supported Binary numbers are now supported as literals, in s?printf formats, and C: - $answer = 0b101010; - printf "The answer is: %b\n", oct("0b101010"); + $answer = 0b101010; + printf "The answer is: %b\n", oct("0b101010"); + +=head2 Some arrows may be omitted in calls through references + +Perl now allows the arrow to be omitted in many constructs +involving subroutine calls through references. For example, +C<$foo[10]->('foo')> may now be written C<$foo[10]('foo')>. +This is rather similar to how the arrow may be omitted from +C<$foo[10]->{'foo'}>. Note however, that the arrow is still +required for C('bar')>. =head2 syswrite() ease-of-use -The length argument of C is now optional. +The length argument of C has become optional. + +=head2 Filehandles can be autovivified + +The construct C can be used to create filehandles +more easily. The filehandle will be automatically closed at the end +of the scope of $fh, provided there are no other references to it. This +largely eliminates the need for typeglobs when opening filehandles +that must be passed around, as in the following example: + + sub myopen { + open my $fh, "@_" + or die "Can't open '@_': $!"; + return $fh; + } + + { + my $f = myopen("; + # $f implicitly closed here + } + +[TODO - this idiom needs more pod penetration] =head2 64-bit support -Better 64-bit support -- but full support still a distant goal. One -must Configure with -Duse64bits to get Configure to probe for the -extent of 64-bit support. Depending on the platform (hints file) more -or less 64-awareness becomes available. As of 5.005_54 at least -somewhat 64-bit aware platforms are HP-UX 11 or better, Solaris 2.6 or -better, IRIX 6.2 or better. Naturally 64-bit platforms like Digital -UNIX and UNICOS also have 64-bit support. +All platforms that have 64-bit integers either (a) natively as longs +or ints (b) via special compiler flags (c) using long long are able to +use "quads" (64-integers) as follows: + +=over 4 + +=item * + +constants (decimal, hexadecimal, octal, binary) in the code + +=item * + +arguments to oct() and hex() + +=item * + +arguments to print(), printf() and sprintf() (flag prefixes ll, L, q) + +=item * + +printed as such + +=item * + +pack() and unpack() "q" and "Q" formats + +=item * + +in basic arithmetics: + - * / % + +=item * + +vec() (but see the below note about bit arithmetics) + +=back + +Note that unless you have the case (a) you will have to configure +and compile Perl using the -Duse64bits Configure flag. + +Unfortunately bit arithmetics (&, |, ^, ~, <<, >>) for numbers are not +64-bit clean, they are explictly forced to be 32-bit. Bit arithmetics +for bit vectors (created by vec()) are not limited in their width. + +Last but not least: note that due to Perl's habit of always using +floating point numbers the quads are still not true integers. +When quads overflow their limits (0...18_446_744_073_709_551_615 unsigned, +-9_223_372_036_854_775_808...9_223_372_036_854_775_807 signed), they +are silently promoted to floating point numbers, after which they will +start losing precision (their lower digits). + +=head2 Large file support + +If you have filesystems that support "large files" (files larger than +2 gigabytes), you may now also be able to create and access them from +Perl. You have to use Configure -Duselargefiles. Turning on the +large file support turns on also the 64-bit support, for obvious reasons. + +Note that in addition to requiring a proper file system to do large +files you may also need to adjust your per-process (or your +per-system, or per-process-group, or per-user-group) maximum filesize +limits before running Perl scripts that try to handle large files, +especially if you intend to write such files. + +Finally, in addition to your process/process group maximum filesize +limits, you may have quota limits on your filesystems that stop you +(your user id or your user group id) from using large files. + +Adjusting your process/user/group/file system/operating system limits +is outside the scope of Perl core language. For process limits, you +may try increasing the limits using your shell's limits/limit/ulimit +command before running Perl. The BSD::Resource extension (not +included with the standard Perl distribution) may also be of use, it +offers the getrlimit/setrlimit interface that can be used to adjust +process resource usage limits, including the maximum filesize limit. + +=head2 Long doubles + +In some systems you may be able to use long doubles to enhance the +range of precision of your double precision floating point numbers +(that is, Perl's numbers). Use Configure -Duselongdouble to enable +this support (if it is available). + +=head2 "more bits" + +You can Configure -Dusemorebits to turn on both the 64-bit support +and the long double support. =head2 Better syntax checks on parenthesized unary operators Expressions such as: - print defined(&foo,&bar,&baz); - print uc("foo","bar","baz"); - undef($foo,&bar); + print defined(&foo,&bar,&baz); + print uc("foo","bar","baz"); + undef($foo,&bar); -used to be accidentally allowed in earlier versions, and produced -unpredictable behavior. Some of them produced ancillary warnings -when used in this way, while others silently did the wrong thing. +used to be accidentally allowed in earlier versions, and produced +unpredictable behaviour. Some produced ancillary warnings +when used in this way; others silently did the wrong thing. The parenthesized forms of most unary operators that expect a single -argument will now ensure that they are not called with more than one -argument, making the above cases syntax errors. Note that the usual -behavior of: +argument now ensure that they are not called with more than one +argument, making the cases shown above syntax errors. The usual +behaviour of: - print defined &foo, &bar, &baz; - print uc "foo", "bar", "baz"; - undef $foo, &bar; + print defined &foo, &bar, &baz; + print uc "foo", "bar", "baz"; + undef $foo, &bar; remains unchanged. See L. -=head1 Supported Platforms +=head2 POSIX character class syntax [: :] supported + +For example to match alphabetic characters use /[[:alpha:]]/. +See L for details. + +=head2 Improved C operator + +The C operator is now evaluated at compile time into a true list +instead of being replaced with a run time call to C. This +removes the confusing misbehaviour of C in scalar context, which +had inherited that behaviour from split(). + +Thus: + + $foo = ($bar) = qw(a b c); print "$foo|$bar\n"; + +now correctly prints "3|a", instead of "2|a". + +=head2 pack() format 'Z' supported + +The new format type 'Z' is useful for packing and unpacking null-terminated +strings. See L. + +=head2 pack() format modifier '!' supported + +The new format type modifier '!' is useful for packing and unpacking +native shorts, ints, and longs. See L. + +=head2 pack() and unpack() support counted strings + +The template character '/' can be used to specify a counted string +type to be packed or unpacked. See L. + +=head2 Comments in pack() templates + +The '#' character in a template introduces a comment up to +end of the line. This facilitates documentation of pack() +templates. + +=head2 $^X variables may now have names longer than one character + +Formerly, $^X was synonymous with ${"\cX"}, but $^XY was a syntax +error. Now variable names that begin with a control character may be +arbitrarily long. However, for compatibility reasons, these variables +I be written with explicit braces, as C<${^XY}> for example. +C<${^XYZ}> is synonymous with ${"\cXYZ"}. Variable names with more +than one control character, such as C<${^XY^Z}>, are illegal. + +The old syntax has not changed. As before, `^X' may be either a +literal control-X character or the two-character sequence `caret' plus +`X'. When braces are omitted, the variable name stops after the +control character. Thus C<"$^XYZ"> continues to be synonymous with +C<$^X . "YZ"> as before. + +As before, lexical variables may not have names beginning with control +characters. As before, variables whose names begin with a control +character are always forced to be in package `main'. All such variables +are reserved for future extensions, except those that begin with +C<^_>, which may be used by user programs and are guaranteed not to +acquire special meaning in any future version of Perl. + +=head2 C implicit in subroutine attributes + +Formerly, if you wanted to mark a subroutine as being a method call or +as requiring an automatic lock() when it is entered, you had to declare +that with a C pragma in the body of the subroutine. +That can now be accomplished with a declaration syntax, like this: + + sub mymethod : locked, method ; + ... + sub mymethod : locked, method { + ... + } + +F and F have been updated to keep the attributes +with the stubs they provide. See L. + +=head2 Regular expression improvements + +change#2827,2373,2372,2365,1813,1800,4112,4158,4215,4301 +[TODO - Ilya Zakharevich ] + +=head2 Overloading improvements + +change#2150 +[TODO - Ilya Zakharevich ] + +=head2 open() with more than two arguments + +[TODO - Ilya Zakharevich ] + +=head2 Support for interpolating named characters + +change#4052 +[TODO - Ilya Zakharevich ] + +=head2 Experimental support for user-hooks in @INC + +[TODO - Ken Fox ] + +=head2 C and C may be overridden + +C and C operations may be overridden locally +by importing subroutines of the same name into the current package +(or globally by importing them into the CORE::GLOBAL:: namespace). +Overriding C will also affect C, provided the override +is visible at compile-time. +See L. + +=head2 New variable $^C reflects C<-c> switch + +C<$^C> has a boolean value that reflects whether perl is being run +in compile-only mode (i.e. via the C<-c> switch). Since +BEGIN blocks are executed under such conditions, this variable +enables perl code to determine whether actions that make sense +only during normal running are warranted. See L. + +=head2 Optional Y2K warnings + +If Perl is built with the cpp macro C defined, +it emits optional warnings when concatenating the number 19 +with another number. + +This behavior must be specifically enabled when running Configure. +See L and L. + +=head1 Significant bug fixes + +=head2 EHANDLEE on empty files + +With C<$/> set to C, slurping an empty file returns a string of +zero length (instead of C, as it used to) the first time the +HANDLE is read. Further reads yield C. + +This means that the following will append "foo" to an empty file (it used +to do nothing): + + perl -0777 -pi -e 's/^/foo/' empty_file + +The behaviour of: + + perl -pi -e 's/^/foo/' empty_file + +is unchanged (it continues to leave the file empty). + +=head2 C improvements + +Line numbers (as reflected by caller() and most diagnostics) within +C were often incorrect when here documents were involved. +This has been corrected. + +Lexical lookups for variables appearing in C within +functions that were themselves called within an C were +searching the wrong place for lexicals. The lexical search now +correctly ends at the subroutine's block boundary. + +Parsing of here documents used to be flawed when they appeared as +the replacement expression in C. This has +been fixed. + +=head2 All compilation errors are true errors + +Some "errors" encountered at compile time were by neccessity +generated as warnings followed by eventual termination of the +program. This enabled more such errors to be reported in a +single run, rather than causing a hard stop at the first error +that was encountered. + +The mechanism for reporting such errors has been reimplemented +to queue compile-time errors and report them at the end of the +compilation as true errors rather than as warnings. This fixes +cases where error messages leaked through in the form of warnings +when code was compiled at run time using C, and +also allows such errors to be reliably trapped using __DIE__ hooks. + +=head2 Automatic flushing of output buffers + +fork(), exec(), system(), qx//, and pipe open()s now flush buffers +of all files opened for output when the operation +was attempted. This mostly eliminates confusing +buffering mishaps suffered by users unaware of how Perl internally +handles I/O. + +=head2 Better diagnostics on meaningless filehandle operations + +Constructs such as CFHE)> and CFHE)> +are compile time errors. Attempting to read from filehandles that +were opened only for writing will now produce warnings (just as +writing to read-only filehandles does). + +=head2 Where possible, buffered data discarded from duped input filehandle + +C&OLD")> now attempts to discard any data that +was previously read and buffered in C before duping the handle. +On platforms where doing this is allowed, the next read operation +on C will return the same data as the corresponding operation +on C. Formerly, it would have returned the data from the start +of the following disk block instead. + +=head2 system(), backticks and pipe open now reflect exec() failure + +On Unix and similar platforms, system(), qx() and open(FOO, "cmd |") +etc., are implemented via fork() and exec(). When the underlying +exec() fails, earlier versions did not report the error properly, +since the exec() happened to be in a different process. + +The child process now communicates with the parent about the +error in launching the external command, which allow these +constructs to return with their usual error value and set $!. + +=head2 Implicitly closed filehandles are safer + +Sometimes implicitly closed filehandles (as when they are localized, +and Perl automatically closes them on exiting the scope) could +inadvertently set $? or $!. This has been corrected. + +=head2 C<(\$)> prototype and C<$foo{a}> + +An scalar reference prototype now correctly allows a hash or +array element in that slot. + +=head2 Pseudo-hashes work better + +Dereferencing some types of reference values in a pseudo-hash, +such as C<$ph->{foo}[1]>, was accidentally disallowed. This has +been corrected. + +When applied to a pseudo-hash element, exists() now reports whether +the specified value exists, not merely if the key is valid. + +=head2 C and AUTOLOAD + +The C construct works correctly when C<&sub> happens +to be autoloaded. + +=head2 C<-bareword> allowed under C + +The autoquoting of barewords preceded by C<-> did not work +in prior versions when the C pragma was enabled. +This has been fixed. + +=head2 Boolean assignment operators are legal lvalues + +Constructs such as C<($a ||= 2) += 1> are now allowed. + +=head2 C allowed + +sort() did not accept a subroutine reference as the comparison +function in earlier versions. This is now permitted. + +=head2 Failures in DESTROY() + +When code in a destructor threw an exception, it went unnoticed +in earlier versions of Perl, unless someone happened to be +looking in $@ just after the point the destructor happened to +run. Such failures are now visible as warnings when warnings are +enabled. + +=head2 Locale bugs fixed + +printf() and sprintf() previously did reset the numeric locale +back to the default "C" locale. This has been fixed. + +Numbers formatted according to the local numeric locale +(such as using a decimal comma instead of a decimal dot) caused +"isn't numeric" warnings, even while the operations accessing +those numbers produced correct results. The warnings are gone. + +=head2 Memory leaks + +The C construct could sometimes leak +memory. This has been fixed. + +Operations that aren't filehandle constructors used to leak memory +when used on invalid filehandles. This has been fixed. + +Constructs that modified C<@_> could fail to deallocate values +in C<@_> and thus leak memory. This has been corrected. + +=head2 Spurious subroutine stubs after failed subroutine calls + +Perl could sometimes create empty subroutine stubs when a +subroutine was not found in the package. Such cases stopped +later method lookups from progressing into base packages. +This has been corrected. + +=head2 Consistent numeric conversions + +change#3378,3318 +[TODO - Ilya Zakharevich ] + +=head2 Taint failures under C<-U> + +When running in unsafe mode, taint violations could sometimes +cause silent failures. This has been fixed. + +=head2 END blocks and the C<-c> switch + +Prior versions used to run BEGIN B END blocks when Perl was +run in compile-only mode. Since this is typically not the expected +behavior, END blocks are not executed anymore when the C<-c> switch +is used. + +Note that something resembling the previous behavior can still be +obtained by putting C token creates an implicit filehandle to +the file that contains the token. It is the program's +responsibility to close it when it is done reading from it. + +This caveat is now better explained in the documentation. +See L. + +=head2 Diagnostics follow STDERR + +Diagnostic output now goes to whichever file the C handle +is pointing at, instead of always going to the underlying C runtime +library's C. + +=head2 Other fixes for better diagnostics + +Line numbers are suppressed no more (under most likely circumstances) +during the global destruction phase. + +Diagnostics emitted from code running in threads other than the main +thread are now accompanied by the thread ID. + +Embedded null characters in diagnostics now actually show up. They +used to truncate the message in prior versions. + +$foo::a and $foo::b are now exempt from "possible typo" warnings only +if sort() is encountered in package foo. + +Unrecognized alphabetic escapes encountered when parsing quoting +constructs now generate a warning, since they may take on new +semantics in later versions of Perl. + +=head1 Performance enhancements + +=head2 Simple sort() using { $a <=> $b } and the like are optimized + +Many common sort() operations using a simple inlined block are now +optimized for faster performance. + +=head2 Optimized assignments to lexical variables + +Certain operations in the RHS of assignment statements have been +optimized to directly set the lexical variable on the LHS, +eliminating redundant copying overheads. + +=head2 Method lookups optimized + +[TODO - Chip Salzenberg ] + +=head2 Faster mechanism to invoke XSUBs + +change#4044,4125 +[TODO - Ilya Zakharevich ] + +=head2 Perl_malloc() improvements + +change#4237 +[TODO - Ilya Zakharevich ] + +=head2 Faster subroutine calls + +Minor changes in how subroutine calls are handled internally +provide marginal improvements in performance. + +=head1 Platform specific changes + +=head2 Additional supported platforms =over 4 @@ -95,38 +863,98 @@ VM/ESA is now supported. =item * -Siemens BS200 is now supported. +Siemens BS2000 is now supported under the POSIX Shell. + +=item * + +The Mach CThreads (NEXTSTEP, OPENSTEP) are now supported by the Thread +extension. + +=item * + +GNU/Hurd is now supported. + +=item * + +Rhapsody is now supported. =item * -The Mach CThreads (NeXTstep) are now supported by the Thread extension. +EPOC is is now supported (on Psion 5). =back +=head2 DOS + +[TODO - Laszlo Molnar ] + +=head2 OS/2 + +[TODO - Ilya Zakharevich ] + +=head2 VMS + +[TODO - Charles Bailey ] + +=head2 Win32 + +Site library searches failed to look for ".../site/5.XXX/lib" +if ".../site/5.XXXYY/lib" wasn't found. This has been corrected. + +When given a pathname that consists only of a drivename, such +as C, opendir() and stat() now use the current working +directory for the drive rather than the drive root. + +The builtin XSUB functions in the Win32:: namespace are +documented. See L. + +$^X now contains the full path name of the running executable. + +A Win32::GetLongPathName() function is provided to complement +Win32::GetFullPathName() and Win32::GetShortPathName(). See L. + +POSIX::uname() is supported. + +system(1,...) now returns true process IDs rather than process +handles. kill() accepts any real process id, rather than strictly +return values from system(1,...). + +The C module is supported. + +[TODO - GSAR] + =head1 New tests =over 4 -=item op/io_const +=item lib/attrs + +Compatibility tests for C vs the older C. + +=item lib/io_const IO constants (SEEK_*, _IO*). - -=item op/io_dir + +=item lib/io_dir Directory-related IO methods (new, read, close, rewind, tied delete). -=item op/io_multihomed +=item lib/io_multihomed INET sockets with multi-homed hosts. -=item op/io_poll +=item lib/io_poll IO poll(). -=item op/io_unix +=item lib/io_unix UNIX sockets. +=item op/attrs + +Regression tests for C and . + =item op/filetest File test operators. @@ -143,49 +971,275 @@ Verify operations that access pad objects (lexicals and temporaries). =over 4 +=item attributes + +While used internally by Perl as a pragma, this module also +provides a way to fetch subroutine and variable attributes. +See L. + +=item B + +[TODO - Vishal Bhatia , +Nick Ing-Simmons ] + +=item ByteLoader + +The ByteLoader is a dedicated extension to generate and run +Perl bytecode. See L. + +=item B + +The Perl Compiler suite has been extensively reworked for this +release. + +=item constant + +References can now be used. See L. + +=item charnames + +change#4052 +[TODO - Ilya Zakharevich ] + +=item Data::Dumper + +A C setting can be specified to avoid venturing +too deeply into data structures that may be very deep. +See L. + +Dumping C objects works correctly. + +=item DB + +C is an experimental module that exposes a clean abstraction +to Perl's debugging API. + +=item DB_File + +[TODO - Paul Marquess ] + +=item Devel::DProf + +Devel::DProf, a Perl source code profiler has been added. See L. + =item Dumpvalue Added Dumpvalue module provides screen dumps of Perl data. =item Benchmark -You can now run tests for I seconds instead of guessing the right -number of tests to run. +You can now run tests for I seconds instead of guessing the right +number of tests to run: e.g. timethese(-5, ...) will run each +code for at least 5 CPU seconds. Zero as the "number of repetitions" +means "for at least 3 CPU seconds". The output format has also +changed. For example: + +use Benchmark;$x=3;timethese(-5,{a=>sub{$x*$x},b=>sub{$x**2}}) + +will now output something like this: + +Benchmark: running a, b, each for at least 5 CPU seconds... + a: 5 wallclock secs ( 5.77 usr + 0.00 sys = 5.77 CPU) @ 200551.91/s (n=1156516) + b: 4 wallclock secs ( 5.00 usr + 0.02 sys = 5.02 CPU) @ 159605.18/s (n=800686) + +New features: "each for at least N CPU seconds...", "wallclock secs", +and the "@ operations/CPU second (n=operations)". + +change#4265,4266,4292 +[TODO - Barrie Slaymaker ] + +=item Devel::Peek + +The Devel::Peek module provides access to the internal representation +of Perl variables and data. It is a data debugging tool for the XS programmer. + +=item ExtUtils::MakeMaker + +change#4135, also needs docs in module pod +[TODO - Ilya Zakharevich ] =item Fcntl More Fcntl constants added: F_SETLK64, F_SETLKW64, O_LARGEFILE for -large (more than 4G) file access (the 64-bit support is not yet +large (more than 4G) file access (64-bit support is not yet working, though, so no need to get overly excited), Free/Net/OpenBSD locking behaviour flags F_FLOCK, F_POSIX, Linux F_SHLCK, and O_ACCMODE: the mask of O_RDONLY, O_WRONLY, and O_RDWR. +=item File::Compare + +A compare_text() function has been added, which allows custom +comparison functions. See L. + +=item File::Find + +File::Find now works correctly when the wanted() function is either +autoloaded or is a symbolic reference. + +A bug that caused File::Find to lose track of the working directory +when pruning top-level directories has been fixed. + +=item File::Spec + +New methods have been added to the File::Spec module: devnull() returns +the name of the null device (/dev/null on Unix) and tmpdir() the name of +the temp directory (normally /tmp on Unix). There are now also methods +to convert between absolute and relative filenames: abs2rel() and +rel2abs(). For compatibility with operating systems that specify volume +names in file paths, the splitpath(), splitdir(), and catdir() methods +have been added. + +=item File::Spec::Functions + +The new File::Spec::Functions modules provides a function interface +to the File::Spec module. Allows shorthand + + $fullname = catfile($dir1, $dir2, $file); + +instead of + + $fullname = File::Spec->catfile($dir1, $dir2, $file); + +=item Getopt::Long + +[TODO - Johan Vromans ] + +=item IO + +write() and syswrite() will now accept a single-argument +form of the call, for consistency with Perl's syswrite(). + +You can now create a TCP-based IO::Socket::INET without forcing +a connect attempt. This allows you to configure its options +(like making it non-blocking) and then call connect() manually. + +A bug that prevented the IO::Socket::protocol() accessor +from ever returning the correct value has been corrected. + +=item JPL + +Java Perl Lingo is now distributed with Perl. See jpl/README +for more information. + +=item Math::BigInt + +The logical operations CE>, CE>, C<&>, C<|>, +and C<~> are now supported on bigints. + =item Math::Complex - -The accessors methods Re, Im, arg, abs, rho, theta, methods can -($z->Re()) now also act as mutators ($z->Re(3)). + +The accessor methods Re, Im, arg, abs, rho, and theta can now also +act as mutators (accessor $z->Re(), mutator $z->Re(3)). =item Math::Trig -A little bit of radial trigonometry (cylindrical and spherical) added, -for example the great circle distance. +A little bit of radial trigonometry (cylindrical and spherical), +radial coordinate conversions, and the great circle distance were added. + +=item Pod::Parser + +[TODO - Brad Appleton ] + +=item Pod::Text and Pod::Man + +[TODO - Russ Allbery ] + +=item SDBM_File + +An EXISTS method has been added to this module (and sdbm_exists() has +been added to the underlying sdbm library), so one can now call exists +on an SDBM_File tied hash and get the correct result, rather than a +runtime error. + +A bug that may have caused data loss when more than one disk block +happens to be read from the database in a single FETCH() has been +fixed. + +=item Time::Local + +The timelocal() and timegm() functions used to silently return bogus +results when the date exceeded the machine's integer range. They +now consistently croak() if the date falls in an unsupported range. + +=item Win32 + +The error return value in list context has been changed for all functions +that return a list of values. Previously these functions returned a list +with a single element C if an error occurred. Now these functions +return the empty list in these situations. This applies to the following +functions: + + Win32::FsType + Win32::GetOSVersion + +The remaining functions are unchanged and continue to return C on +error even in list context. + +The Win32::SetLastError(ERROR) function has been added as a complement +to the Win32::GetLastError() function. + +The new Win32::GetFullPathName(FILENAME) returns the full absolute +pathname for FILENAME in scalar context. In list context it returns +a two-element list containing the fully qualified directory name and +the filename. + +=item DBM Filters + +A new feature called "DBM Filters" has been added to all the +DBM modules--DB_File, GDBM_File, NDBM_File, ODBM_File, and SDBM_File. +DBM Filters add four new methods to each DBM module: + + filter_store_key + filter_store_value + filter_fetch_key + filter_fetch_value + +These can be used to filter key-value pairs before the pairs are +written to the database or just after they are read from the database. +See L for further information. =back =head2 Pragmata -Lexical warnings pragma, "use warning;", to control optional warnings. +C is now obsolescent, and is only provided for +backward-compatibility. It's been replaced by the C +syntax. See L and L. + +C to enable UTF-8 and Unicode support. + +C allows modules to inherit pragmatic attributes +from the caller's context. C is currently the only supported +attribute. -Filetest pragma, to control the behaviour of filetests (C<-r> C<-w> ...). -Currently only one subpragma implemented, "use filetest 'access';", -that enables the use of access(2) or equivalent to check the -permissions instead of using stat(2) as usual. This matters -in filesystems where there are ACLs (access control lists), the -stat(2) might lie, while access(2) knows better. +Lexical warnings pragma, C, to control optional warnings. +See L. + +C to control the behaviour of filetests (C<-r> C<-w> +...). Currently only one subpragma implemented, "use filetest +'access';", that uses access(2) or equivalent to check permissions +instead of using stat(2) as usual. This matters in filesystems +where there are ACLs (access control lists): the stat(2) might lie, +but access(2) knows better. =head1 Utility Changes -Todo. +=head2 h2ph + +[TODO - Kurt Starsinic ] + +=head2 perlcc + +C now supports the C and Bytecode backends. By default, +it generates output from the simple C backend rather than the +optimized C backend. + +Support for non-Unix platforms has been improved. + +=head2 h2xs + +change#4232 +[TODO - Ilya Zakharevich ] =head1 Documentation Changes @@ -199,48 +1253,160 @@ A tutorial on using open() effectively. A tutorial that introduces the essentials of references. +=item perltootc.pod + +A tutorial on managing class data for object modules. + +=item perlcompile.pod + +An introduction to using the Perl Compiler suite. + =back =head1 New Diagnostics +=item "my sub" not yet implemented + +(F) Lexically scoped subroutines are not yet implemented. Don't try that +yet. + +=item %s package attribute may clash with future reserved word: %s + +(W) A lowercase attribute name was used that had a package-specific handler. +That name might have a meaning to Perl itself some day, even though it +doesn't yet. Perhaps you should use a mixed-case attribute name, instead. +See L. + =item /%s/: Unrecognized escape \\%c passed through (W) You used a backslash-character combination which is not recognized -by Perl. This combination appears in an interpolated variable or a +by Perl. This combination appears in an interpolated variable or a C<'>-delimited regular expression. -=item Unrecognized escape \\%c passed through +=item Filehandle %s opened only for output -(W) You used a backslash-character combination which is not recognized -by Perl. +(W) You tried to read from a filehandle opened only for writing. If you +intended it to be a read-write filehandle, you needed to open it with +"+E" or "+E" or "+EE" instead of with "E" or nothing. If +you intended only to read from the file, use "E". See +L. + +=item Invalid %s attribute: %s + +The indicated attribute for a subroutine or variable was not recognized +by Perl or by a user-supplied handler. See L. + +=item Invalid %s attributes: %s + +The indicated attributes for a subroutine or variable were not recognized +by Perl or by a user-supplied handler. See L. + +=item Invalid separator character %s in attribute list + +(F) Something other than a comma or whitespace was seen between the +elements of an attribute list. If the previous attribute +had a parenthesised parameter list, perhaps that list was terminated +too soon. See L. =item Missing command in piped open (W) You used the C or C construction, but the command was missing or blank. -=head1 Obsolete Diagnostics +=item Missing name in "my sub" -Todo. +(F) The reserved syntax for lexically scoped subroutines requires that they +have a name with which they can be found. -=head1 Configuration Changes +=item Unrecognized escape \\%c passed through -You can use "Configure -Uinstallusrbinperl" which causes installperl -to skip installing perl also as /usr/bin/perl. This is useful if you -prefer not to modify /usr/bin for some reason or another but harmful -because many scripts assume to find Perl in /usr/bin/perl. +(W) You used a backslash-character combination which is not recognized +by Perl. + +=item Unterminated attribute parameter in attribute list + +(F) The lexer saw an opening (left) parenthesis character while parsing an +attribute list, but the matching closing (right) parenthesis +character was not found. You may need to add (or remove) a backslash +character to get your parentheses to balance. See L. + +=item Unterminated attribute list + +(F) The lexer found something other than a simple identifier at the start +of an attribute, and it wasn't a semicolon or the start of a +block. Perhaps you terminated the parameter list of the previous attribute +too soon. See L. + +=item defined(@array) is deprecated + +(D) defined() is not usually useful on arrays because it checks for an +undefined I value. If you want to see if the array is empty, +just use C for example. + +=item defined(%hash) is deprecated + +(D) defined() is not usually useful on hashes because it checks for an +undefined I value. If you want to see if the hash is empty, +just use C for example. + +=item Invalid separator character %s in subroutine attribute list + +(F) Something other than a comma or whitespace was seen between the +elements of a subroutine attribute list. If the previous attribute +had a parenthesised parameter list, perhaps that list was terminated +too soon. + +=item Possible Y2K bug: %s + +(W) You are concatenating the number 19 with another number, which +could be a potential Year 2000 problem. + +=item Unterminated attribute parameter in subroutine attribute list + +(F) The lexer saw an opening (left) parenthesis character while parsing a +subroutine attribute list, but the matching closing (right) parenthesis +character was not found. You may need to add (or remove) a backslash +character to get your parentheses to balance. + +=item Unterminated subroutine attribute list + +(F) The lexer found something other than a simple identifier at the start +of a subroutine attribute, and it wasn't a semicolon or the start of a +block. Perhaps you terminated the parameter list of the previous attribute +too soon. + +=item /%s/ should probably be written as "%s" + +(W) You have used a pattern where Perl expected to find a string, +like in the first argument to C. Perl will treat the true +or false result of matching the pattern against $_ as the string, +which is probably not what you had in mind. + +=item %s() called too early to check prototype + +(W) You've called a function that has a prototype before the parser saw a +definition or declaration for it, and Perl could not check that the call +conforms to the prototype. You need to either add an early prototype +declaration for the subroutine in question, or move the subroutine +definition ahead of the call to get proper prototype checking. Alternatively, +if you are certain that you're calling the function correctly, you may put +an ampersand before the name to avoid the warning. See L. + +=head1 Obsolete Diagnostics + +Todo. =head1 BUGS If you find what you think is a bug, you might check the headers of -recently posted articles in the comp.lang.perl.misc newsgroup. +articles recently posted to the comp.lang.perl.misc newsgroup. There may also be information at http://www.perl.com/perl/, the Perl Home Page. If you believe you have an unreported bug, please run the B -program included with your release. Make sure you trim your bug down +program included with your release. Make sure to trim your bug down to a tiny but sufficient test case. Your bug report, along with the -output of C, will be sent off to > to be +output of C, will be sent off to perlbug@perl.com to be analysed by the Perl porting team. =head1 SEE ALSO @@ -255,8 +1421,8 @@ The F and F files for copyright information. =head1 HISTORY -Written by Gurusamy Sarathy >, with many contributions -from The Perl Porters. +Written by Gurusamy Sarathy >, with many +contributions from The Perl Porters. Send omissions or corrections to >.