diff options
Diffstat (limited to 'upstream/fedora-40/man1/perl56delta.1')
| -rw-r--r-- | upstream/fedora-40/man1/perl56delta.1 | 2870 |
1 files changed, 2870 insertions, 0 deletions
diff --git a/upstream/fedora-40/man1/perl56delta.1 b/upstream/fedora-40/man1/perl56delta.1 new file mode 100644 index 00000000..f9bbec81 --- /dev/null +++ b/upstream/fedora-40/man1/perl56delta.1 @@ -0,0 +1,2870 @@ +.\" -*- mode: troff; coding: utf-8 -*- +.\" Automatically generated by Pod::Man 5.01 (Pod::Simple 3.43) +.\" +.\" Standard preamble: +.\" ======================================================================== +.de Sp \" Vertical space (when we can't use .PP) +.if t .sp .5v +.if n .sp +.. +.de Vb \" Begin verbatim text +.ft CW +.nf +.ne \\$1 +.. +.de Ve \" End verbatim text +.ft R +.fi +.. +.\" \*(C` and \*(C' are quotes in nroff, nothing in troff, for use with C<>. +.ie n \{\ +. ds C` "" +. ds C' "" +'br\} +.el\{\ +. ds C` +. ds C' +'br\} +.\" +.\" Escape single quotes in literal strings from groff's Unicode transform. +.ie \n(.g .ds Aq \(aq +.el .ds Aq ' +.\" +.\" If the F register is >0, we'll generate index entries on stderr for +.\" titles (.TH), headers (.SH), subsections (.SS), items (.Ip), and index +.\" entries marked with X<> in POD. Of course, you'll have to process the +.\" output yourself in some meaningful fashion. +.\" +.\" Avoid warning from groff about undefined register 'F'. +.de IX +.. +.nr rF 0 +.if \n(.g .if rF .nr rF 1 +.if (\n(rF:(\n(.g==0)) \{\ +. if \nF \{\ +. de IX +. tm Index:\\$1\t\\n%\t"\\$2" +.. +. if !\nF==2 \{\ +. nr % 0 +. nr F 2 +. \} +. \} +.\} +.rr rF +.\" ======================================================================== +.\" +.IX Title "PERL56DELTA 1" +.TH PERL56DELTA 1 2024-01-25 "perl v5.38.2" "Perl Programmers Reference Guide" +.\" For nroff, turn off justification. Always turn off hyphenation; it makes +.\" way too many mistakes in technical documents. +.if n .ad l +.nh +.SH NAME +perl56delta \- what's new for perl v5.6.0 +.SH DESCRIPTION +.IX Header "DESCRIPTION" +This document describes differences between the 5.005 release and the 5.6.0 +release. +.SH "Core Enhancements" +.IX Header "Core Enhancements" +.SS "Interpreter cloning, threads, and concurrency" +.IX Subsection "Interpreter cloning, threads, and concurrency" +Perl 5.6.0 introduces the beginnings of support for running multiple +interpreters concurrently in different threads. In conjunction with +the \fBperl_clone()\fR API call, which can be used to selectively duplicate +the state of any given interpreter, it is possible to compile a +piece of code once in an interpreter, clone that interpreter +one or more times, and run all the resulting interpreters in distinct +threads. +.PP +On the Windows platform, this feature is used to emulate \fBfork()\fR at the +interpreter level. See perlfork for details about that. +.PP +This feature is still in evolution. It is eventually meant to be used +to selectively clone a subroutine and data reachable from that +subroutine in a separate interpreter and run the cloned subroutine +in a separate thread. Since there is no shared data between the +interpreters, little or no locking will be needed (unless parts of +the symbol table are explicitly shared). This is obviously intended +to be an easy-to-use replacement for the existing threads support. +.PP +Support for cloning interpreters and interpreter concurrency can be +enabled using the \-Dusethreads Configure option (see win32/Makefile for +how to enable it on Windows.) The resulting perl executable will be +functionally identical to one that was built with \-Dmultiplicity, but +the \fBperl_clone()\fR API call will only be available in the former. +.PP +\&\-Dusethreads enables the cpp macro USE_ITHREADS by default, which in turn +enables Perl source code changes that provide a clear separation between +the op tree and the data it operates with. The former is immutable, and +can therefore be shared between an interpreter and all of its clones, +while the latter is considered local to each interpreter, and is therefore +copied for each clone. +.PP +Note that building Perl with the \-Dusemultiplicity Configure option +is adequate if you wish to run multiple \fBindependent\fR interpreters +concurrently in different threads. \-Dusethreads only provides the +additional functionality of the \fBperl_clone()\fR API call and other +support for running \fBcloned\fR interpreters concurrently. +.PP +.Vb 2 +\& NOTE: This is an experimental feature. Implementation details are +\& subject to change. +.Ve +.SS "Lexically scoped warning categories" +.IX Subsection "Lexically scoped warning categories" +You can now control the granularity of warnings emitted by perl at a finer +level using the \f(CW\*(C`use warnings\*(C'\fR pragma. warnings and perllexwarn +have copious documentation on this feature. +.SS "Unicode and UTF\-8 support" +.IX Subsection "Unicode and UTF-8 support" +Perl now uses UTF\-8 as its internal representation for character +strings. The \f(CW\*(C`utf8\*(C'\fR and \f(CW\*(C`bytes\*(C'\fR pragmas are used to control this support +in the current lexical scope. See perlunicode, utf8 and bytes for +more information. +.PP +This feature is expected to evolve quickly to support some form of I/O +disciplines that can be used to specify the kind of input and output data +(bytes or characters). Until that happens, additional modules from CPAN +will be needed to complete the toolkit for dealing with Unicode. +.PP +.Vb 2 +\& NOTE: This should be considered an experimental feature. Implementation +\& details are subject to change. +.Ve +.SS "Support for interpolating named characters" +.IX Subsection "Support for interpolating named characters" +The new \f(CW\*(C`\eN\*(C'\fR escape interpolates named characters within strings. +For example, \f(CW"Hi! \eN{WHITE SMILING FACE}"\fR evaluates to a string +with a unicode smiley face at the end. +.SS """our"" declarations" +.IX Subsection """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 +package that was current where the variable was declared. This is +mostly useful as an alternative to the \f(CW\*(C`vars\*(C'\fR pragma, but also provides +the opportunity to introduce typing and other attributes for such +variables. See "our" in perlfunc. +.SS "Support for strings represented as a vector of ordinals" +.IX Subsection "Support for strings represented as a vector of ordinals" +Literals of the form \f(CW\*(C`v1.2.3.4\*(C'\fR are now parsed as a string composed +of characters with the specified ordinals. This is an alternative, more +readable way to construct (possibly unicode) strings instead of +interpolating characters, as in \f(CW"\ex{1}\ex{2}\ex{3}\ex{4}"\fR. The leading +\&\f(CW\*(C`v\*(C'\fR may be omitted if there are more than two ordinals, so \f(CW1.2.3\fR is +parsed the same as \f(CW\*(C`v1.2.3\*(C'\fR. +.PP +Strings written in this form are also useful to represent version "numbers". +It is easy to compare such version "numbers" (which are really just plain +strings) using any of the usual string comparison operators \f(CW\*(C`eq\*(C'\fR, \f(CW\*(C`ne\*(C'\fR, +\&\f(CW\*(C`lt\*(C'\fR, \f(CW\*(C`gt\*(C'\fR, etc., or perform bitwise string operations on them using \f(CW\*(C`|\*(C'\fR, +\&\f(CW\*(C`&\*(C'\fR, etc. +.PP +In conjunction with the new \f(CW$^V\fR magic variable (which contains +the perl version as a string), such literals can be used as a readable way +to check if you're running a particular version of Perl: +.PP +.Vb 4 +\& # this will parse in older versions of Perl also +\& if ($^V and $^V gt v5.6.0) { +\& # new features supported +\& } +.Ve +.PP +\&\f(CW\*(C`require\*(C'\fR and \f(CW\*(C`use\*(C'\fR also have some special magic to support such +literals, but this particular usage should be avoided because it leads to +misleading error messages under versions of Perl which don't support vector +strings. Using a true version number will ensure correct behavior in all +versions of Perl: +.PP +.Vb 2 +\& require 5.006; # run time check for v5.6 +\& use 5.006_001; # compile time check for v5.6.1 +.Ve +.PP +Also, \f(CW\*(C`sprintf\*(C'\fR and \f(CW\*(C`printf\*(C'\fR support the Perl-specific format flag \f(CW%v\fR +to print ordinals of characters in arbitrary strings: +.PP +.Vb 3 +\& printf "v%vd", $^V; # prints current version, such as "v5.5.650" +\& printf "%*vX", ":", $addr; # formats IPv6 address +\& printf "%*vb", " ", $bits; # displays bitstring +.Ve +.PP +See "Scalar value constructors" in perldata for additional information. +.SS "Improved Perl version numbering system" +.IX Subsection "Improved Perl version numbering system" +Beginning with Perl version 5.6.0, the version number convention has been +changed to a "dotted integer" scheme that is more commonly found in open +source projects. +.PP +Maintenance versions of v5.6.0 will be released as v5.6.1, v5.6.2 etc. +The next development series following v5.6.0 will be numbered v5.7.x, +beginning with v5.7.0, and the next major production release following +v5.6.0 will be v5.8.0. +.PP +The English module now sets \f(CW$PERL_VERSION\fR to $^V (a string value) rather +than \f(CW$]\fR (a numeric value). (This is a potential incompatibility. +Send us a report via perlbug if you are affected by this.) +.PP +The v1.2.3 syntax is also now legal in Perl. +See "Support for strings represented as a vector of ordinals" for more on that. +.PP +To cope with the new versioning system's use of at least three significant +digits for each version component, the method used for incrementing the +subversion number has also changed slightly. We assume that versions older +than v5.6.0 have been incrementing the subversion component in multiples of +10. Versions after v5.6.0 will increment them by 1. Thus, using the new +notation, 5.005_03 is the "same" as v5.5.30, and the first maintenance +version following v5.6.0 will be v5.6.1 (which should be read as being +equivalent to a floating point value of 5.006_001 in the older format, +stored in \f(CW$]\fR). +.SS "New syntax for declaring subroutine attributes" +.IX Subsection "New syntax for declaring subroutine attributes" +Formerly, if you wanted to mark a subroutine as being a method call or +as requiring an automatic \fBlock()\fR when it is entered, you had to declare +that with a \f(CW\*(C`use attrs\*(C'\fR pragma in the body of the subroutine. +That can now be accomplished with declaration syntax, like this: +.PP +.Vb 5 +\& sub mymethod : locked method; +\& ... +\& sub mymethod : locked method { +\& ... +\& } +\& +\& sub othermethod :locked :method; +\& ... +\& sub othermethod :locked :method { +\& ... +\& } +.Ve +.PP +(Note how only the first \f(CW\*(C`:\*(C'\fR is mandatory, and whitespace surrounding +the \f(CW\*(C`:\*(C'\fR is optional.) +.PP +\&\fIAutoSplit.pm\fR and \fISelfLoader.pm\fR have been updated to keep the attributes +with the stubs they provide. See attributes. +.SS "File and directory handles can be autovivified" +.IX Subsection "File and directory handles can be autovivified" +Similar to how constructs such as \f(CW\*(C`$x\->[0]\*(C'\fR autovivify a reference, +handle constructors (\fBopen()\fR, \fBopendir()\fR, \fBpipe()\fR, \fBsocketpair()\fR, \fBsysopen()\fR, +\&\fBsocket()\fR, and \fBaccept()\fR) now autovivify a file or directory handle +if the handle passed to them is an uninitialized scalar variable. This +allows the constructs such as \f(CW\*(C`open(my $fh, ...)\*(C'\fR and \f(CW\*(C`open(local $fh,...)\*(C'\fR +to be used to create filehandles that will conveniently be closed +automatically when the scope ends, provided there are no other references +to them. This largely eliminates the need for typeglobs when opening +filehandles that must be passed around, as in the following example: +.PP +.Vb 5 +\& sub myopen { +\& open my $fh, "@_" +\& or die "Can\*(Aqt open \*(Aq@_\*(Aq: $!"; +\& return $fh; +\& } +\& +\& { +\& my $f = myopen("</etc/motd"); +\& print <$f>; +\& # $f implicitly closed here +\& } +.Ve +.SS "\fBopen()\fP with more than two arguments" +.IX Subsection "open() with more than two arguments" +If \fBopen()\fR is passed three arguments instead of two, the second argument +is used as the mode and the third argument is taken to be the file name. +This is primarily useful for protecting against unintended magic behavior +of the traditional two-argument form. See "open" in perlfunc. +.SS "64\-bit support" +.IX Subsection "64-bit support" +Any platform that has 64\-bit integers either +.PP +.Vb 3 +\& (1) natively as longs or ints +\& (2) via special compiler flags +\& (3) using long long or int64_t +.Ve +.PP +is able to use "quads" (64\-bit integers) as follows: +.IP \(bu 4 +constants (decimal, hexadecimal, octal, binary) in the code +.IP \(bu 4 +arguments to \fBoct()\fR and \fBhex()\fR +.IP \(bu 4 +arguments to \fBprint()\fR, \fBprintf()\fR and \fBsprintf()\fR (flag prefixes ll, L, q) +.IP \(bu 4 +printed as such +.IP \(bu 4 +\&\fBpack()\fR and \fBunpack()\fR "q" and "Q" formats +.IP \(bu 4 +in basic arithmetics: + \- * / % (NOTE: operating close to the limits +of the integer values may produce surprising results) +.IP \(bu 4 +in bit arithmetics: & | ^ ~ << >> (NOTE: these used to be forced +to be 32 bits wide but now operate on the full native width.) +.IP \(bu 4 +\&\fBvec()\fR +.PP +Note that unless you have the case (a) you will have to configure +and compile Perl using the \-Duse64bitint Configure flag. +.PP +.Vb 2 +\& NOTE: The Configure flags \-Duselonglong and \-Duse64bits have been +\& deprecated. Use \-Duse64bitint instead. +.Ve +.PP +There are actually two modes of 64\-bitness: the first one is achieved +using Configure \-Duse64bitint and the second one using Configure +\&\-Duse64bitall. The difference is that the first one is minimal and +the second one maximal. The first works in more places than the second. +.PP +The \f(CW\*(C`use64bitint\*(C'\fR does only as much as is required to get 64\-bit +integers into Perl (this may mean, for example, using "long longs") +while your memory may still be limited to 2 gigabytes (because your +pointers could still be 32\-bit). Note that the name \f(CW\*(C`64bitint\*(C'\fR does +not imply that your C compiler will be using 64\-bit \f(CW\*(C`int\*(C'\fRs (it might, +but it doesn't have to): the \f(CW\*(C`use64bitint\*(C'\fR means that you will be +able to have 64 bits wide scalar values. +.PP +The \f(CW\*(C`use64bitall\*(C'\fR goes all the way by attempting to switch also +integers (if it can), longs (and pointers) to being 64\-bit. This may +create an even more binary incompatible Perl than \-Duse64bitint: the +resulting executable may not run at all in a 32\-bit box, or you may +have to reboot/reconfigure/rebuild your operating system to be 64\-bit +aware. +.PP +Natively 64\-bit systems like Alpha and Cray need neither \-Duse64bitint +nor \-Duse64bitall. +.PP +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 (in their lower digits). +.PP +.Vb 4 +\& NOTE: 64\-bit support is still experimental on most platforms. +\& Existing support only covers the LP64 data model. In particular, the +\& LLP64 data model is not yet supported. 64\-bit libraries and system +\& APIs on many platforms have not stabilized\-\-your mileage may vary. +.Ve +.SS "Large file support" +.IX Subsection "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. +.PP +.Vb 2 +\& NOTE: The default action is to enable large file support, if +\& available on the platform. +.Ve +.PP +If the large file support is on, and you have a Fcntl constant +O_LARGEFILE, the O_LARGEFILE is automatically added to the flags +of \fBsysopen()\fR. +.PP +Beware that unless your filesystem also supports "sparse files" seeking +to umpteen petabytes may be inadvisable. +.PP +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. +.PP +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. +.PP +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. +.SS "Long doubles" +.IX Subsection "Long doubles" +In some systems you may be able to use long doubles to enhance the +range and precision of your double precision floating point numbers +(that is, Perl's numbers). Use Configure \-Duselongdouble to enable +this support (if it is available). +.SS """more bits""" +.IX Subsection """more bits""" +You can "Configure \-Dusemorebits" to turn on both the 64\-bit support +and the long double support. +.SS "Enhanced support for \fBsort()\fP subroutines" +.IX Subsection "Enhanced support for sort() subroutines" +Perl subroutines with a prototype of \f(CW\*(C`($$)\*(C'\fR, and XSUBs in general, can +now be used as sort subroutines. In either case, the two elements to +be compared are passed as normal parameters in \f(CW@_\fR. See "sort" in perlfunc. +.PP +For unprototyped sort subroutines, the historical behavior of passing +the elements to be compared as the global variables \f(CW$a\fR and \f(CW$b\fR remains +unchanged. +.ie n .SS """sort $coderef @foo"" allowed" +.el .SS "\f(CWsort $coderef @foo\fP allowed" +.IX Subsection "sort $coderef @foo allowed" +\&\fBsort()\fR did not accept a subroutine reference as the comparison +function in earlier versions. This is now permitted. +.SS "File globbing implemented internally" +.IX Subsection "File globbing implemented internally" +Perl now uses the File::Glob implementation of the \fBglob()\fR operator +automatically. This avoids using an external csh process and the +problems associated with it. +.PP +.Vb 2 +\& NOTE: This is currently an experimental feature. Interfaces and +\& implementation are subject to change. +.Ve +.SS "Support for CHECK blocks" +.IX Subsection "Support for CHECK blocks" +In addition to \f(CW\*(C`BEGIN\*(C'\fR, \f(CW\*(C`INIT\*(C'\fR, \f(CW\*(C`END\*(C'\fR, \f(CW\*(C`DESTROY\*(C'\fR and \f(CW\*(C`AUTOLOAD\*(C'\fR, +subroutines named \f(CW\*(C`CHECK\*(C'\fR are now special. These are queued up during +compilation and behave similar to END blocks, except they are called at +the end of compilation rather than at the end of execution. They cannot +be called directly. +.SS "POSIX character class syntax [: :] supported" +.IX Subsection "POSIX character class syntax [: :] supported" +For example to match alphabetic characters use /[[:alpha:]]/. +See perlre for details. +.SS "Better pseudo-random number generator" +.IX Subsection "Better pseudo-random number generator" +In 5.005_0x and earlier, perl's \fBrand()\fR function used the C library +\&\fBrand\fR\|(3) function. As of 5.005_52, Configure tests for \fBdrand48()\fR, +\&\fBrandom()\fR, and \fBrand()\fR (in that order) and picks the first one it finds. +.PP +These changes should result in better random numbers from \fBrand()\fR. +.ie n .SS "Improved ""qw//"" operator" +.el .SS "Improved \f(CWqw//\fP operator" +.IX Subsection "Improved qw// operator" +The \f(CW\*(C`qw//\*(C'\fR operator is now evaluated at compile time into a true list +instead of being replaced with a run time call to \f(CWsplit()\fR. This +removes the confusing misbehaviour of \f(CW\*(C`qw//\*(C'\fR in scalar context, which +had inherited that behaviour from \fBsplit()\fR. +.PP +Thus: +.PP +.Vb 1 +\& $foo = ($bar) = qw(a b c); print "$foo|$bar\en"; +.Ve +.PP +now correctly prints "3|a", instead of "2|a". +.SS "Better worst-case behavior of hashes" +.IX Subsection "Better worst-case behavior of hashes" +Small changes in the hashing algorithm have been implemented in +order to improve the distribution of lower order bits in the +hashed value. This is expected to yield better performance on +keys that are repeated sequences. +.SS "\fBpack()\fP format 'Z' supported" +.IX Subsection "pack() format 'Z' supported" +The new format type 'Z' is useful for packing and unpacking null-terminated +strings. See "pack" in perlfunc. +.SS "\fBpack()\fP format modifier '!' supported" +.IX Subsection "pack() format modifier '!' supported" +The new format type modifier '!' is useful for packing and unpacking +native shorts, ints, and longs. See "pack" in perlfunc. +.SS "\fBpack()\fP and \fBunpack()\fP support counted strings" +.IX Subsection "pack() and unpack() support counted strings" +The template character '/' can be used to specify a counted string +type to be packed or unpacked. See "pack" in perlfunc. +.SS "Comments in \fBpack()\fP templates" +.IX Subsection "Comments in pack() templates" +The '#' character in a template introduces a comment up to +end of the line. This facilitates documentation of \fBpack()\fR +templates. +.SS "Weak references" +.IX Subsection "Weak references" +In previous versions of Perl, you couldn't cache objects so as +to allow them to be deleted if the last reference from outside +the cache is deleted. The reference in the cache would hold a +reference count on the object and the objects would never be +destroyed. +.PP +Another familiar problem is with circular references. When an +object references itself, its reference count would never go +down to zero, and it would not get destroyed until the program +is about to exit. +.PP +Weak references solve this by allowing you to "weaken" any +reference, that is, make it not count towards the reference count. +When the last non-weak reference to an object is deleted, the object +is destroyed and all the weak references to the object are +automatically undef-ed. +.PP +To use this feature, you need the Devel::WeakRef package from CPAN, which +contains additional documentation. +.PP +.Vb 1 +\& NOTE: This is an experimental feature. Details are subject to change. +.Ve +.SS "Binary numbers supported" +.IX Subsection "Binary numbers supported" +Binary numbers are now supported as literals, in s?printf formats, and +\&\f(CWoct()\fR: +.PP +.Vb 2 +\& $answer = 0b101010; +\& printf "The answer is: %b\en", oct("0b101010"); +.Ve +.SS "Lvalue subroutines" +.IX Subsection "Lvalue subroutines" +Subroutines can now return modifiable lvalues. +See "Lvalue subroutines" in perlsub. +.PP +.Vb 1 +\& NOTE: This is an experimental feature. Details are subject to change. +.Ve +.SS "Some arrows may be omitted in calls through references" +.IX Subsection "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, +\&\f(CW\*(C`$foo[10]\->(\*(Aqfoo\*(Aq)\*(C'\fR may now be written \f(CW\*(C`$foo[10](\*(Aqfoo\*(Aq)\*(C'\fR. +This is rather similar to how the arrow may be omitted from +\&\f(CW\*(C`$foo[10]\->{\*(Aqfoo\*(Aq}\*(C'\fR. Note however, that the arrow is still +required for \f(CW\*(C`foo(10)\->(\*(Aqbar\*(Aq)\*(C'\fR. +.SS "Boolean assignment operators are legal lvalues" +.IX Subsection "Boolean assignment operators are legal lvalues" +Constructs such as \f(CW\*(C`($a ||= 2) += 1\*(C'\fR are now allowed. +.SS "\fBexists()\fP is supported on subroutine names" +.IX Subsection "exists() is supported on subroutine names" +The \fBexists()\fR builtin now works on subroutine names. A subroutine +is considered to exist if it has been declared (even if implicitly). +See "exists" in perlfunc for examples. +.SS "\fBexists()\fP and \fBdelete()\fP are supported on array elements" +.IX Subsection "exists() and delete() are supported on array elements" +The \fBexists()\fR and \fBdelete()\fR builtins now work on simple arrays as well. +The behavior is similar to that on hash elements. +.PP +\&\fBexists()\fR can be used to check whether an array element has been +initialized. This avoids autovivifying array elements that don't exist. +If the array is tied, the \fBEXISTS()\fR method in the corresponding tied +package will be invoked. +.PP +\&\fBdelete()\fR may be used to remove an element from the array and return +it. The array element at that position returns to its uninitialized +state, so that testing for the same element with \fBexists()\fR will return +false. If the element happens to be the one at the end, the size of +the array also shrinks up to the highest element that tests true for +\&\fBexists()\fR, or 0 if none such is found. If the array is tied, the \fBDELETE()\fR +method in the corresponding tied package will be invoked. +.PP +See "exists" in perlfunc and "delete" in perlfunc for examples. +.SS "Pseudo-hashes work better" +.IX Subsection "Pseudo-hashes work better" +Dereferencing some types of reference values in a pseudo-hash, +such as \f(CW\*(C`$ph\->{foo}[1]\*(C'\fR, was accidentally disallowed. This has +been corrected. +.PP +When applied to a pseudo-hash element, \fBexists()\fR now reports whether +the specified value exists, not merely if the key is valid. +.PP +\&\fBdelete()\fR now works on pseudo-hashes. When given a pseudo-hash element +or slice it deletes the values corresponding to the keys (but not the keys +themselves). See "Pseudo-hashes: Using an array as a hash" in perlref. +.PP +Pseudo-hash slices with constant keys are now optimized to array lookups +at compile-time. +.PP +List assignments to pseudo-hash slices are now supported. +.PP +The \f(CW\*(C`fields\*(C'\fR pragma now provides ways to create pseudo-hashes, via +\&\fBfields::new()\fR and \fBfields::phash()\fR. See fields. +.PP +.Vb 3 +\& NOTE: The pseudo\-hash data type continues to be experimental. +\& Limiting oneself to the interface elements provided by the +\& fields pragma will provide protection from any future changes. +.Ve +.SS "Automatic flushing of output buffers" +.IX Subsection "Automatic flushing of output buffers" +\&\fBfork()\fR, \fBexec()\fR, \fBsystem()\fR, qx//, and pipe \fBopen()\fRs 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. +.PP +This is not supported on some platforms like Solaris where a suitably +correct implementation of fflush(NULL) isn't available. +.SS "Better diagnostics on meaningless filehandle operations" +.IX Subsection "Better diagnostics on meaningless filehandle operations" +Constructs such as \f(CWopen(<FH>)\fR and \f(CWclose(<FH>)\fR +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). +.SS "Where possible, buffered data discarded from duped input filehandle" +.IX Subsection "Where possible, buffered data discarded from duped input filehandle" +\&\f(CW\*(C`open(NEW, "<&OLD")\*(C'\fR now attempts to discard any data that +was previously read and buffered in \f(CW\*(C`OLD\*(C'\fR before duping the handle. +On platforms where doing this is allowed, the next read operation +on \f(CW\*(C`NEW\*(C'\fR will return the same data as the corresponding operation +on \f(CW\*(C`OLD\*(C'\fR. Formerly, it would have returned the data from the start +of the following disk block instead. +.SS "\fBeof()\fP has the same old magic as <>" +.IX Subsection "eof() has the same old magic as <>" +\&\f(CWeof()\fR would return true if no attempt to read from \f(CW\*(C`<>\*(C'\fR had +yet been made. \f(CWeof()\fR has been changed to have a little magic of its +own, it now opens the \f(CW\*(C`<>\*(C'\fR files. +.SS "\fBbinmode()\fP can be used to set :crlf and :raw modes" +.IX Subsection "binmode() can be used to set :crlf and :raw modes" +\&\fBbinmode()\fR now accepts a second argument that specifies a discipline +for the handle in question. The two pseudo-disciplines ":raw" and +":crlf" are currently supported on DOS-derivative platforms. +See "binmode" in perlfunc and open. +.ie n .SS """\-T"" filetest recognizes UTF\-8 encoded files as ""text""" +.el .SS "\f(CW\-T\fP filetest recognizes UTF\-8 encoded files as ""text""" +.IX Subsection "-T filetest recognizes UTF-8 encoded files as ""text""" +The algorithm used for the \f(CW\*(C`\-T\*(C'\fR filetest has been enhanced to +correctly identify UTF\-8 content as "text". +.SS "\fBsystem()\fP, backticks and pipe open now reflect \fBexec()\fP failure" +.IX Subsection "system(), backticks and pipe open now reflect exec() failure" +On Unix and similar platforms, \fBsystem()\fR, \fBqx()\fR and open(FOO, "cmd |") +etc., are implemented via \fBfork()\fR and \fBexec()\fR. When the underlying +\&\fBexec()\fR fails, earlier versions did not report the error properly, +since the \fBexec()\fR happened to be in a different process. +.PP +The child process now communicates with the parent about the +error in launching the external command, which allows these +constructs to return with their usual error value and set $!. +.SS "Improved diagnostics" +.IX Subsection "Improved diagnostics" +Line numbers are no longer suppressed (under most likely circumstances) +during the global destruction phase. +.PP +Diagnostics emitted from code running in threads other than the main +thread are now accompanied by the thread ID. +.PP +Embedded null characters in diagnostics now actually show up. They +used to truncate the message in prior versions. +.PP +\&\f(CW$foo::a\fR and \f(CW$foo::b\fR are now exempt from "possible typo" warnings only +if \fBsort()\fR is encountered in package \f(CW\*(C`foo\*(C'\fR. +.PP +Unrecognized alphabetic escapes encountered when parsing quote +constructs now generate a warning, since they may take on new +semantics in later versions of Perl. +.PP +Many diagnostics now report the internal operation in which the warning +was provoked, like so: +.PP +.Vb 2 +\& Use of uninitialized value in concatenation (.) at (eval 1) line 1. +\& Use of uninitialized value in print at (eval 1) line 1. +.Ve +.PP +Diagnostics that occur within eval may also report the file and line +number where the eval is located, in addition to the eval sequence +number and the line number within the evaluated text itself. For +example: +.PP +.Vb 1 +\& Not enough arguments for scalar at (eval 4)[newlib/perl5db.pl:1411] line 2, at EOF +.Ve +.SS "Diagnostics follow STDERR" +.IX Subsection "Diagnostics follow STDERR" +Diagnostic output now goes to whichever file the \f(CW\*(C`STDERR\*(C'\fR handle +is pointing at, instead of always going to the underlying C runtime +library's \f(CW\*(C`stderr\*(C'\fR. +.SS "More consistent close-on-exec behavior" +.IX Subsection "More consistent close-on-exec behavior" +On systems that support a close-on-exec flag on filehandles, the +flag is now set for any handles created by \fBpipe()\fR, \fBsocketpair()\fR, +\&\fBsocket()\fR, and \fBaccept()\fR, 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 these operators. See "pipe" in perlfunc, +"socketpair" in perlfunc, "socket" in perlfunc, "accept" in perlfunc, +and "$^F" in perlvar. +.SS "\fBsyswrite()\fP ease-of-use" +.IX Subsection "syswrite() ease-of-use" +The length argument of \f(CWsyswrite()\fR has become optional. +.SS "Better syntax checks on parenthesized unary operators" +.IX Subsection "Better syntax checks on parenthesized unary operators" +Expressions such as: +.PP +.Vb 3 +\& print defined(&foo,&bar,&baz); +\& print uc("foo","bar","baz"); +\& undef($foo,&bar); +.Ve +.PP +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. +.PP +The parenthesized forms of most unary operators that expect a single +argument now ensure that they are not called with more than one +argument, making the cases shown above syntax errors. The usual +behaviour of: +.PP +.Vb 3 +\& print defined &foo, &bar, &baz; +\& print uc "foo", "bar", "baz"; +\& undef $foo, &bar; +.Ve +.PP +remains unchanged. See perlop. +.SS "Bit operators support full native integer width" +.IX Subsection "Bit operators support full native integer width" +The bit operators (& | ^ ~ << >>) now operate on the full native +integral width (the exact size of which is available in \f(CW$Config\fR{ivsize}). +For example, if your platform is either natively 64\-bit or if Perl +has been configured to use 64\-bit integers, these operations apply +to 8 bytes (as opposed to 4 bytes on 32\-bit platforms). +For portability, be sure to mask off the excess bits in the result of +unary \f(CW\*(C`~\*(C'\fR, e.g., \f(CW\*(C`~$x & 0xffffffff\*(C'\fR. +.SS "Improved security features" +.IX Subsection "Improved security features" +More potentially unsafe operations taint their results for improved +security. +.PP +The \f(CW\*(C`passwd\*(C'\fR and \f(CW\*(C`shell\*(C'\fR fields returned by the \fBgetpwent()\fR, \fBgetpwnam()\fR, +and \fBgetpwuid()\fR are now tainted, because the user can affect their own +encrypted password and login shell. +.PP +The variable modified by \fBshmread()\fR, and messages returned by \fBmsgrcv()\fR +(and its object-oriented interface IPC::SysV::Msg::rcv) are also tainted, +because other untrusted processes can modify messages and shared memory +segments for their own nefarious purposes. +.SS "More functional bareword prototype (*)" +.IX Subsection "More functional bareword prototype (*)" +Bareword prototypes have been rationalized to enable them to be used +to override builtins that accept barewords and interpret them in +a special way, such as \f(CW\*(C`require\*(C'\fR or \f(CW\*(C`do\*(C'\fR. +.PP +Arguments prototyped as \f(CW\*(C`*\*(C'\fR will now be visible within the subroutine +as either a simple scalar or as a reference to a typeglob. +See "Prototypes" in perlsub. +.ie n .SS """require"" and ""do"" may be overridden" +.el .SS "\f(CWrequire\fP and \f(CWdo\fP may be overridden" +.IX Subsection "require and do may be overridden" +\&\f(CW\*(C`require\*(C'\fR and \f(CW\*(C`do \*(Aqfile\*(Aq\*(C'\fR 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 \f(CW\*(C`require\*(C'\fR will also affect \f(CW\*(C`use\*(C'\fR, provided the override +is visible at compile-time. +See "Overriding Built-in Functions" in perlsub. +.SS "$^X variables may now have names longer than one character" +.IX Subsection "$^X variables may now have names longer than one character" +Formerly, $^X was synonymous with ${"\ecX"}, 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 +\&\fImust\fR be written with explicit braces, as \f(CW\*(C`${^XY}\*(C'\fR for example. +\&\f(CW\*(C`${^XYZ}\*(C'\fR is synonymous with ${"\ecXYZ"}. Variable names with more +than one control character, such as \f(CW\*(C`${^XY^Z}\*(C'\fR, are illegal. +.PP +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 \f(CW"$^XYZ"\fR continues to be synonymous with +\&\f(CW\*(C`$^X . "YZ"\*(C'\fR as before. +.PP +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 +\&\f(CW\*(C`^_\*(C'\fR, which may be used by user programs and are guaranteed not to +acquire special meaning in any future version of Perl. +.ie n .SS "New variable $^C reflects ""\-c"" switch" +.el .SS "New variable $^C reflects \f(CW\-c\fP switch" +.IX Subsection "New variable $^C reflects -c switch" +\&\f(CW$^C\fR has a boolean value that reflects whether perl is being run +in compile-only mode (i.e. via the \f(CW\*(C`\-c\*(C'\fR 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 perlvar. +.SS "New variable $^V contains Perl version as a string" +.IX Subsection "New variable $^V contains Perl version as a string" +\&\f(CW$^V\fR contains the Perl version number as a string composed of +characters whose ordinals match the version numbers, i.e. v5.6.0. +This may be used in string comparisons. +.PP +See \f(CW\*(C`Support for strings represented as a vector of ordinals\*(C'\fR for an +example. +.SS "Optional Y2K warnings" +.IX Subsection "Optional Y2K warnings" +If Perl is built with the cpp macro \f(CW\*(C`PERL_Y2KWARN\*(C'\fR defined, +it emits optional warnings when concatenating the number 19 +with another number. +.PP +This behavior must be specifically enabled when running Configure. +See \fIINSTALL\fR and \fIREADME.Y2K\fR. +.SS "Arrays now always interpolate into double-quoted strings" +.IX Subsection "Arrays now always interpolate into double-quoted strings" +In double-quoted strings, arrays now interpolate, no matter what. The +behavior in earlier versions of perl 5 was that arrays would interpolate +into strings if the array had been mentioned before the string was +compiled, and otherwise Perl would raise a fatal compile-time error. +In versions 5.000 through 5.003, the error was +.PP +.Vb 1 +\& Literal @example now requires backslash +.Ve +.PP +In versions 5.004_01 through 5.6.0, the error was +.PP +.Vb 1 +\& In string, @example now must be written as \e@example +.Ve +.PP +The idea here was to get people into the habit of writing +\&\f(CW"fred\e@example.com"\fR when they wanted a literal \f(CW\*(C`@\*(C'\fR sign, just as +they have always written \f(CW"Give me back my \e$5"\fR when they wanted a +literal \f(CW\*(C`$\*(C'\fR sign. +.PP +Starting with 5.6.1, when Perl now sees an \f(CW\*(C`@\*(C'\fR sign in a +double-quoted string, it \fIalways\fR attempts to interpolate an array, +regardless of whether or not the array has been used or declared +already. The fatal error has been downgraded to an optional warning: +.PP +.Vb 1 +\& Possible unintended interpolation of @example in string +.Ve +.PP +This warns you that \f(CW"fred@example.com"\fR is going to turn into +\&\f(CW\*(C`fred.com\*(C'\fR if you don't backslash the \f(CW\*(C`@\*(C'\fR. +See http://perl.plover.com/at\-error.html for more details +about the history here. +.SS "@\- and @+ provide starting/ending offsets of regex matches" +.IX Subsection "@- and @+ provide starting/ending offsets of regex matches" +The new magic variables @\- and @+ provide the starting and ending +offsets, respectively, of $&, \f(CW$1\fR, \f(CW$2\fR, etc. See perlvar for +details. +.SH "Modules and Pragmata" +.IX Header "Modules and Pragmata" +.SS Modules +.IX Subsection "Modules" +.IP attributes 4 +.IX Item "attributes" +While used internally by Perl as a pragma, this module also +provides a way to fetch subroutine and variable attributes. +See attributes. +.IP B 4 +.IX Item "B" +The Perl Compiler suite has been extensively reworked for this +release. More of the standard Perl test suite passes when run +under the Compiler, but there is still a significant way to +go to achieve production quality compiled executables. +.Sp +.Vb 3 +\& NOTE: The Compiler suite remains highly experimental. The +\& generated code may not be correct, even when it manages to execute +\& without errors. +.Ve +.IP Benchmark 4 +.IX Item "Benchmark" +Overall, Benchmark results exhibit lower average error and better timing +accuracy. +.Sp +You can now run tests for \fIn\fR 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: +.Sp +.Vb 1 +\& use Benchmark;$x=3;timethese(\-5,{a=>sub{$x*$x},b=>sub{$x**2}}) +.Ve +.Sp +will now output something like this: +.Sp +.Vb 3 +\& 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) +.Ve +.Sp +New features: "each for at least N CPU seconds...", "wallclock secs", +and the "@ operations/CPU second (n=operations)". +.Sp +\&\fBtimethese()\fR now returns a reference to a hash of Benchmark objects containing +the test results, keyed on the names of the tests. +.Sp +\&\fBtimethis()\fR now returns the iterations field in the Benchmark result object +instead of 0. +.Sp +\&\fBtimethese()\fR, \fBtimethis()\fR, and the new \fBcmpthese()\fR (see below) can also take +a format specifier of 'none' to suppress output. +.Sp +A new function \fBcountit()\fR is just like \fBtimeit()\fR except that it takes a +TIME instead of a COUNT. +.Sp +A new function \fBcmpthese()\fR prints a chart comparing the results of each test +returned from a \fBtimethese()\fR call. For each possible pair of tests, the +percentage speed difference (iters/sec or seconds/iter) is shown. +.Sp +For other details, see Benchmark. +.IP ByteLoader 4 +.IX Item "ByteLoader" +The ByteLoader is a dedicated extension to generate and run +Perl bytecode. See ByteLoader. +.IP constant 4 +.IX Item "constant" +References can now be used. +.Sp +The new version also allows a leading underscore in constant names, but +disallows a double leading underscore (as in "_\|_LINE_\|_"). Some other names +are disallowed or warned against, including BEGIN, END, etc. Some names +which were forced into main:: used to fail silently in some cases; now they're +fatal (outside of main::) and an optional warning (inside of main::). +The ability to detect whether a constant had been set with a given name has +been added. +.Sp +See constant. +.IP charnames 4 +.IX Item "charnames" +This pragma implements the \f(CW\*(C`\eN\*(C'\fR string escape. See charnames. +.IP Data::Dumper 4 +.IX Item "Data::Dumper" +A \f(CW\*(C`Maxdepth\*(C'\fR setting can be specified to avoid venturing +too deeply into deep data structures. See Data::Dumper. +.Sp +The XSUB implementation of \fBDump()\fR is now automatically called if the +\&\f(CW\*(C`Useqq\*(C'\fR setting is not in use. +.Sp +Dumping \f(CW\*(C`qr//\*(C'\fR objects works correctly. +.IP DB 4 +.IX Item "DB" +\&\f(CW\*(C`DB\*(C'\fR is an experimental module that exposes a clean abstraction +to Perl's debugging API. +.IP DB_File 4 +.IX Item "DB_File" +DB_File can now be built with Berkeley DB versions 1, 2 or 3. +See \f(CW\*(C`ext/DB_File/Changes\*(C'\fR. +.IP Devel::DProf 4 +.IX Item "Devel::DProf" +Devel::DProf, a Perl source code profiler has been added. See +Devel::DProf and dprofpp. +.IP Devel::Peek 4 +.IX 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. +.IP Dumpvalue 4 +.IX Item "Dumpvalue" +The Dumpvalue module provides screen dumps of Perl data. +.IP DynaLoader 4 +.IX Item "DynaLoader" +DynaLoader now supports a \fBdl_unload_file()\fR function on platforms that +support unloading shared objects using \fBdlclose()\fR. +.Sp +Perl can also optionally arrange to unload all extension shared objects +loaded by Perl. To enable this, build Perl with the Configure option +\&\f(CW\*(C`\-Accflags=\-DDL_UNLOAD_ALL_AT_EXIT\*(C'\fR. (This maybe useful if you are +using Apache with mod_perl.) +.IP English 4 +.IX Item "English" +\&\f(CW$PERL_VERSION\fR now stands for \f(CW$^V\fR (a string value) rather than for \f(CW$]\fR +(a numeric value). +.IP Env 4 +.IX Item "Env" +Env now supports accessing environment variables like PATH as array +variables. +.IP Fcntl 4 +.IX Item "Fcntl" +More Fcntl constants added: F_SETLK64, F_SETLKW64, O_LARGEFILE for +large file (more than 4GB) access (NOTE: the O_LARGEFILE is +automatically added to \fBsysopen()\fR flags if large file support has been +configured, as is the default), Free/Net/OpenBSD locking behaviour +flags F_FLOCK, F_POSIX, Linux F_SHLCK, and O_ACCMODE: the combined +mask of O_RDONLY, O_WRONLY, and O_RDWR. The \fBseek()\fR/\fBsysseek()\fR +constants SEEK_SET, SEEK_CUR, and SEEK_END are available via the +\&\f(CW\*(C`:seek\*(C'\fR tag. The \fBchmod()\fR/\fBstat()\fR S_IF* constants and S_IS* functions +are available via the \f(CW\*(C`:mode\*(C'\fR tag. +.IP File::Compare 4 +.IX Item "File::Compare" +A \fBcompare_text()\fR function has been added, which allows custom +comparison functions. See File::Compare. +.IP File::Find 4 +.IX Item "File::Find" +File::Find now works correctly when the \fBwanted()\fR function is either +autoloaded or is a symbolic reference. +.Sp +A bug that caused File::Find to lose track of the working directory +when pruning top-level directories has been fixed. +.Sp +File::Find now also supports several other options to control its +behavior. It can follow symbolic links if the \f(CW\*(C`follow\*(C'\fR option is +specified. Enabling the \f(CW\*(C`no_chdir\*(C'\fR option will make File::Find skip +changing the current directory when walking directories. The \f(CW\*(C`untaint\*(C'\fR +flag can be useful when running with taint checks enabled. +.Sp +See File::Find. +.IP File::Glob 4 +.IX Item "File::Glob" +This extension implements BSD-style file globbing. By default, +it will also be used for the internal implementation of the \fBglob()\fR +operator. See File::Glob. +.IP File::Spec 4 +.IX Item "File::Spec" +New methods have been added to the File::Spec module: \fBdevnull()\fR returns +the name of the null device (/dev/null on Unix) and \fBtmpdir()\fR the name of +the temp directory (normally /tmp on Unix). There are now also methods +to convert between absolute and relative filenames: \fBabs2rel()\fR and +\&\fBrel2abs()\fR. For compatibility with operating systems that specify volume +names in file paths, the \fBsplitpath()\fR, \fBsplitdir()\fR, and \fBcatdir()\fR methods +have been added. +.IP File::Spec::Functions 4 +.IX Item "File::Spec::Functions" +The new File::Spec::Functions modules provides a function interface +to the File::Spec module. Allows shorthand +.Sp +.Vb 1 +\& $fullname = catfile($dir1, $dir2, $file); +.Ve +.Sp +instead of +.Sp +.Vb 1 +\& $fullname = File::Spec\->catfile($dir1, $dir2, $file); +.Ve +.IP Getopt::Long 4 +.IX Item "Getopt::Long" +Getopt::Long licensing has changed to allow the Perl Artistic License +as well as the GPL. It used to be GPL only, which got in the way of +non-GPL applications that wanted to use Getopt::Long. +.Sp +Getopt::Long encourages the use of Pod::Usage to produce help +messages. For example: +.Sp +.Vb 7 +\& use Getopt::Long; +\& use Pod::Usage; +\& my $man = 0; +\& my $help = 0; +\& GetOptions(\*(Aqhelp|?\*(Aq => \e$help, man => \e$man) or pod2usage(2); +\& pod2usage(1) if $help; +\& pod2usage(\-exitstatus => 0, \-verbose => 2) if $man; +\& +\& _\|_END_\|_ +\& +\& =head1 NAME +\& +\& sample \- Using Getopt::Long and Pod::Usage +\& +\& =head1 SYNOPSIS +\& +\& sample [options] [file ...] +\& +\& Options: +\& \-help brief help message +\& \-man full documentation +\& +\& =head1 OPTIONS +\& +\& =over 8 +\& +\& =item B<\-help> +\& +\& Print a brief help message and exits. +\& +\& =item B<\-man> +\& +\& Prints the manual page and exits. +\& +\& =back +\& +\& =head1 DESCRIPTION +\& +\& B<This program> will read the given input file(s) and do something +\& useful with the contents thereof. +\& +\& =cut +.Ve +.Sp +See Pod::Usage for details. +.Sp +A bug that prevented the non-option call-back <> from being +specified as the first argument has been fixed. +.Sp +To specify the characters < and > as option starters, use ><. Note, +however, that changing option starters is strongly deprecated. +.IP IO 4 +.IX Item "IO" +\&\fBwrite()\fR and \fBsyswrite()\fR will now accept a single-argument +form of the call, for consistency with Perl's \fBsyswrite()\fR. +.Sp +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 \fBconnect()\fR manually. +.Sp +A bug that prevented the \fBIO::Socket::protocol()\fR accessor +from ever returning the correct value has been corrected. +.Sp +IO::Socket::connect now uses non-blocking IO instead of \fBalarm()\fR +to do connect timeouts. +.Sp +IO::Socket::accept now uses \fBselect()\fR instead of \fBalarm()\fR for doing +timeouts. +.Sp +IO::Socket::INET\->new now sets $! correctly on failure. $@ is +still set for backwards compatibility. +.IP JPL 4 +.IX Item "JPL" +Java Perl Lingo is now distributed with Perl. See jpl/README +for more information. +.IP lib 4 +.IX Item "lib" +\&\f(CW\*(C`use lib\*(C'\fR now weeds out any trailing duplicate entries. +\&\f(CW\*(C`no lib\*(C'\fR removes all named entries. +.IP Math::BigInt 4 +.IX Item "Math::BigInt" +The bitwise operations \f(CW\*(C`<<\*(C'\fR, \f(CW\*(C`>>\*(C'\fR, \f(CW\*(C`&\*(C'\fR, \f(CW\*(C`|\*(C'\fR, +and \f(CW\*(C`~\*(C'\fR are now supported on bigints. +.IP Math::Complex 4 +.IX Item "Math::Complex" +The accessor methods Re, Im, arg, abs, rho, and theta can now also +act as mutators (accessor \f(CW$z\fR\->\fBRe()\fR, mutator \f(CW$z\fR\->\fBRe\fR\|(3)). +.Sp +The class method \f(CW\*(C`display_format\*(C'\fR and the corresponding object method +\&\f(CW\*(C`display_format\*(C'\fR, in addition to accepting just one argument, now can +also accept a parameter hash. Recognized keys of a parameter hash are +\&\f(CW"style"\fR, which corresponds to the old one parameter case, and two +new parameters: \f(CW"format"\fR, which is a \fBprintf()\fR\-style format string +(defaults usually to \f(CW"%.15g"\fR, you can revert to the default by +setting the format string to \f(CW\*(C`undef\*(C'\fR) used for both parts of a +complex number, and \f(CW"polar_pretty_print"\fR (defaults to true), +which controls whether an attempt is made to try to recognize small +multiples and rationals of pi (2pi, pi/2) at the argument (angle) of a +polar complex number. +.Sp +The potentially disruptive change is that in list context both methods +now \fIreturn the parameter hash\fR, instead of only the value of the +\&\f(CW"style"\fR parameter. +.IP Math::Trig 4 +.IX Item "Math::Trig" +A little bit of radial trigonometry (cylindrical and spherical), +radial coordinate conversions, and the great circle distance were added. +.IP "Pod::Parser, Pod::InputObjects" 4 +.IX Item "Pod::Parser, Pod::InputObjects" +Pod::Parser is a base class for parsing and selecting sections of +pod documentation from an input stream. This module takes care of +identifying pod paragraphs and commands in the input and hands off the +parsed paragraphs and commands to user-defined methods which are free +to interpret or translate them as they see fit. +.Sp +Pod::InputObjects defines some input objects needed by Pod::Parser, and +for advanced users of Pod::Parser that need more about a command besides +its name and text. +.Sp +As of release 5.6.0 of Perl, Pod::Parser is now the officially sanctioned +"base parser code" recommended for use by all pod2xxx translators. +Pod::Text (pod2text) and Pod::Man (pod2man) have already been converted +to use Pod::Parser and efforts to convert Pod::HTML (pod2html) are already +underway. For any questions or comments about pod parsing and translating +issues and utilities, please use the pod\-people@perl.org mailing list. +.Sp +For further information, please see Pod::Parser and Pod::InputObjects. +.IP "Pod::Checker, podchecker" 4 +.IX Item "Pod::Checker, podchecker" +This utility checks pod files for correct syntax, according to +perlpod. Obvious errors are flagged as such, while warnings are +printed for mistakes that can be handled gracefully. The checklist is +not complete yet. See Pod::Checker. +.IP "Pod::ParseUtils, Pod::Find" 4 +.IX Item "Pod::ParseUtils, Pod::Find" +These modules provide a set of gizmos that are useful mainly for pod +translators. Pod::Find traverses directory structures and +returns found pod files, along with their canonical names (like +\&\f(CW\*(C`File::Spec::Unix\*(C'\fR). Pod::ParseUtils contains +\&\fBPod::List\fR (useful for storing pod list information), \fBPod::Hyperlink\fR +(for parsing the contents of \f(CW\*(C`L<>\*(C'\fR sequences) and \fBPod::Cache\fR +(for caching information about pod files, e.g., link nodes). +.IP "Pod::Select, podselect" 4 +.IX Item "Pod::Select, podselect" +Pod::Select is a subclass of Pod::Parser which provides a function +named "\fBpodselect()\fR" to filter out user-specified sections of raw pod +documentation from an input stream. podselect is a script that provides +access to Pod::Select from other scripts to be used as a filter. +See Pod::Select. +.IP "Pod::Usage, pod2usage" 4 +.IX Item "Pod::Usage, pod2usage" +Pod::Usage provides the function "\fBpod2usage()\fR" to print usage messages for +a Perl script based on its embedded pod documentation. The \fBpod2usage()\fR +function is generally useful to all script authors since it lets them +write and maintain a single source (the pods) for documentation, thus +removing the need to create and maintain redundant usage message text +consisting of information already in the pods. +.Sp +There is also a pod2usage script which can be used from other kinds of +scripts to print usage messages from pods (even for non-Perl scripts +with pods embedded in comments). +.Sp +For details and examples, please see Pod::Usage. +.IP "Pod::Text and Pod::Man" 4 +.IX Item "Pod::Text and Pod::Man" +Pod::Text has been rewritten to use Pod::Parser. While \fBpod2text()\fR is +still available for backwards compatibility, the module now has a new +preferred interface. See Pod::Text for the details. The new Pod::Text +module is easily subclassed for tweaks to the output, and two such +subclasses (Pod::Text::Termcap for man-page-style bold and underlining +using termcap information, and Pod::Text::Color for markup with ANSI color +sequences) are now standard. +.Sp +pod2man has been turned into a module, Pod::Man, which also uses +Pod::Parser. In the process, several outstanding bugs related to quotes +in section headers, quoting of code escapes, and nested lists have been +fixed. pod2man is now a wrapper script around this module. +.IP SDBM_File 4 +.IX Item "SDBM_File" +An EXISTS method has been added to this module (and \fBsdbm_exists()\fR 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. +.Sp +A bug that may have caused data loss when more than one disk block +happens to be read from the database in a single \fBFETCH()\fR has been +fixed. +.IP Sys::Syslog 4 +.IX Item "Sys::Syslog" +Sys::Syslog now uses XSUBs to access facilities from syslog.h so it +no longer requires syslog.ph to exist. +.IP Sys::Hostname 4 +.IX Item "Sys::Hostname" +Sys::Hostname now uses XSUBs to call the C library's \fBgethostname()\fR or +\&\fBuname()\fR if they exist. +.IP Term::ANSIColor 4 +.IX Item "Term::ANSIColor" +Term::ANSIColor is a very simple module to provide easy and readable +access to the ANSI color and highlighting escape sequences, supported by +most ANSI terminal emulators. It is now included standard. +.IP Time::Local 4 +.IX Item "Time::Local" +The \fBtimelocal()\fR and \fBtimegm()\fR functions used to silently return bogus +results when the date fell outside the machine's integer range. They +now consistently \fBcroak()\fR if the date falls in an unsupported range. +.IP Win32 4 +.IX 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 \f(CW\*(C`undef\*(C'\fR if an error occurred. Now these functions +return the empty list in these situations. This applies to the following +functions: +.Sp +.Vb 2 +\& Win32::FsType +\& Win32::GetOSVersion +.Ve +.Sp +The remaining functions are unchanged and continue to return \f(CW\*(C`undef\*(C'\fR on +error even in list context. +.Sp +The Win32::SetLastError(ERROR) function has been added as a complement +to the \fBWin32::GetLastError()\fR function. +.Sp +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. See Win32. +.IP XSLoader 4 +.IX Item "XSLoader" +The XSLoader extension is a simpler alternative to DynaLoader. +See XSLoader. +.IP "DBM Filters" 4 +.IX 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: +.Sp +.Vb 4 +\& filter_store_key +\& filter_store_value +\& filter_fetch_key +\& filter_fetch_value +.Ve +.Sp +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 perldbmfilter for further information. +.SS Pragmata +.IX Subsection "Pragmata" +\&\f(CW\*(C`use attrs\*(C'\fR is now obsolete, and is only provided for +backward-compatibility. It's been replaced by the \f(CW\*(C`sub : attributes\*(C'\fR +syntax. See "Subroutine Attributes" in perlsub and attributes. +.PP +Lexical warnings pragma, \f(CW\*(C`use warnings;\*(C'\fR, to control optional warnings. +See perllexwarn. +.PP +\&\f(CW\*(C`use filetest\*(C'\fR to control the behaviour of filetests (\f(CW\*(C`\-r\*(C'\fR \f(CW\*(C`\-w\*(C'\fR +\&...). Currently only one subpragma implemented, "use filetest +\&'access';", that uses \fBaccess\fR\|(2) or equivalent to check permissions +instead of using \fBstat\fR\|(2) as usual. This matters in filesystems +where there are ACLs (access control lists): the \fBstat\fR\|(2) might lie, +but \fBaccess\fR\|(2) knows better. +.PP +The \f(CW\*(C`open\*(C'\fR pragma can be used to specify default disciplines for +handle constructors (e.g. \fBopen()\fR) and for qx//. The two +pseudo-disciplines \f(CW\*(C`:raw\*(C'\fR and \f(CW\*(C`:crlf\*(C'\fR are currently supported on +DOS-derivative platforms (i.e. where binmode is not a no-op). +See also "\fBbinmode()\fR can be used to set :crlf and :raw modes". +.SH "Utility Changes" +.IX Header "Utility Changes" +.SS dprofpp +.IX Subsection "dprofpp" +\&\f(CW\*(C`dprofpp\*(C'\fR is used to display profile data generated using \f(CW\*(C`Devel::DProf\*(C'\fR. +See dprofpp. +.SS find2perl +.IX Subsection "find2perl" +The \f(CW\*(C`find2perl\*(C'\fR utility now uses the enhanced features of the File::Find +module. The \-depth and \-follow options are supported. Pod documentation +is also included in the script. +.SS h2xs +.IX Subsection "h2xs" +The \f(CW\*(C`h2xs\*(C'\fR tool can now work in conjunction with \f(CW\*(C`C::Scan\*(C'\fR (available +from CPAN) to automatically parse real-life header files. The \f(CW\*(C`\-M\*(C'\fR, +\&\f(CW\*(C`\-a\*(C'\fR, \f(CW\*(C`\-k\*(C'\fR, and \f(CW\*(C`\-o\*(C'\fR options are new. +.SS perlcc +.IX Subsection "perlcc" +\&\f(CW\*(C`perlcc\*(C'\fR now supports the C and Bytecode backends. By default, +it generates output from the simple C backend rather than the +optimized C backend. +.PP +Support for non-Unix platforms has been improved. +.SS perldoc +.IX Subsection "perldoc" +\&\f(CW\*(C`perldoc\*(C'\fR has been reworked to avoid possible security holes. +It will not by default let itself be run as the superuser, but you +may still use the \fB\-U\fR switch to try to make it drop privileges +first. +.SS "The Perl Debugger" +.IX Subsection "The Perl Debugger" +Many bug fixes and enhancements were added to \fIperl5db.pl\fR, the +Perl debugger. The help documentation was rearranged. New commands +include \f(CW\*(C`< ?\*(C'\fR, \f(CW\*(C`> ?\*(C'\fR, and \f(CW\*(C`{ ?\*(C'\fR to list out current +actions, \f(CW\*(C`man \fR\f(CIdocpage\fR\f(CW\*(C'\fR to run your doc viewer on some perl +docset, and support for quoted options. The help information was +rearranged, and should be viewable once again if you're using \fBless\fR +as your pager. A serious security hole was plugged\-\-you should +immediately remove all older versions of the Perl debugger as +installed in previous releases, all the way back to perl3, from +your system to avoid being bitten by this. +.SH "Improved Documentation" +.IX Header "Improved Documentation" +Many of the platform-specific README files are now part of the perl +installation. See perl for the complete list. +.IP perlapi.pod 4 +.IX Item "perlapi.pod" +The official list of public Perl API functions. +.IP perlboot.pod 4 +.IX Item "perlboot.pod" +A tutorial for beginners on object-oriented Perl. +.IP perlcompile.pod 4 +.IX Item "perlcompile.pod" +An introduction to using the Perl Compiler suite. +.IP perldbmfilter.pod 4 +.IX Item "perldbmfilter.pod" +A howto document on using the DBM filter facility. +.IP perldebug.pod 4 +.IX Item "perldebug.pod" +All material unrelated to running the Perl debugger, plus all +low-level guts-like details that risked crushing the casual user +of the debugger, have been relocated from the old manpage to the +next entry below. +.IP perldebguts.pod 4 +.IX Item "perldebguts.pod" +This new manpage contains excessively low-level material not related +to the Perl debugger, but slightly related to debugging Perl itself. +It also contains some arcane internal details of how the debugging +process works that may only be of interest to developers of Perl +debuggers. +.IP perlfork.pod 4 +.IX Item "perlfork.pod" +Notes on the \fBfork()\fR emulation currently available for the Windows platform. +.IP perlfilter.pod 4 +.IX Item "perlfilter.pod" +An introduction to writing Perl source filters. +.IP perlhack.pod 4 +.IX Item "perlhack.pod" +Some guidelines for hacking the Perl source code. +.IP perlintern.pod 4 +.IX Item "perlintern.pod" +A list of internal functions in the Perl source code. +(List is currently empty.) +.IP perllexwarn.pod 4 +.IX Item "perllexwarn.pod" +Introduction and reference information about lexically scoped +warning categories. +.IP perlnumber.pod 4 +.IX Item "perlnumber.pod" +Detailed information about numbers as they are represented in Perl. +.IP perlopentut.pod 4 +.IX Item "perlopentut.pod" +A tutorial on using \fBopen()\fR effectively. +.IP perlreftut.pod 4 +.IX Item "perlreftut.pod" +A tutorial that introduces the essentials of references. +.IP perltootc.pod 4 +.IX Item "perltootc.pod" +A tutorial on managing class data for object modules. +.IP perltodo.pod 4 +.IX Item "perltodo.pod" +Discussion of the most often wanted features that may someday be +supported in Perl. +.IP perlunicode.pod 4 +.IX Item "perlunicode.pod" +An introduction to Unicode support features in Perl. +.SH "Performance enhancements" +.IX Header "Performance enhancements" +.ie n .SS "Simple \fBsort()\fP using { $a <=> $b } and the like are optimized" +.el .SS "Simple \fBsort()\fP using { \f(CW$a\fP <=> \f(CW$b\fP } and the like are optimized" +.IX Subsection "Simple sort() using { $a <=> $b } and the like are optimized" +Many common \fBsort()\fR operations using a simple inlined block are now +optimized for faster performance. +.SS "Optimized assignments to lexical variables" +.IX Subsection "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. +.SS "Faster subroutine calls" +.IX Subsection "Faster subroutine calls" +Minor changes in how subroutine calls are handled internally +provide marginal improvements in performance. +.SS "\fBdelete()\fP, \fBeach()\fP, \fBvalues()\fP and hash iteration are faster" +.IX Subsection "delete(), each(), values() and hash iteration are faster" +The hash values returned by \fBdelete()\fR, \fBeach()\fR, \fBvalues()\fR and hashes in a +list context are the actual values in the hash, instead of copies. +This results in significantly better performance, because it eliminates +needless copying in most situations. +.SH "Installation and Configuration Improvements" +.IX Header "Installation and Configuration Improvements" +.SS "\-Dusethreads means something different" +.IX Subsection "-Dusethreads means something different" +The \-Dusethreads flag now enables the experimental interpreter-based thread +support by default. To get the flavor of experimental threads that was in +5.005 instead, you need to run Configure with "\-Dusethreads \-Duse5005threads". +.PP +As of v5.6.0, interpreter-threads support is still lacking a way to +create new threads from Perl (i.e., \f(CW\*(C`use Thread;\*(C'\fR will not work with +interpreter threads). \f(CW\*(C`use Thread;\*(C'\fR continues to be available when you +specify the \-Duse5005threads option to Configure, bugs and all. +.PP +.Vb 2 +\& NOTE: Support for threads continues to be an experimental feature. +\& Interfaces and implementation are subject to sudden and drastic changes. +.Ve +.SS "New Configure flags" +.IX Subsection "New Configure flags" +The following new flags may be enabled on the Configure command line +by running Configure with \f(CW\*(C`\-Dflag\*(C'\fR. +.PP +.Vb 3 +\& usemultiplicity +\& usethreads useithreads (new interpreter threads: no Perl API yet) +\& usethreads use5005threads (threads as they were in 5.005) +\& +\& use64bitint (equal to now deprecated \*(Aquse64bits\*(Aq) +\& use64bitall +\& +\& uselongdouble +\& usemorebits +\& uselargefiles +\& usesocks (only SOCKS v5 supported) +.Ve +.SS "Threadedness and 64\-bitness now more daring" +.IX Subsection "Threadedness and 64-bitness 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 and datatypes, you should be able just to go ahead and +use them, for threads by Configure \-Dusethreads, and for 64 bits +either explicitly by Configure \-Duse64bitint or implicitly if your +system has 64\-bit wide datatypes. See also "64\-bit support". +.SS "Long Doubles" +.IX Subsection "Long Doubles" +Some platforms have "long doubles", floating point numbers of even +larger range than ordinary "doubles". To enable using long doubles for +Perl's scalars, use \-Duselongdouble. +.SS \-Dusemorebits +.IX Subsection "-Dusemorebits" +You can enable both \-Duse64bitint and \-Duselongdouble with \-Dusemorebits. +See also "64\-bit support". +.SS \-Duselargefiles +.IX Subsection "-Duselargefiles" +Some platforms support system APIs that are capable of handling large files +(typically, files larger than two gigabytes). Perl will try to use these +APIs if you ask for \-Duselargefiles. +.PP +See "Large file support" for more information. +.SS installusrbinperl +.IX Subsection "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. +.SS "SOCKS support" +.IX Subsection "SOCKS support" +You can use "Configure \-Dusesocks" which causes Perl to probe +for the SOCKS proxy protocol library (v5, not v4). For more information +on SOCKS, see: +.PP +.Vb 1 +\& http://www.socks.nec.com/ +.Ve +.ie n .SS """\-A"" flag" +.el .SS "\f(CW\-A\fP flag" +.IX Subsection "-A flag" +You can "post-edit" the Configure variables using the Configure \f(CW\*(C`\-A\*(C'\fR +switch. The editing happens immediately after the platform specific +hints files have been processed but before the actual configuration +process starts. Run \f(CW\*(C`Configure \-h\*(C'\fR to find out the full \f(CW\*(C`\-A\*(C'\fR syntax. +.SS "Enhanced Installation Directories" +.IX Subsection "Enhanced Installation Directories" +The installation structure has been enriched to improve the support +for maintaining multiple versions of perl, to provide locations for +vendor-supplied modules, scripts, and manpages, and to ease maintenance +of locally-added modules, scripts, and manpages. See the section on +Installation Directories in the INSTALL file for complete details. +For most users building and installing from source, the defaults should +be fine. +.PP +If you previously used \f(CW\*(C`Configure \-Dsitelib\*(C'\fR or \f(CW\*(C`\-Dsitearch\*(C'\fR to set +special values for library directories, you might wish to consider using +the new \f(CW\*(C`\-Dsiteprefix\*(C'\fR setting instead. Also, if you wish to re-use a +config.sh file from an earlier version of perl, you should be sure to +check that Configure makes sensible choices for the new directories. +See INSTALL for complete details. +.SH "Platform specific changes" +.IX Header "Platform specific changes" +.SS "Supported platforms" +.IX Subsection "Supported platforms" +.IP \(bu 4 +The Mach CThreads (NEXTSTEP, OPENSTEP) are now supported by the Thread +extension. +.IP \(bu 4 +GNU/Hurd is now supported. +.IP \(bu 4 +Rhapsody/Darwin is now supported. +.IP \(bu 4 +EPOC is now supported (on Psion 5). +.IP \(bu 4 +The cygwin port (formerly cygwin32) has been greatly improved. +.SS DOS +.IX Subsection "DOS" +.IP \(bu 4 +Perl now works with djgpp 2.02 (and 2.03 alpha). +.IP \(bu 4 +Environment variable names are not converted to uppercase any more. +.IP \(bu 4 +Incorrect exit codes from backticks have been fixed. +.IP \(bu 4 +This port continues to use its own builtin globbing (not File::Glob). +.SS "OS390 (OpenEdition MVS)" +.IX Subsection "OS390 (OpenEdition MVS)" +Support for this EBCDIC platform has not been renewed in this release. +There are difficulties in reconciling Perl's standardization on UTF\-8 +as its internal representation for characters with the EBCDIC character +set, because the two are incompatible. +.PP +It is unclear whether future versions will renew support for this +platform, but the possibility exists. +.SS VMS +.IX Subsection "VMS" +Numerous revisions and extensions to configuration, build, testing, and +installation process to accommodate core changes and VMS-specific options. +.PP +Expand \f(CW%ENV\fR\-handling code to allow runtime mapping to logical names, +CLI symbols, and CRTL environ array. +.PP +Extension of subprocess invocation code to accept filespecs as command +"verbs". +.PP +Add to Perl command line processing the ability to use default file types and +to recognize Unix-style \f(CW\*(C`2>&1\*(C'\fR. +.PP +Expansion of File::Spec::VMS routines, and integration into ExtUtils::MM_VMS. +.PP +Extension of ExtUtils::MM_VMS to handle complex extensions more flexibly. +.PP +Barewords at start of Unix-syntax paths may be treated as text rather than +only as logical names. +.PP +Optional secure translation of several logical names used internally by Perl. +.PP +Miscellaneous bugfixing and porting of new core code to VMS. +.PP +Thanks are gladly extended to the many people who have contributed VMS +patches, testing, and ideas. +.SS Win32 +.IX Subsection "Win32" +Perl can now emulate \fBfork()\fR internally, using multiple interpreters running +in different concurrent threads. This support must be enabled at build +time. See perlfork for detailed information. +.PP +When given a pathname that consists only of a drivename, such as \f(CW\*(C`A:\*(C'\fR, +\&\fBopendir()\fR and \fBstat()\fR now use the current working directory for the drive +rather than the drive root. +.PP +The builtin XSUB functions in the Win32:: namespace are documented. See +Win32. +.PP +$^X now contains the full path name of the running executable. +.PP +A \fBWin32::GetLongPathName()\fR function is provided to complement +\&\fBWin32::GetFullPathName()\fR and \fBWin32::GetShortPathName()\fR. See Win32. +.PP +\&\fBPOSIX::uname()\fR is supported. +.PP +system(1,...) now returns true process IDs rather than process +handles. \fBkill()\fR accepts any real process id, rather than strictly +return values from system(1,...). +.PP +For better compatibility with Unix, \f(CW\*(C`kill(0, $pid)\*(C'\fR can now be used to +test whether a process exists. +.PP +The \f(CW\*(C`Shell\*(C'\fR module is supported. +.PP +Better support for building Perl under command.com in Windows 95 +has been added. +.PP +Scripts are read in binary mode by default to allow ByteLoader (and +the filter mechanism in general) to work properly. For compatibility, +the DATA filehandle will be set to text mode if a carriage return is +detected at the end of the line containing the _\|_END_\|_ or _\|_DATA_\|_ +token; if not, the DATA filehandle will be left open in binary mode. +Earlier versions always opened the DATA filehandle in text mode. +.PP +The \fBglob()\fR operator is implemented via the \f(CW\*(C`File::Glob\*(C'\fR extension, +which supports glob syntax of the C shell. This increases the flexibility +of the \fBglob()\fR operator, but there may be compatibility issues for +programs that relied on the older globbing syntax. If you want to +preserve compatibility with the older syntax, you might want to run +perl with \f(CW\*(C`\-MFile::DosGlob\*(C'\fR. For details and compatibility information, +see File::Glob. +.SH "Significant bug fixes" +.IX Header "Significant bug fixes" +.SS "<HANDLE> on empty files" +.IX Subsection "<HANDLE> on empty files" +With \f(CW$/\fR set to \f(CW\*(C`undef\*(C'\fR, "slurping" an empty file returns a string of +zero length (instead of \f(CW\*(C`undef\*(C'\fR, as it used to) the first time the +HANDLE is read after \f(CW$/\fR is set to \f(CW\*(C`undef\*(C'\fR. Further reads yield +\&\f(CW\*(C`undef\*(C'\fR. +.PP +This means that the following will append "foo" to an empty file (it used +to do nothing): +.PP +.Vb 1 +\& perl \-0777 \-pi \-e \*(Aqs/^/foo/\*(Aq empty_file +.Ve +.PP +The behaviour of: +.PP +.Vb 1 +\& perl \-pi \-e \*(Aqs/^/foo/\*(Aq empty_file +.Ve +.PP +is unchanged (it continues to leave the file empty). +.ie n .SS """eval \*(Aq...\*(Aq"" improvements" +.el .SS "\f(CWeval \*(Aq...\*(Aq\fP improvements" +.IX Subsection "eval ... improvements" +Line numbers (as reflected by \fBcaller()\fR and most diagnostics) within +\&\f(CW\*(C`eval \*(Aq...\*(Aq\*(C'\fR were often incorrect where here documents were involved. +This has been corrected. +.PP +Lexical lookups for variables appearing in \f(CW\*(C`eval \*(Aq...\*(Aq\*(C'\fR within +functions that were themselves called within an \f(CW\*(C`eval \*(Aq...\*(Aq\*(C'\fR were +searching the wrong place for lexicals. The lexical search now +correctly ends at the subroutine's block boundary. +.PP +The use of \f(CW\*(C`return\*(C'\fR within \f(CW\*(C`eval {...}\*(C'\fR caused $@ not to be reset +correctly when no exception occurred within the eval. This has +been fixed. +.PP +Parsing of here documents used to be flawed when they appeared as +the replacement expression in \f(CW\*(C`eval \*(Aqs/.../.../e\*(Aq\*(C'\fR. This has +been fixed. +.SS "All compilation errors are true errors" +.IX Subsection "All compilation errors are true errors" +Some "errors" encountered at compile time were by necessity +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. +.PP +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 \f(CW\*(C`eval STRING\*(C'\fR, and +also allows such errors to be reliably trapped using \f(CW\*(C`eval "..."\*(C'\fR. +.SS "Implicitly closed filehandles are safer" +.IX Subsection "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. +.SS "Behavior of list slices is more consistent" +.IX Subsection "Behavior of list slices is more consistent" +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. +.PP +The new behavior is to produce an empty list if (and only if) +the original list was empty. Consider the following example: +.PP +.Vb 1 +\& @a = (1,undef,undef,2)[2,1,2]; +.Ve +.PP +The old behavior would have resulted in \f(CW@a\fR having no elements. +The new behavior ensures it has three undefined elements. +.PP +Note in particular that the behavior of slices of the following +cases remains unchanged: +.PP +.Vb 5 +\& @a = ()[1,2]; +\& @a = (getpwent)[7,0]; +\& @a = (anything_returning_empty_list())[2,1,2]; +\& @a = @b[2,1,2]; +\& @a = @c{\*(Aqa\*(Aq,\*(Aqb\*(Aq,\*(Aqc\*(Aq}; +.Ve +.PP +See perldata. +.ie n .SS """(\e$)"" prototype and $foo{a}" +.el .SS "\f(CW(\e$)\fP prototype and \f(CW$foo{a}\fP" +.IX Subsection "($) prototype and $foo{a}" +A scalar reference prototype now correctly allows a hash or +array element in that slot. +.ie n .SS """goto &sub"" and AUTOLOAD" +.el .SS "\f(CWgoto &sub\fP and AUTOLOAD" +.IX Subsection "goto &sub and AUTOLOAD" +The \f(CW\*(C`goto &sub\*(C'\fR construct works correctly when \f(CW&sub\fR happens +to be autoloaded. +.ie n .SS """\-bareword"" allowed under ""use integer""" +.el .SS "\f(CW\-bareword\fP allowed under \f(CWuse integer\fP" +.IX Subsection "-bareword allowed under use integer" +The autoquoting of barewords preceded by \f(CW\*(C`\-\*(C'\fR did not work +in prior versions when the \f(CW\*(C`integer\*(C'\fR pragma was enabled. +This has been fixed. +.SS "Failures in \fBDESTROY()\fP" +.IX Subsection "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. +.SS "Locale bugs fixed" +.IX Subsection "Locale bugs fixed" +\&\fBprintf()\fR and \fBsprintf()\fR previously reset the numeric locale +back to the default "C" locale. This has been fixed. +.PP +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. These warnings have been +discontinued. +.SS "Memory leaks" +.IX Subsection "Memory leaks" +The \f(CW\*(C`eval \*(Aqreturn sub {...}\*(Aq\*(C'\fR construct could sometimes leak +memory. This has been fixed. +.PP +Operations that aren't filehandle constructors used to leak memory +when used on invalid filehandles. This has been fixed. +.PP +Constructs that modified \f(CW@_\fR could fail to deallocate values +in \f(CW@_\fR and thus leak memory. This has been corrected. +.SS "Spurious subroutine stubs after failed subroutine calls" +.IX Subsection "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. +.ie n .SS "Taint failures under ""\-U""" +.el .SS "Taint failures under \f(CW\-U\fP" +.IX Subsection "Taint failures under -U" +When running in unsafe mode, taint violations could sometimes +cause silent failures. This has been fixed. +.ie n .SS "END blocks and the ""\-c"" switch" +.el .SS "END blocks and the \f(CW\-c\fP switch" +.IX Subsection "END blocks and the -c switch" +Prior versions used to run BEGIN \fBand\fR 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 \f(CW\*(C`\-c\*(C'\fR switch +is used, or if compilation fails. +.PP +See "Support for CHECK blocks" for how to run things when the compile +phase ends. +.SS "Potential to leak DATA filehandles" +.IX Subsection "Potential to leak DATA filehandles" +Using the \f(CW\*(C`_\|_DATA_\|_\*(C'\fR 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. +.PP +This caveat is now better explained in the documentation. +See perldata. +.SH "New or Changed Diagnostics" +.IX Header "New or Changed Diagnostics" +.ie n .IP """%s"" variable %s masks earlier declaration in same %s" 4 +.el .IP """%s"" variable \f(CW%s\fR masks earlier declaration in same \f(CW%s\fR" 4 +.IX Item """%s"" variable %s masks earlier declaration in same %s" +(W misc) A "my" or "our" variable has been redeclared in the current scope or statement, +effectively eliminating all access to the previous instance. This is almost +always a typographical error. Note that the earlier variable will still exist +until the end of the scope or until all closure referents to it are +destroyed. +.IP """my sub"" not yet implemented" 4 +.IX Item """my sub"" not yet implemented" +(F) Lexically scoped subroutines are not yet implemented. Don't try that +yet. +.ie n .IP """our"" variable %s redeclared" 4 +.el .IP """our"" variable \f(CW%s\fR redeclared" 4 +.IX Item """our"" variable %s redeclared" +(W misc) You seem to have already declared the same global once before in the +current lexical scope. +.ie n .IP "'!' allowed only after types %s" 4 +.el .IP "'!' allowed only after types \f(CW%s\fR" 4 +.IX Item "'!' allowed only after types %s" +(F) The '!' is allowed in \fBpack()\fR and \fBunpack()\fR only after certain types. +See "pack" in perlfunc. +.IP "/ cannot take a count" 4 +.IX Item "/ cannot take a count" +(F) You had an unpack template indicating a counted-length string, +but you have also specified an explicit size for the string. +See "pack" in perlfunc. +.IP "/ must be followed by a, A or Z" 4 +.IX Item "/ must be followed by a, A or Z" +(F) You had an unpack template indicating a counted-length string, +which must be followed by one of the letters a, A or Z +to indicate what sort of string is to be unpacked. +See "pack" in perlfunc. +.IP "/ must be followed by a*, A* or Z*" 4 +.IX Item "/ must be followed by a*, A* or Z*" +(F) You had a pack template indicating a counted-length string, +Currently the only things that can have their length counted are a*, A* or Z*. +See "pack" in perlfunc. +.IP "/ must follow a numeric type" 4 +.IX Item "/ must follow a numeric type" +(F) You had an unpack template that contained a '#', +but this did not follow some numeric unpack specification. +See "pack" in perlfunc. +.IP "/%s/: Unrecognized escape \e\e%c passed through" 4 +.IX Item "/%s/: Unrecognized escape %c passed through" +(W regexp) You used a backslash-character combination which is not recognized +by Perl. This combination appears in an interpolated variable or a +\&\f(CW\*(C`\*(Aq\*(C'\fR\-delimited regular expression. The character was understood literally. +.IP "/%s/: Unrecognized escape \e\e%c in character class passed through" 4 +.IX Item "/%s/: Unrecognized escape %c in character class passed through" +(W regexp) You used a backslash-character combination which is not recognized +by Perl inside character classes. The character was understood literally. +.IP "/%s/ should probably be written as ""%s""" 4 +.IX Item "/%s/ should probably be written as ""%s""" +(W syntax) You have used a pattern where Perl expected to find a string, +as in the first argument to \f(CW\*(C`join\*(C'\fR. Perl will treat the true +or false result of matching the pattern against \f(CW$_\fR as the string, +which is probably not what you had in mind. +.IP "%s() called too early to check prototype" 4 +.IX Item "%s() called too early to check prototype" +(W prototype) 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 perlsub. +.ie n .IP "%s argument is not a HASH or ARRAY element" 4 +.el .IP "\f(CW%s\fR argument is not a HASH or ARRAY element" 4 +.IX Item "%s argument is not a HASH or ARRAY element" +(F) The argument to \fBexists()\fR must be a hash or array element, such as: +.Sp +.Vb 2 +\& $foo{$bar} +\& $ref\->{"susie"}[12] +.Ve +.ie n .IP "%s argument is not a HASH or ARRAY element or slice" 4 +.el .IP "\f(CW%s\fR argument is not a HASH or ARRAY element or slice" 4 +.IX Item "%s argument is not a HASH or ARRAY element or slice" +(F) The argument to \fBdelete()\fR must be either a hash or array element, such as: +.Sp +.Vb 2 +\& $foo{$bar} +\& $ref\->{"susie"}[12] +.Ve +.Sp +or a hash or array slice, such as: +.Sp +.Vb 2 +\& @foo[$bar, $baz, $xyzzy] +\& @{$ref\->[12]}{"susie", "queue"} +.Ve +.ie n .IP "%s argument is not a subroutine name" 4 +.el .IP "\f(CW%s\fR argument is not a subroutine name" 4 +.IX Item "%s argument is not a subroutine name" +(F) The argument to \fBexists()\fR for \f(CW\*(C`exists &sub\*(C'\fR must be a subroutine +name, and not a subroutine call. \f(CW\*(C`exists &sub()\*(C'\fR will generate this error. +.ie n .IP "%s package attribute may clash with future reserved word: %s" 4 +.el .IP "\f(CW%s\fR package attribute may clash with future reserved word: \f(CW%s\fR" 4 +.IX Item "%s package attribute may clash with future reserved word: %s" +(W reserved) 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 attributes. +.ie n .IP "(in cleanup) %s" 4 +.el .IP "(in cleanup) \f(CW%s\fR" 4 +.IX Item "(in cleanup) %s" +(W misc) This prefix usually indicates that a \fBDESTROY()\fR method raised +the indicated exception. Since destructors are usually called by +the system at arbitrary points during execution, and often a vast +number of times, the warning is issued only once for any number +of failures that would otherwise result in the same message being +repeated. +.Sp +Failure of user callbacks dispatched using the \f(CW\*(C`G_KEEPERR\*(C'\fR flag +could also result in this warning. See "G_KEEPERR" in perlcall. +.IP "<> should be quotes" 4 +.IX Item "<> should be quotes" +(F) You wrote \f(CW\*(C`require <file>\*(C'\fR when you should have written +\&\f(CW\*(C`require \*(Aqfile\*(Aq\*(C'\fR. +.IP "Attempt to join self" 4 +.IX Item "Attempt to join self" +(F) You tried to join a thread from within itself, which is an +impossible task. You may be joining the wrong thread, or you may +need to move the \fBjoin()\fR to some other thread. +.IP "Bad evalled substitution pattern" 4 +.IX Item "Bad evalled substitution pattern" +(F) You've used the /e switch to evaluate the replacement for a +substitution, but perl found a syntax error in the code to evaluate, +most likely an unexpected right brace '}'. +.IP "Bad \fBrealloc()\fR ignored" 4 +.IX Item "Bad realloc() ignored" +(S) An internal routine called \fBrealloc()\fR on something that had never been +\&\fBmalloc()\fRed in the first place. Mandatory, but can be disabled by +setting environment variable \f(CW\*(C`PERL_BADFREE\*(C'\fR to 1. +.IP "Bareword found in conditional" 4 +.IX Item "Bareword found in conditional" +(W bareword) The compiler found a bareword where it expected a conditional, +which often indicates that an || or && was parsed as part of the +last argument of the previous construct, for example: +.Sp +.Vb 1 +\& open FOO || die; +.Ve +.Sp +It may also indicate a misspelled constant that has been interpreted +as a bareword: +.Sp +.Vb 2 +\& use constant TYPO => 1; +\& if (TYOP) { print "foo" } +.Ve +.Sp +The \f(CW\*(C`strict\*(C'\fR pragma is useful in avoiding such errors. +.IP "Binary number > 0b11111111111111111111111111111111 non-portable" 4 +.IX Item "Binary number > 0b11111111111111111111111111111111 non-portable" +(W portable) The binary number you specified is larger than 2**32\-1 +(4294967295) and therefore non-portable between systems. See +perlport for more on portability concerns. +.IP "Bit vector size > 32 non-portable" 4 +.IX Item "Bit vector size > 32 non-portable" +(W portable) Using bit vector sizes larger than 32 is non-portable. +.ie n .IP "Buffer overflow in prime_env_iter: %s" 4 +.el .IP "Buffer overflow in prime_env_iter: \f(CW%s\fR" 4 +.IX Item "Buffer overflow in prime_env_iter: %s" +(W internal) A warning peculiar to VMS. While Perl was preparing to iterate over +\&\f(CW%ENV\fR, it encountered a logical name or symbol definition which was too long, +so it was truncated to the string shown. +.IP "Can't check filesystem of script ""%s""" 4 +.IX Item "Can't check filesystem of script ""%s""" +(P) For some reason you can't check the filesystem of the script for nosuid. +.ie n .IP "Can't declare class for non-scalar %s in ""%s""" 4 +.el .IP "Can't declare class for non-scalar \f(CW%s\fR in ""%s""" 4 +.IX Item "Can't declare class for non-scalar %s in ""%s""" +(S) Currently, only scalar variables can declared with a specific class +qualifier in a "my" or "our" declaration. The semantics may be extended +for other types of variables in future. +.ie n .IP "Can't declare %s in ""%s""" 4 +.el .IP "Can't declare \f(CW%s\fR in ""%s""" 4 +.IX Item "Can't declare %s in ""%s""" +(F) Only scalar, array, and hash variables may be declared as "my" or +"our" variables. They must have ordinary identifiers as names. +.IP "Can't ignore signal CHLD, forcing to default" 4 +.IX Item "Can't ignore signal CHLD, forcing to default" +(W signal) Perl has detected that it is being run with the SIGCHLD signal +(sometimes known as SIGCLD) disabled. Since disabling this signal +will interfere with proper determination of exit status of child +processes, Perl has reset the signal to its default value. +This situation typically indicates that the parent program under +which Perl may be running (e.g., cron) is being very careless. +.IP "Can't modify non-lvalue subroutine call" 4 +.IX Item "Can't modify non-lvalue subroutine call" +(F) Subroutines meant to be used in lvalue context should be declared as +such, see "Lvalue subroutines" in perlsub. +.IP "Can't read CRTL environ" 4 +.IX Item "Can't read CRTL environ" +(S) A warning peculiar to VMS. Perl tried to read an element of \f(CW%ENV\fR +from the CRTL's internal environment array and discovered the array was +missing. You need to figure out where your CRTL misplaced its environ +or define \fIPERL_ENV_TABLES\fR (see perlvms) so that environ is not searched. +.ie n .IP "Can't remove %s: %s, skipping file" 4 +.el .IP "Can't remove \f(CW%s:\fR \f(CW%s\fR, skipping file" 4 +.IX Item "Can't remove %s: %s, skipping file" +(S) You requested an inplace edit without creating a backup file. Perl +was unable to remove the original file to replace it with the modified +file. The file was left unmodified. +.ie n .IP "Can't return %s from lvalue subroutine" 4 +.el .IP "Can't return \f(CW%s\fR from lvalue subroutine" 4 +.IX Item "Can't return %s from lvalue subroutine" +(F) Perl detected an attempt to return illegal lvalues (such +as temporary or readonly values) from a subroutine used as an lvalue. +This is not allowed. +.IP "Can't weaken a nonreference" 4 +.IX Item "Can't weaken a nonreference" +(F) You attempted to weaken something that was not a reference. Only +references can be weakened. +.IP "Character class [:%s:] unknown" 4 +.IX Item "Character class [:%s:] unknown" +(F) The class in the character class [: :] syntax is unknown. +See perlre. +.IP "Character class syntax [%s] belongs inside character classes" 4 +.IX Item "Character class syntax [%s] belongs inside character classes" +(W unsafe) The character class constructs [: :], [= =], and [. .] go +\&\fIinside\fR character classes, the [] are part of the construct, +for example: /[012[:alpha:]345]/. Note that [= =] and [. .] +are not currently implemented; they are simply placeholders for +future extensions. +.ie n .IP "Constant is not %s reference" 4 +.el .IP "Constant is not \f(CW%s\fR reference" 4 +.IX Item "Constant is not %s reference" +(F) A constant value (perhaps declared using the \f(CW\*(C`use constant\*(C'\fR pragma) +is being dereferenced, but it amounts to the wrong type of reference. The +message indicates the type of reference that was expected. This usually +indicates a syntax error in dereferencing the constant value. +See "Constant Functions" in perlsub and constant. +.ie n .IP "constant(%s): %s" 4 +.el .IP "constant(%s): \f(CW%s\fR" 4 +.IX Item "constant(%s): %s" +(F) The parser found inconsistencies either while attempting to define an +overloaded constant, or when trying to find the character name specified +in the \f(CW\*(C`\eN{...}\*(C'\fR escape. Perhaps you forgot to load the corresponding +\&\f(CW\*(C`overload\*(C'\fR or \f(CW\*(C`charnames\*(C'\fR pragma? See charnames and overload. +.IP "CORE::%s is not a keyword" 4 +.IX Item "CORE::%s is not a keyword" +(F) The CORE:: namespace is reserved for Perl keywords. +.IP "defined(@array) is deprecated" 4 +.IX Item "defined(@array) is deprecated" +(D) \fBdefined()\fR is not usually useful on arrays because it checks for an +undefined \fIscalar\fR value. If you want to see if the array is empty, +just use \f(CW\*(C`if (@array) { # not empty }\*(C'\fR for example. +.IP "defined(%hash) is deprecated" 4 +.IX Item "defined(%hash) is deprecated" +(D) \fBdefined()\fR is not usually useful on hashes because it checks for an +undefined \fIscalar\fR value. If you want to see if the hash is empty, +just use \f(CW\*(C`if (%hash) { # not empty }\*(C'\fR for example. +.IP "Did not produce a valid header" 4 +.IX Item "Did not produce a valid header" +See Server error. +.IP "(Did you mean ""local"" instead of ""our""?)" 4 +.IX Item "(Did you mean ""local"" instead of ""our""?)" +(W misc) Remember that "our" does not localize the declared global variable. +You have declared it again in the same lexical scope, which seems superfluous. +.IP "Document contains no data" 4 +.IX Item "Document contains no data" +See Server error. +.ie n .IP "entering effective %s failed" 4 +.el .IP "entering effective \f(CW%s\fR failed" 4 +.IX Item "entering effective %s failed" +(F) While under the \f(CW\*(C`use filetest\*(C'\fR pragma, switching the real and +effective uids or gids failed. +.IP "false [] range ""%s"" in regexp" 4 +.IX Item "false [] range ""%s"" in regexp" +(W regexp) A character class range must start and end at a literal character, not +another character class like \f(CW\*(C`\ed\*(C'\fR or \f(CW\*(C`[:alpha:]\*(C'\fR. The "\-" in your false +range is interpreted as a literal "\-". Consider quoting the "\-", "\e\-". +See perlre. +.ie n .IP "Filehandle %s opened only for output" 4 +.el .IP "Filehandle \f(CW%s\fR opened only for output" 4 +.IX Item "Filehandle %s opened only for output" +(W io) 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 +"+<" or "+>" or "+>>" instead of with "<" or nothing. If +you intended only to read from the file, use "<". See +"open" in perlfunc. +.ie n .IP "\fBflock()\fR on closed filehandle %s" 4 +.el .IP "\fBflock()\fR on closed filehandle \f(CW%s\fR" 4 +.IX Item "flock() on closed filehandle %s" +(W closed) The filehandle you're attempting to \fBflock()\fR got itself closed some +time before now. Check your logic flow. \fBflock()\fR operates on filehandles. +Are you attempting to call \fBflock()\fR on a dirhandle by the same name? +.IP "Global symbol ""%s"" requires explicit package name" 4 +.IX Item "Global symbol ""%s"" requires explicit package name" +(F) You've said "use strict vars", which indicates that all variables +must either be lexically scoped (using "my"), declared beforehand using +"our", or explicitly qualified to say which package the global variable +is in (using "::"). +.IP "Hexadecimal number > 0xffffffff non-portable" 4 +.IX Item "Hexadecimal number > 0xffffffff non-portable" +(W portable) The hexadecimal number you specified is larger than 2**32\-1 +(4294967295) and therefore non-portable between systems. See +perlport for more on portability concerns. +.IP "Ill-formed CRTL environ value ""%s""" 4 +.IX Item "Ill-formed CRTL environ value ""%s""" +(W internal) A warning peculiar to VMS. Perl tried to read the CRTL's internal +environ array, and encountered an element without the \f(CW\*(C`=\*(C'\fR delimiter +used to separate keys from values. The element is ignored. +.IP "Ill-formed message in prime_env_iter: |%s|" 4 +.IX Item "Ill-formed message in prime_env_iter: |%s|" +(W internal) A warning peculiar to VMS. Perl tried to read a logical name +or CLI symbol definition when preparing to iterate over \f(CW%ENV\fR, and +didn't see the expected delimiter between key and value, so the +line was ignored. +.ie n .IP "Illegal binary digit %s" 4 +.el .IP "Illegal binary digit \f(CW%s\fR" 4 +.IX Item "Illegal binary digit %s" +(F) You used a digit other than 0 or 1 in a binary number. +.ie n .IP "Illegal binary digit %s ignored" 4 +.el .IP "Illegal binary digit \f(CW%s\fR ignored" 4 +.IX Item "Illegal binary digit %s ignored" +(W digit) You may have tried to use a digit other than 0 or 1 in a binary number. +Interpretation of the binary number stopped before the offending digit. +.IP "Illegal number of bits in vec" 4 +.IX Item "Illegal number of bits in vec" +(F) The number of bits in \fBvec()\fR (the third argument) must be a power of +two from 1 to 32 (or 64, if your platform supports that). +.ie n .IP "Integer overflow in %s number" 4 +.el .IP "Integer overflow in \f(CW%s\fR number" 4 +.IX Item "Integer overflow in %s number" +(W overflow) The hexadecimal, octal or binary number you have specified either +as a literal or as an argument to \fBhex()\fR or \fBoct()\fR is too big for your +architecture, and has been converted to a floating point number. On a +32\-bit architecture the largest hexadecimal, octal or binary number +representable without overflow is 0xFFFFFFFF, 037777777777, or +0b11111111111111111111111111111111 respectively. Note that Perl +transparently promotes all numbers to a floating point representation +internally\-\-subject to loss of precision errors in subsequent +operations. +.ie n .IP "Invalid %s attribute: %s" 4 +.el .IP "Invalid \f(CW%s\fR attribute: \f(CW%s\fR" 4 +.IX 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 attributes. +.ie n .IP "Invalid %s attributes: %s" 4 +.el .IP "Invalid \f(CW%s\fR attributes: \f(CW%s\fR" 4 +.IX 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 attributes. +.IP "invalid [] range ""%s"" in regexp" 4 +.IX Item "invalid [] range ""%s"" in regexp" +The offending range is now explicitly displayed. +.ie n .IP "Invalid separator character %s in attribute list" 4 +.el .IP "Invalid separator character \f(CW%s\fR in attribute list" 4 +.IX Item "Invalid separator character %s in attribute list" +(F) Something other than a colon 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 attributes. +.ie n .IP "Invalid separator character %s in subroutine attribute list" 4 +.el .IP "Invalid separator character \f(CW%s\fR in subroutine attribute list" 4 +.IX Item "Invalid separator character %s in subroutine attribute list" +(F) Something other than a colon 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. +.ie n .IP "leaving effective %s failed" 4 +.el .IP "leaving effective \f(CW%s\fR failed" 4 +.IX Item "leaving effective %s failed" +(F) While under the \f(CW\*(C`use filetest\*(C'\fR pragma, switching the real and +effective uids or gids failed. +.ie n .IP "Lvalue subs returning %s not implemented yet" 4 +.el .IP "Lvalue subs returning \f(CW%s\fR not implemented yet" 4 +.IX Item "Lvalue subs returning %s not implemented yet" +(F) Due to limitations in the current implementation, array and hash +values cannot be returned in subroutines used in lvalue context. +See "Lvalue subroutines" in perlsub. +.ie n .IP "Method %s not permitted" 4 +.el .IP "Method \f(CW%s\fR not permitted" 4 +.IX Item "Method %s not permitted" +See Server error. +.ie n .IP "Missing %sbrace%s on \eN{}" 4 +.el .IP "Missing \f(CW%sbrace\fR%s on \eN{}" 4 +.IX Item "Missing %sbrace%s on N{}" +(F) Wrong syntax of character name literal \f(CW\*(C`\eN{charname}\*(C'\fR within +double-quotish context. +.IP "Missing command in piped open" 4 +.IX Item "Missing command in piped open" +(W pipe) You used the \f(CW\*(C`open(FH, "| command")\*(C'\fR or \f(CW\*(C`open(FH, "command |")\*(C'\fR +construction, but the command was missing or blank. +.IP "Missing name in ""my sub""" 4 +.IX Item "Missing name in ""my sub""" +(F) The reserved syntax for lexically scoped subroutines requires that they +have a name with which they can be found. +.ie n .IP "No %s specified for \-%c" 4 +.el .IP "No \f(CW%s\fR specified for \-%c" 4 +.IX Item "No %s specified for -%c" +(F) The indicated command line switch needs a mandatory argument, but +you haven't specified one. +.ie n .IP "No package name allowed for variable %s in ""our""" 4 +.el .IP "No package name allowed for variable \f(CW%s\fR in ""our""" 4 +.IX Item "No package name allowed for variable %s in ""our""" +(F) Fully qualified variable names are not allowed in "our" declarations, +because that doesn't make much sense under existing semantics. Such +syntax is reserved for future extensions. +.IP "No space allowed after \-%c" 4 +.IX Item "No space allowed after -%c" +(F) The argument to the indicated command line switch must follow immediately +after the switch, without intervening spaces. +.IP "no UTC offset information; assuming local time is UTC" 4 +.IX Item "no UTC offset information; assuming local time is UTC" +(S) A warning peculiar to VMS. Perl was unable to find the local +timezone offset, so it's assuming that local system time is equivalent +to UTC. If it's not, define the logical name \fISYS$TIMEZONE_DIFFERENTIAL\fR +to translate to the number of seconds which need to be added to UTC to +get local time. +.IP "Octal number > 037777777777 non-portable" 4 +.IX Item "Octal number > 037777777777 non-portable" +(W portable) The octal number you specified is larger than 2**32\-1 (4294967295) +and therefore non-portable between systems. See perlport for more +on portability concerns. +.Sp +See also perlport for writing portable code. +.IP "panic: del_backref" 4 +.IX Item "panic: del_backref" +(P) Failed an internal consistency check while trying to reset a weak +reference. +.IP "panic: kid popen errno read" 4 +.IX Item "panic: kid popen errno read" +(F) forked child returned an incomprehensible message about its errno. +.IP "panic: magic_killbackrefs" 4 +.IX Item "panic: magic_killbackrefs" +(P) Failed an internal consistency check while trying to reset all weak +references to an object. +.IP "Parentheses missing around ""%s"" list" 4 +.IX Item "Parentheses missing around ""%s"" list" +(W parenthesis) You said something like +.Sp +.Vb 1 +\& my $foo, $bar = @_; +.Ve +.Sp +when you meant +.Sp +.Vb 1 +\& my ($foo, $bar) = @_; +.Ve +.Sp +Remember that "my", "our", and "local" bind tighter than comma. +.ie n .IP "Possible unintended interpolation of %s in string" 4 +.el .IP "Possible unintended interpolation of \f(CW%s\fR in string" 4 +.IX Item "Possible unintended interpolation of %s in string" +(W ambiguous) It used to be that Perl would try to guess whether you +wanted an array interpolated or a literal @. It no longer does this; +arrays are now \fIalways\fR interpolated into strings. This means that +if you try something like: +.Sp +.Vb 1 +\& print "fred@example.com"; +.Ve +.Sp +and the array \f(CW@example\fR doesn't exist, Perl is going to print +\&\f(CW\*(C`fred.com\*(C'\fR, which is probably not what you wanted. To get a literal +\&\f(CW\*(C`@\*(C'\fR sign in a string, put a backslash before it, just as you would +to get a literal \f(CW\*(C`$\*(C'\fR sign. +.ie n .IP "Possible Y2K bug: %s" 4 +.el .IP "Possible Y2K bug: \f(CW%s\fR" 4 +.IX Item "Possible Y2K bug: %s" +(W y2k) You are concatenating the number 19 with another number, which +could be a potential Year 2000 problem. +.IP "pragma ""attrs"" is deprecated, use ""sub NAME : ATTRS"" instead" 4 +.IX Item "pragma ""attrs"" is deprecated, use ""sub NAME : ATTRS"" instead" +(W deprecated) You have written something like this: +.Sp +.Vb 4 +\& sub doit +\& { +\& use attrs qw(locked); +\& } +.Ve +.Sp +You should use the new declaration syntax instead. +.Sp +.Vb 3 +\& sub doit : locked +\& { +\& ... +.Ve +.Sp +The \f(CW\*(C`use attrs\*(C'\fR pragma is now obsolete, and is only provided for +backward-compatibility. See "Subroutine Attributes" in perlsub. +.IP "Premature end of script headers" 4 +.IX Item "Premature end of script headers" +See Server error. +.IP "Repeat count in pack overflows" 4 +.IX Item "Repeat count in pack overflows" +(F) You can't specify a repeat count so large that it overflows +your signed integers. See "pack" in perlfunc. +.IP "Repeat count in unpack overflows" 4 +.IX Item "Repeat count in unpack overflows" +(F) You can't specify a repeat count so large that it overflows +your signed integers. See "unpack" in perlfunc. +.IP "\fBrealloc()\fR of freed memory ignored" 4 +.IX Item "realloc() of freed memory ignored" +(S) An internal routine called \fBrealloc()\fR on something that had already +been freed. +.IP "Reference is already weak" 4 +.IX Item "Reference is already weak" +(W misc) You have attempted to weaken a reference that is already weak. +Doing so has no effect. +.IP "setpgrp can't take arguments" 4 +.IX Item "setpgrp can't take arguments" +(F) Your system has the \fBsetpgrp()\fR from BSD 4.2, which takes no arguments, +unlike POSIX \fBsetpgid()\fR, which takes a process ID and process group ID. +.IP "Strange *+?{} on zero-length expression" 4 +.IX Item "Strange *+?{} on zero-length expression" +(W regexp) You applied a regular expression quantifier in a place where it +makes no sense, such as on a zero-width assertion. +Try putting the quantifier inside the assertion instead. For example, +the way to match "abc" provided that it is followed by three +repetitions of "xyz" is \f(CW\*(C`/abc(?=(?:xyz){3})/\*(C'\fR, not \f(CW\*(C`/abc(?=xyz){3}/\*(C'\fR. +.ie n .IP "switching effective %s is not implemented" 4 +.el .IP "switching effective \f(CW%s\fR is not implemented" 4 +.IX Item "switching effective %s is not implemented" +(F) While under the \f(CW\*(C`use filetest\*(C'\fR pragma, we cannot switch the +real and effective uids or gids. +.IP "This Perl can't reset CRTL environ elements (%s)" 4 +.IX Item "This Perl can't reset CRTL environ elements (%s)" +.PD 0 +.IP "This Perl can't set CRTL environ elements (%s=%s)" 4 +.IX Item "This Perl can't set CRTL environ elements (%s=%s)" +.PD +(W internal) Warnings peculiar to VMS. You tried to change or delete an element +of the CRTL's internal environ array, but your copy of Perl wasn't +built with a CRTL that contained the \fBsetenv()\fR function. You'll need to +rebuild Perl with a CRTL that does, or redefine \fIPERL_ENV_TABLES\fR (see +perlvms) so that the environ array isn't the target of the change to +\&\f(CW%ENV\fR which produced the warning. +.ie n .IP "Too late to run %s block" 4 +.el .IP "Too late to run \f(CW%s\fR block" 4 +.IX Item "Too late to run %s block" +(W void) A CHECK or INIT block is being defined during run time proper, +when the opportunity to run them has already passed. Perhaps you are +loading a file with \f(CW\*(C`require\*(C'\fR or \f(CW\*(C`do\*(C'\fR when you should be using +\&\f(CW\*(C`use\*(C'\fR instead. Or perhaps you should put the \f(CW\*(C`require\*(C'\fR or \f(CW\*(C`do\*(C'\fR +inside a BEGIN block. +.IP "Unknown \fBopen()\fR mode '%s'" 4 +.IX Item "Unknown open() mode '%s'" +(F) The second argument of 3\-argument \fBopen()\fR is not among the list +of valid modes: \f(CW\*(C`<\*(C'\fR, \f(CW\*(C`>\*(C'\fR, \f(CW\*(C`>>\*(C'\fR, \f(CW\*(C`+<\*(C'\fR, +\&\f(CW\*(C`+>\*(C'\fR, \f(CW\*(C`+>>\*(C'\fR, \f(CW\*(C`\-|\*(C'\fR, \f(CW\*(C`|\-\*(C'\fR. +.ie n .IP "Unknown process %x sent message to prime_env_iter: %s" 4 +.el .IP "Unknown process \f(CW%x\fR sent message to prime_env_iter: \f(CW%s\fR" 4 +.IX Item "Unknown process %x sent message to prime_env_iter: %s" +(P) An error peculiar to VMS. Perl was reading values for \f(CW%ENV\fR before +iterating over it, and someone else stuck a message in the stream of +data Perl expected. Someone's very confused, or perhaps trying to +subvert Perl's population of \f(CW%ENV\fR for nefarious purposes. +.IP "Unrecognized escape \e\e%c passed through" 4 +.IX Item "Unrecognized escape %c passed through" +(W misc) You used a backslash-character combination which is not recognized +by Perl. The character was understood literally. +.IP "Unterminated attribute parameter in attribute list" 4 +.IX 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 attributes. +.IP "Unterminated attribute list" 4 +.IX 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 attributes. +.IP "Unterminated attribute parameter in subroutine attribute list" 4 +.IX 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. +.IP "Unterminated subroutine attribute list" 4 +.IX 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. +.IP "Value of CLI symbol ""%s"" too long" 4 +.IX Item "Value of CLI symbol ""%s"" too long" +(W misc) A warning peculiar to VMS. Perl tried to read the value of an \f(CW%ENV\fR +element from a CLI symbol table, and found a resultant string longer +than 1024 characters. The return value has been truncated to 1024 +characters. +.IP "Version number must be a constant number" 4 +.IX Item "Version number must be a constant number" +(P) The attempt to translate a \f(CW\*(C`use Module n.n LIST\*(C'\fR statement into +its equivalent \f(CW\*(C`BEGIN\*(C'\fR block found an internal inconsistency with +the version number. +.SH "New tests" +.IX Header "New tests" +.IP lib/attrs 4 +.IX Item "lib/attrs" +Compatibility tests for \f(CW\*(C`sub : attrs\*(C'\fR vs the older \f(CW\*(C`use attrs\*(C'\fR. +.IP lib/env 4 +.IX Item "lib/env" +Tests for new environment scalar capability (e.g., \f(CW\*(C`use Env qw($BAR);\*(C'\fR). +.IP lib/env\-array 4 +.IX Item "lib/env-array" +Tests for new environment array capability (e.g., \f(CW\*(C`use Env qw(@PATH);\*(C'\fR). +.IP lib/io_const 4 +.IX Item "lib/io_const" +IO constants (SEEK_*, _IO*). +.IP lib/io_dir 4 +.IX Item "lib/io_dir" +Directory-related IO methods (new, read, close, rewind, tied delete). +.IP lib/io_multihomed 4 +.IX Item "lib/io_multihomed" +INET sockets with multi-homed hosts. +.IP lib/io_poll 4 +.IX Item "lib/io_poll" +IO \fBpoll()\fR. +.IP lib/io_unix 4 +.IX Item "lib/io_unix" +UNIX sockets. +.IP op/attrs 4 +.IX Item "op/attrs" +Regression tests for \f(CW\*(C`my ($x,@y,%z) : attrs\*(C'\fR and <sub : attrs>. +.IP op/filetest 4 +.IX Item "op/filetest" +File test operators. +.IP op/lex_assign 4 +.IX Item "op/lex_assign" +Verify operations that access pad objects (lexicals and temporaries). +.IP op/exists_sub 4 +.IX Item "op/exists_sub" +Verify \f(CW\*(C`exists &sub\*(C'\fR operations. +.SH "Incompatible Changes" +.IX Header "Incompatible Changes" +.SS "Perl Source Incompatibilities" +.IX Subsection "Perl Source Incompatibilities" +Beware that any new warnings that have been added or old ones +that have been enhanced are \fBnot\fR considered incompatible changes. +.PP +Since all new warnings must be explicitly requested via the \f(CW\*(C`\-w\*(C'\fR +switch or the \f(CW\*(C`warnings\*(C'\fR pragma, it is ultimately the programmer's +responsibility to ensure that warnings are enabled judiciously. +.IP "CHECK is a new keyword" 4 +.IX Item "CHECK is a new keyword" +All subroutine definitions named CHECK are now special. See +\&\f(CW\*(C`/"Support for CHECK blocks"\*(C'\fR for more information. +.IP "Treatment of list slices of undef has changed" 4 +.IX Item "Treatment of list slices of undef has changed" +There is a potential incompatibility in the behavior of list slices +that are comprised entirely of undefined values. +See "Behavior of list slices is more consistent". +.ie n .IP "Format of $English::PERL_VERSION is different" 4 +.el .IP "Format of \f(CW$English::PERL_VERSION\fR is different" 4 +.IX Item "Format of $English::PERL_VERSION is different" +The English module now sets \f(CW$PERL_VERSION\fR to $^V (a string value) rather +than \f(CW$]\fR (a numeric value). This is a potential incompatibility. +Send us a report via perlbug if you are affected by this. +.Sp +See "Improved Perl version numbering system" for the reasons for +this change. +.ie n .IP "Literals of the form 1.2.3 parse differently" 4 +.el .IP "Literals of the form \f(CW1.2.3\fR parse differently" 4 +.IX Item "Literals of the form 1.2.3 parse differently" +Previously, numeric literals with more than one dot in them were +interpreted as a floating point number concatenated with one or more +numbers. Such "numbers" are now parsed as strings composed of the +specified ordinals. +.Sp +For example, \f(CW\*(C`print 97.98.99\*(C'\fR used to output \f(CW97.9899\fR in earlier +versions, but now prints \f(CW\*(C`abc\*(C'\fR. +.Sp +See "Support for strings represented as a vector of ordinals". +.IP "Possibly changed pseudo-random number generator" 4 +.IX Item "Possibly changed pseudo-random number generator" +Perl programs that depend on reproducing a specific set of pseudo-random +numbers may now produce different output due to improvements made to the +\&\fBrand()\fR builtin. You can use \f(CW\*(C`sh Configure \-Drandfunc=rand\*(C'\fR to obtain +the old behavior. +.Sp +See "Better pseudo-random number generator". +.IP "Hashing function for hash keys has changed" 4 +.IX Item "Hashing function for hash keys has changed" +Even though Perl hashes are not order preserving, the apparently +random order encountered when iterating on the contents of a hash +is actually determined by the hashing algorithm used. Improvements +in the algorithm may yield a random order that is \fBdifferent\fR from +that of previous versions, especially when iterating on hashes. +.Sp +See "Better worst-case behavior of hashes" for additional +information. +.ie n .IP """undef"" fails on read only values" 4 +.el .IP "\f(CWundef\fR fails on read only values" 4 +.IX Item "undef fails on read only values" +Using the \f(CW\*(C`undef\*(C'\fR operator on a readonly value (such as \f(CW$1\fR) has +the same effect as assigning \f(CW\*(C`undef\*(C'\fR to the readonly value\-\-it +throws an exception. +.IP "Close-on-exec bit may be set on pipe and socket handles" 4 +.IX Item "Close-on-exec bit may be set on pipe and socket handles" +Pipe and socket handles are also now subject to the close-on-exec +behavior determined by the special variable $^F. +.Sp +See "More consistent close-on-exec behavior". +.ie n .IP "Writing ""$$1"" to mean ""${$}1"" is unsupported" 4 +.el .IP "Writing \f(CW""$$1""\fR to mean \f(CW""${$}1""\fR is unsupported" 4 +.IX Item "Writing ""$$1"" to mean ""${$}1"" is unsupported" +Perl 5.004 deprecated the interpretation of \f(CW$$1\fR and +similar within interpolated strings to mean \f(CW\*(C`$$ . "1"\*(C'\fR, +but still allowed it. +.Sp +In Perl 5.6.0 and later, \f(CW"$$1"\fR always means \f(CW"${$1}"\fR. +.ie n .IP "\fBdelete()\fR, \fBeach()\fR, \fBvalues()\fR and ""\e(%h)""" 4 +.el .IP "\fBdelete()\fR, \fBeach()\fR, \fBvalues()\fR and \f(CW\e(%h)\fR" 4 +.IX Item "delete(), each(), values() and )" +operate on aliases to values, not copies +.Sp +\&\fBdelete()\fR, \fBeach()\fR, \fBvalues()\fR and hashes (e.g. \f(CW\*(C`\e(%h)\*(C'\fR) +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 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. +.Sp +See also "\fBdelete()\fR, \fBeach()\fR, \fBvalues()\fR and hash iteration are faster". +.IP "vec(EXPR,OFFSET,BITS) enforces powers-of-two BITS" 4 +.IX Item "vec(EXPR,OFFSET,BITS) enforces powers-of-two BITS" +\&\fBvec()\fR generates a run-time error if the BITS argument is not +a valid power-of-two integer. +.IP "Text of some diagnostic output has changed" 4 +.IX 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. +.ie n .IP """%@"" has been removed" 4 +.el .IP "\f(CW%@\fR has been removed" 4 +.IX Item "%@ has been removed" +The undocumented special variable \f(CW\*(C`%@\*(C'\fR that used to accumulate +"background" errors (such as those that happen in \fBDESTROY()\fR) +has been removed, because it could potentially result in memory +leaks. +.IP "Parenthesized \fBnot()\fR behaves like a list operator" 4 +.IX Item "Parenthesized not() behaves like a list operator" +The \f(CW\*(C`not\*(C'\fR operator now falls under the "if it looks like a function, +it behaves like a function" rule. +.Sp +As a result, the parenthesized form can be used with \f(CW\*(C`grep\*(C'\fR and \f(CW\*(C`map\*(C'\fR. +The following construct used to be a syntax error before, but it works +as expected now: +.Sp +.Vb 1 +\& grep not($_), @things; +.Ve +.Sp +On the other hand, using \f(CW\*(C`not\*(C'\fR with a literal list slice may not +work. The following previously allowed construct: +.Sp +.Vb 1 +\& print not (1,2,3)[0]; +.Ve +.Sp +needs to be written with additional parentheses now: +.Sp +.Vb 1 +\& print not((1,2,3)[0]); +.Ve +.Sp +The behavior remains unaffected when \f(CW\*(C`not\*(C'\fR is not followed by parentheses. +.ie n .IP "Semantics of bareword prototype ""(*)"" have changed" 4 +.el .IP "Semantics of bareword prototype \f(CW(*)\fR have changed" 4 +.IX Item "Semantics of bareword prototype (*) have changed" +The semantics of the bareword prototype \f(CW\*(C`*\*(C'\fR have changed. Perl 5.005 +always coerced simple scalar arguments to a typeglob, which wasn't useful +in situations where the subroutine must distinguish between a simple +scalar and a typeglob. The new behavior is to not coerce bareword +arguments to a typeglob. The value will always be visible as either +a simple scalar or as a reference to a typeglob. +.Sp +See "More functional bareword prototype (*)". +.IP "Semantics of bit operators may have changed on 64\-bit platforms" 4 +.IX Item "Semantics of bit operators may have changed on 64-bit platforms" +If your platform is either natively 64\-bit or if Perl has been +configured to used 64\-bit integers, i.e., \f(CW$Config\fR{ivsize} is 8, +there may be a potential incompatibility in the behavior of bitwise +numeric operators (& | ^ ~ << >>). These operators used to strictly +operate on the lower 32 bits of integers in previous versions, but now +operate over the entire native integral width. In particular, note +that unary \f(CW\*(C`~\*(C'\fR will produce different results on platforms that have +different \f(CW$Config\fR{ivsize}. For portability, be sure to mask off +the excess bits in the result of unary \f(CW\*(C`~\*(C'\fR, e.g., \f(CW\*(C`~$x & 0xffffffff\*(C'\fR. +.Sp +See "Bit operators support full native integer width". +.IP "More builtins taint their results" 4 +.IX Item "More builtins taint their results" +As described in "Improved security features", there may be more +sources of taint in a Perl program. +.Sp +To avoid these new tainting behaviors, you can build Perl with the +Configure option \f(CW\*(C`\-Accflags=\-DINCOMPLETE_TAINTS\*(C'\fR. Beware that the +ensuing perl binary may be insecure. +.SS "C Source Incompatibilities" +.IX Subsection "C Source Incompatibilities" +.ie n .IP """PERL_POLLUTE""" 4 +.el .IP \f(CWPERL_POLLUTE\fR 4 +.IX Item "PERL_POLLUTE" +Release 5.005 grandfathered old global symbol names by providing preprocessor +macros for extension source compatibility. As of release 5.6.0, these +preprocessor definitions are not available by default. You need to explicitly +compile perl with \f(CW\*(C`\-DPERL_POLLUTE\*(C'\fR to get these definitions. For +extensions still using the old symbols, this option can be +specified via MakeMaker: +.Sp +.Vb 1 +\& perl Makefile.PL POLLUTE=1 +.Ve +.ie n .IP """PERL_IMPLICIT_CONTEXT""" 4 +.el .IP \f(CWPERL_IMPLICIT_CONTEXT\fR 4 +.IX Item "PERL_IMPLICIT_CONTEXT" +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 \f(CW\*(C`sv_setsv(foo,bar)\*(C'\fR +amounts to a macro invocation that actually translates to something like +\&\f(CW\*(C`Perl_sv_setsv(my_perl,foo,bar)\*(C'\fR. 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. +.Sp +This means that there \fBis\fR a source compatibility issue as a result of +this if your extensions attempt to use pointers to any of the Perl API +functions. +.Sp +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). +.Sp +See "Background and PERL_IMPLICIT_CONTEXT" in perlguts for detailed information on the +ramifications of building Perl with this option. +.Sp +.Vb 3 +\& NOTE: PERL_IMPLICIT_CONTEXT is automatically enabled whenever Perl is built +\& with one of \-Dusethreads, \-Dusemultiplicity, or both. It is not +\& intended to be enabled by users at this time. +.Ve +.ie n .IP """PERL_POLLUTE_MALLOC""" 4 +.el .IP \f(CWPERL_POLLUTE_MALLOC\fR 4 +.IX Item "PERL_POLLUTE_MALLOC" +Enabling Perl's malloc in release 5.005 and earlier caused the namespace of +the system's 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. +.Sp +As of release 5.6.0, Perl's malloc family of functions have default names +distinct from the system versions. You need to explicitly compile perl with +\&\f(CW\*(C`\-DPERL_POLLUTE_MALLOC\*(C'\fR to get the older behaviour. HIDEMYMALLOC +and EMBEDMYMALLOC have no effect, since the behaviour they enabled is now +the default. +.Sp +Note that these functions do \fBnot\fR constitute Perl's memory allocation API. +See "Memory Allocation" in perlguts for further information about that. +.SS "Compatible C Source API Changes" +.IX Subsection "Compatible C Source API Changes" +.ie n .IP """PATCHLEVEL"" is now ""PERL_VERSION""" 4 +.el .IP "\f(CWPATCHLEVEL\fR is now \f(CWPERL_VERSION\fR" 4 +.IX Item "PATCHLEVEL is now PERL_VERSION" +The cpp macros \f(CW\*(C`PERL_REVISION\*(C'\fR, \f(CW\*(C`PERL_VERSION\*(C'\fR, and \f(CW\*(C`PERL_SUBVERSION\*(C'\fR +are now available by default from perl.h, and reflect the base revision, +patchlevel, and subversion respectively. \f(CW\*(C`PERL_REVISION\*(C'\fR had no +prior equivalent, while \f(CW\*(C`PERL_VERSION\*(C'\fR and \f(CW\*(C`PERL_SUBVERSION\*(C'\fR were +previously available as \f(CW\*(C`PATCHLEVEL\*(C'\fR and \f(CW\*(C`SUBVERSION\*(C'\fR. +.Sp +The new names cause less pollution of the \fBcpp\fR namespace and reflect what +the numbers have come to stand for in common practice. For compatibility, +the old names are still supported when \fIpatchlevel.h\fR is explicitly +included (as required before), so there is no source incompatibility +from the change. +.SS "Binary Incompatibilities" +.IX Subsection "Binary Incompatibilities" +In general, the default build of this release is expected to be binary +compatible for extensions built with the 5.005 release or its maintenance +versions. However, specific platforms may have broken binary compatibility +due to changes in the defaults used in hints files. Therefore, please be +sure to always check the platform-specific README files for any notes to +the contrary. +.PP +The usethreads or usemultiplicity builds are \fBnot\fR binary compatible +with the corresponding builds in 5.005. +.PP +On platforms that require an explicit list of exports (AIX, OS/2 and Windows, +among others), purely internal symbols such as parser functions and the +run time opcodes are not exported by default. Perl 5.005 used to export +all functions irrespective of whether they were considered part of the +public API or not. +.PP +For the full list of public API functions, see perlapi. +.SH "Known Problems" +.IX Header "Known Problems" +.SS "Thread test failures" +.IX Subsection "Thread test failures" +The subtests 19 and 20 of lib/thr5005.t test are known to fail due to +fundamental problems in the 5.005 threading implementation. These are +not new failures\-\-Perl 5.005_0x has the same bugs, but didn't have these +tests. +.SS "EBCDIC platforms not supported" +.IX Subsection "EBCDIC platforms not supported" +In earlier releases of Perl, EBCDIC environments like OS390 (also +known as Open Edition MVS) and VM-ESA were supported. Due to changes +required by the UTF\-8 (Unicode) support, the EBCDIC platforms are not +supported in Perl 5.6.0. +.SS "In 64\-bit HP-UX the lib/io_multihomed test may hang" +.IX Subsection "In 64-bit HP-UX the lib/io_multihomed test may hang" +The lib/io_multihomed test may hang in HP-UX if Perl has been +configured to be 64\-bit. Because other 64\-bit platforms do not +hang in this test, HP-UX is suspect. All other tests pass +in 64\-bit HP-UX. The test attempts to create and connect to +"multihomed" sockets (sockets which have multiple IP addresses). +.SS "NEXTSTEP 3.3 POSIX test failure" +.IX Subsection "NEXTSTEP 3.3 POSIX test failure" +In NEXTSTEP 3.3p2 the implementation of the \fBstrftime\fR\|(3) in the +operating system libraries is buggy: the \f(CW%j\fR format numbers the days of +a month starting from zero, which, while being logical to programmers, +will cause the subtests 19 to 27 of the lib/posix test may fail. +.SS "Tru64 (aka Digital UNIX, aka DEC OSF/1) lib/sdbm test failure with gcc" +.IX Subsection "Tru64 (aka Digital UNIX, aka DEC OSF/1) lib/sdbm test failure with gcc" +If compiled with gcc 2.95 the lib/sdbm test will fail (dump core). +The cure is to use the vendor cc, it comes with the operating system +and produces good code. +.SS "UNICOS/mk CC failures during Configure run" +.IX Subsection "UNICOS/mk CC failures during Configure run" +In UNICOS/mk the following errors may appear during the Configure run: +.PP +.Vb 6 +\& Guessing which symbols your C compiler and preprocessor define... +\& CC\-20 cc: ERROR File = try.c, Line = 3 +\& ... +\& bad switch yylook 79bad switch yylook 79bad switch yylook 79bad switch yylook 79#ifdef A29K +\& ... +\& 4 errors detected in the compilation of "try.c". +.Ve +.PP +The culprit is the broken awk of UNICOS/mk. The effect is fortunately +rather mild: Perl itself is not adversely affected by the error, only +the h2ph utility coming with Perl, and that is rather rarely needed +these days. +.SS "Arrow operator and arrays" +.IX Subsection "Arrow operator and arrays" +When the left argument to the arrow operator \f(CW\*(C`\->\*(C'\fR is an array, or +the \f(CW\*(C`scalar\*(C'\fR operator operating on an array, the result of the +operation must be considered erroneous. For example: +.PP +.Vb 2 +\& @x\->[2] +\& scalar(@x)\->[2] +.Ve +.PP +These expressions will get run-time errors in some future release of +Perl. +.SS "Experimental features" +.IX Subsection "Experimental features" +As discussed above, many features are still experimental. Interfaces and +implementation of these features are subject to change, and in extreme cases, +even subject to removal in some future release of Perl. These features +include the following: +.IP Threads 4 +.IX Item "Threads" +.PD 0 +.IP Unicode 4 +.IX Item "Unicode" +.IP "64\-bit support" 4 +.IX Item "64-bit support" +.IP "Lvalue subroutines" 4 +.IX Item "Lvalue subroutines" +.IP "Weak references" 4 +.IX Item "Weak references" +.IP "The pseudo-hash data type" 4 +.IX Item "The pseudo-hash data type" +.IP "The Compiler suite" 4 +.IX Item "The Compiler suite" +.IP "Internal implementation of file globbing" 4 +.IX Item "Internal implementation of file globbing" +.IP "The DB module" 4 +.IX Item "The DB module" +.IP "The regular expression code constructs:" 4 +.IX Item "The regular expression code constructs:" +.PD +\&\f(CW\*(C`(?{ code })\*(C'\fR and \f(CW\*(C`(??{ code })\*(C'\fR +.SH "Obsolete Diagnostics" +.IX Header "Obsolete Diagnostics" +.IP "Character class syntax [: :] is reserved for future extensions" 4 +.IX Item "Character class syntax [: :] is reserved for future extensions" +(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: "\e[:" and ":\e]". +.IP "Ill-formed logical name |%s| in prime_env_iter" 4 +.IX Item "Ill-formed logical name |%s| in prime_env_iter" +(W) A warning peculiar to VMS. A logical name was encountered when preparing +to iterate over \f(CW%ENV\fR which violates the syntactic rules governing logical +names. Because it cannot be translated normally, it is skipped, and will not +appear in \f(CW%ENV\fR. This may be a benign occurrence, as some software packages +might directly modify logical name tables and introduce nonstandard names, +or it may indicate that a logical name table has been corrupted. +.IP "In string, @%s now must be written as \e@%s" 4 +.IX Item "In string, @%s now must be written as @%s" +The description of this error used to say: +.Sp +.Vb 2 +\& (Someday it will simply assume that an unbackslashed @ +\& interpolates an array.) +.Ve +.Sp +That day has come, and this fatal error has been removed. It has been +replaced by a non-fatal warning instead. +See "Arrays now always interpolate into double-quoted strings" for +details. +.ie n .IP "Probable precedence problem on %s" 4 +.el .IP "Probable precedence problem on \f(CW%s\fR" 4 +.IX Item "Probable precedence problem on %s" +(W) The compiler found a bareword where it expected a conditional, +which often indicates that an || or && was parsed as part of the +last argument of the previous construct, for example: +.Sp +.Vb 1 +\& open FOO || die; +.Ve +.IP "regexp too big" 4 +.IX Item "regexp too big" +(F) The current implementation of regular expressions uses shorts as +address offsets within a string. Unfortunately this means that if +the regular expression compiles to longer than 32767, it'll blow up. +Usually when you want a regular expression this big, there is a better +way to do it with multiple statements. See perlre. +.IP "Use of ""$$<digit>"" to mean ""${$}<digit>"" is deprecated" 4 +.IX Item "Use of ""$$<digit>"" to mean ""${$}<digit>"" is deprecated" +(D) Perl versions before 5.004 misinterpreted any type marker followed +by "$" and a digit. For example, "$$0" was incorrectly taken to mean +"${$}0" instead of "${$0}". This bug is (mostly) fixed in Perl 5.004. +.Sp +However, the developers of Perl 5.004 could not fix this bug completely, +because at least two widely-used modules depend on the old meaning of +"$$0" in a string. So Perl 5.004 still interprets "$$<digit>" in the +old (broken) way inside strings; but it generates this message as a +warning. And in Perl 5.005, this special treatment will cease. +.SH "Reporting Bugs" +.IX Header "Reporting Bugs" +If you find what you think is a bug, you might check the +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. +.PP +If you believe you have an unreported bug, please run the \fBperlbug\fR +program included with your release. Be sure to trim your bug down +to a tiny but sufficient test case. Your bug report, along with the +output of \f(CW\*(C`perl \-V\*(C'\fR, will be sent off to perlbug@perl.org to be +analysed by the Perl porting team. +.SH "SEE ALSO" +.IX Header "SEE ALSO" +The \fIChanges\fR file for exhaustive details on what changed. +.PP +The \fIINSTALL\fR file for how to build Perl. +.PP +The \fIREADME\fR file for general stuff. +.PP +The \fIArtistic\fR and \fICopying\fR files for copyright information. +.SH HISTORY +.IX Header "HISTORY" +Written by Gurusamy Sarathy <\fIgsar@activestate.com\fR>, with many +contributions from The Perl Porters. +.PP +Send omissions or corrections to <\fIperlbug@perl.org\fR>. |