X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=pod%2Fperldelta.pod;h=8e62de0bf783c381f600cb564a7c1d75c2d018de;hb=0f1923bdafbbf46153592d4c0bb426b7e17d90d7;hp=de727db4870ad014b7c669a9955e91389da084e6;hpb=27806c827bf94df47a488c71aa19376daf71342b;p=p5sagit%2Fp5-mst-13.2.git diff --git a/pod/perldelta.pod b/pod/perldelta.pod index de727db..8e62de0 100644 --- a/pod/perldelta.pod +++ b/pod/perldelta.pod @@ -1,16 +1,218 @@ =head1 NAME -perldelta - what's new for perl5.006 (as of 5.005_56) +perldelta - what's new for perl v5.6.0 =head1 DESCRIPTION +This is an unsupported alpha release, meant for intrepid Perl +developers only. The included sources may not even build correctly on +some platforms. Subscribing to perl5-porters is the best way to +monitor and contribute to the progress of development releases (see +http://www.hut.fi/~jhi/perl5-porters.html for info). + This document describes differences between the 5.005 release and this one. =head1 Incompatible Changes =head2 Perl Source Incompatibilities -None known at this time. +Beware that any new warnings that have been added or old ones +that have been enhanced are B considered incompatible changes. + +Since all new warnings must be explicitly requested via the C<-w> +switch or the C pragma, it is ultimately the programmer's +responsibility to ensure that warnings are enabled judiciously. + +=over 4 + +=item CHECK is a new keyword + +In addition to C, C, C, C and C, +subroutines named C 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. + +=item Treatment of list slices of undef has changed + +When taking a slice of a literal list (as opposed to a slice of +an array or hash), Perl used to return an empty list if the +result happened to be composed of all undef values. + +The new behavior is to produce an empty list if (and only if) +the original list was empty. Consider the following example: + + @a = (1,undef,undef,2)[2,1,2]; + +The old behavior would have resulted in @a having no elements. +The new behavior ensures it has three undefined elements. + +Note in particular that the behavior of slices of the following +cases remains unchanged: + + @a = ()[1,2]; + @a = (getpwent)[7,0]; + @a = (anything_returning_empty_list())[2,1,2]; + @a = @b[2,1,2]; + @a = @c{'a','b','c'}; + +See L. + +=head2 Perl's version numbering has changed + +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. + +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. + +The English module now sets $PERL_VERSION to $^V (a string value) rather +than C<$]> (a numeric value). (This is a potential incompatibility. +Send us a report via perlbug if you are affected by this.) + +The v1.2.3 syntax is also now legal in Perl. +See L for more on that. + +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 C<$]>). + +=item Literals of the form C<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. + +For example, C used to output C<97.9899> in earlier +versions, but now prints C. + +See L below. + +=item Possibly changed pseudo-random number generator + +In 5.005_0x and earlier, perl's rand() function used the C library +rand(3) function. As of 5.005_52, Configure tests for drand48(), +random(), and rand() (in that order) and picks the first one it finds. +Perl programs that depend on reproducing a specific set of pseudo-random +numbers will now likely produce different output. You can use +C to obtain the old behavior. + +=item Hashing function for hash keys has changed + +Perl hashes are not order preserving. The apparently random order +encountered when iterating on the contents of a hash is determined +by the hashing algorithm used. To improve the distribution of lower +bits in the hashed value, the algorithm has changed slightly as of +5.005_52. When iterating over hashes, this may yield a random order +that is B from that of previous versions. + +=item C fails on read only values + +Using the C operator on a readonly value (such as $1) has +the same effect as assigning C to the readonly value--it +throws an exception. + +=item Close-on-exec bit may be set on pipe and socket handles + +On systems that support a close-on-exec flag on filehandles, the +flag will be set for any handles created by pipe(), socketpair(), +socket(), and accept(), 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 L, +L, L, L, +and L. + +=item Writing C<"$$1"> to mean C<"${$}1"> is unsupported + +Perl 5.004 deprecated the interpretation of C<$$1> and +similar within interpolated strings to mean C<$$ . "1">, +but still allowed it. + +In Perl 5.6 and later, C<"$$1"> always means C<"${$1}">. + +=item delete(), values() and C<\(%h)> operate on aliases to values, not copies + +delete(), each(), values() and hashes in a list context return the actual +values in the hash, instead of copies (as they used to in earlier +versions). Typical idioms for using these constructs copy the +returned values, but this can make a significant difference when +creating references to the returned values. + +Keys in the hash are still returned as copies when iterating on +a hash. + +=item vec(EXPR,OFFSET,BITS) enforces powers-of-two BITS + +vec() generates a run-time error if the BITS argument is not +a valid power-of-two integer. + +=item Text of some diagnostic output has changed + +Most references to internal Perl operations in diagnostics +have been changed to be more descriptive. This may be an +issue for programs that may incorrectly rely on the exact +text of diagnostics for proper functioning. + +=item C<%@> has been removed + +The undocumented special variable C<%@> that used to accumulate +"background" errors (such as those that happen in DESTROY()) +has been removed, because it could potentially result in memory +leaks. + +=item Parenthesized not() behaves like a list operator + +The C operator now falls under the "if it looks like a function, +it behaves like a function" rule. + +As a result, the parenthesized form can be used with C and C. +The following construct used to be a syntax error before, but it works +as expected now: + + grep not($_), @things; + +On the other hand, using C with a literal list slice may not +work. The following previously allowed construct: + + print not (1,2,3)[0]; + +needs to be written with additional parentheses now: + + print not((1,2,3)[0]); + +The behavior remains unaffected when C is not followed by parentheses. + +=item Semantics of bareword prototype C<(*)> have changed + +Arguments prototyped as C<*> will now be visible within the subroutine +as either a simple scalar or as a reference to a typeglob. 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. See L. + +=head2 On 64-bit platforms the semantics of bit operators have changed + +If your platform is either natively 64-bit or your Perl has been +configured to used 64-bit integers (say C and see what is +your ivsize: if it is 8, you are 64-bit) , be warned that the +semantics of all the bitwise numeric operators (& | ^ ~ << >>) have +been changed. They used to be forced to be 32 bits wide, but now in +the aforementioned platforms they are 64 bits wide. Most dramatically +this affects the unary ~: what used to be 32 bits wide, is now 64 bits +wide. If you depend on your integers being 32 bits wide, mask off the +excess bits with C<& 0xffffffff>. + +=back =head2 C Source Incompatibilities @@ -19,7 +221,7 @@ None known at this time. =item C Release 5.005 grandfathered old global symbol names by providing preprocessor -macros for extension source compatibility. As of release 5.006, these +macros for extension source compatibility. As of release 5.6, these preprocessor definitions are not available by default. You need to explicitly compile perl with C<-DPERL_POLLUTE> to get these definitions. For extensions still using the old symbols, this option can be @@ -27,6 +229,31 @@ specified via MakeMaker: perl Makefile.PL POLLUTE=1 +=item C + +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. + +This new build option provides a set of macros for all API functions +such that an implicit interpreter/thread context argument is passed to +every API function. As a result of this, something like C +amounts to a macro invocation that actually translates to something like +C. While this is generally expected +to not have any significant source compatibility issues, the difference +between a macro and a real function call will need to be considered. + +This means that there B a source compatibility issue as a result of +this if your extensions attempt to use pointers to any of the Perl API +functions. + +Note that the above issue is not relevant to the default build of +Perl, whose interfaces continue to match those of prior versions +(but subject to the other options described here). + +See L for detailed information on the +ramifications of building Perl using this option. + =item C Enabling Perl's malloc in release 5.005 and earlier caused @@ -40,7 +267,7 @@ be called in programs that used Perl's malloc. Previous versions of Perl have allowed this behaviour to be suppressed with the HIDEMYMALLOC and EMBEDMYMALLOC preprocessor definitions. -As of release 5.006, Perl's malloc family of functions have default names +As of release 5.6, Perl's malloc family of functions have default names distinct from the system versions. You need to explicitly compile perl with C<-DPERL_POLLUTE_MALLOC> to get the older behaviour. HIDEMYMALLOC and EMBEDMYMALLOC have no effect, since the behaviour they enabled is now @@ -49,14 +276,6 @@ the default. Note that these functions do B constitute Perl's memory allocation API. See L for further information about that. -=item C and C Issues - -The C global is now thread local, so a C declaration is needed -in the scope in which the global appears. XSUBs should handle this automatically, -but if you have used C in support functions, you either need to -change the C to a local variable (which is recommended), or put in -a C. - =back =head2 Compatible C Source API Changes @@ -81,21 +300,275 @@ from the change. =head2 Binary Incompatibilities -This release is not binary compatible with the 5.005 release or its -maintenance versions. +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. + +The usethreads or usemultiplicity builds are B binary compatible +with the corresponding builds in 5.005. + +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. + +For the full list of public API functions, see L. + +=head1 Installation and Configuration Improvements + +=head2 -Dusethreads means something different + +WARNING: Support for threads continues to be an experimental feature. +Interfaces and implementation are subject to sudden and drastic changes. + +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". + +As of v5.5.640, interpreter-threads support is still lacking a way to +create new threads from Perl (i.e., C will not work with +interpreter threads). C continues to be available when you +ask for use5005threads, bugs and all. + +=head2 New Configure flags + +The following new flags may be enabled on the Configure command line +by running Configure with C<-Dflag>. + + usemultiplicity + usethreads useithreads (new interpreter threads: no Perl API yet) + usethreads use5005threads (threads as they were in 5.005) + + use64bitint (equal to now deprecated 'use64bits') + use64bitall + + uselongdouble + usemorebits + uselargefiles + usesocks (only SOCKS v5 supported) + +=head2 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 L<"64-bit support">. + +=head2 Long Doubles + +Some platforms have "long doubles", floating point numbers of even +larger range than ordinary "doubles". To enable using long doubles for +Perl's scalars, use -Duselongdouble. + +=head2 -Dusemorebits + +You can enable both -Duse64bitint and -Dlongdouble by -Dusemorebits. +See also L<"64-bit support">. + +=head2 -Duselargefiles + +Some platforms support large files, files larger than two gigabytes. +See L<"Large file support"> for more information. + +=head2 installusrbinperl + +You can use "Configure -Uinstallusrbinperl" which causes installperl +to skip installing perl also as /usr/bin/perl. This is useful if you +prefer not to modify /usr/bin for some reason or another but harmful +because many scripts assume to find Perl in /usr/bin/perl. + +=head2 SOCKS support + +You can use "Configure -Dusesocks" which causes Perl to probe +for the SOCKS (v5, not v4) proxy protocol library, +http://www.socks.nec.com/ + +=head2 C<-A> flag + +You can "post-edit" the Configure variables using the Configure C<-A> +flag. The editing happens immediately after the platform specific +hints files have been processed but before the actual configuration +process starts. Run C to find out the full C<-A> syntax. + +=head2 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. + +If you previously used C or C<-Dsitearch> to set +special values for library directories, you might wish to consider using +the new C<-Dsiteprefix> 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. =head1 Core Changes =head2 Unicode and UTF-8 support Perl can optionally use UTF-8 as its internal representation for character -strings. The C pragma enables this support in the current lexical -scope. See L for more information. +strings. The C and C pragmas are used to control this support +in the current lexical scope. See L, L and L for +more information. + +=head2 Interpreter cloning, threads, and concurrency + +WARNING: This is an experimental feature in a pre-alpha state. Use +at your own risk. + +Perl 5.005_63 introduces the beginnings of support for running multiple +interpreters concurrently in different threads. In conjunction with +the perl_clone() 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. + +On Windows, this feature is used to emulate fork() at the interpreter +level. See L. + +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. + +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 perl_clone() API call will only be available in the former. + +-Dusethreads enables, the cpp macros USE_ITHREADS by default, which enables +Perl source code changes that provide a clear separation between the op tree +and the data it operates with. The former is considered 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. + +Note that building Perl with the -Dusemultiplicity Configure option +is adequate if you wish to run multiple B interpreters +concurrently in different threads. -Dusethreads only provides the +additional functionality of the perl_clone() API call and other +support for running B interpreters concurrently. =head2 Lexically scoped warning categories You can now control the granularity of warnings emitted by perl at a finer -level using the C pragma. See L for details. +level using the C pragma. See L and L +for details. + +=head2 Lvalue subroutines + +WARNING: This is an experimental feature. + +change#4081 +[TODO - Ilya Zakharevich , +Tuomas Lukka )] + +=head2 "our" declarations + +An "our" declaration introduces a value that can be best understood +as a lexically scoped symbolic alias to a global variable in the +package that was current where the variable was declared. This is +mostly useful as an alternative to the C pragma, but also provides +the opportunity to introduce typing and other attributes for such +variables. See L. + +=head2 Support for strings represented as a vector of ordinals + +Literals of the form C are now parsed as a string composed of +of characters with the specified ordinals. This is an alternative, more +readable way to construct (possibly unicode) strings instead of +interpolating characters, as in C<"\x{1}\x{2}\x{3}\x{4}">. The leading +C may be omitted if there are more than two ordinals, so C<1.2.3> is +parsed the same as C. + +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 C, C, +C, C, etc., or perform bitwise string operations on them using C<|>, +C<&>, etc. + +In conjunction with the new C<$^V> 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: + + # this will parse in older versions of Perl also + if ($^V and $^V gt v5.5.640) { + # new features supported + } + +C and C also have some special magic to support such literals. +They will be interpreted as a version rather than as a module name: + + require v5.6.0; # croak if $^V lt v5.6.0 + use v5.6.0; # same, but croaks at compile-time + +Alternatively, the C may be omitted if there is more than one dot: + + require 5.6.0; + use 5.6.0; + +Also, C and C support the Perl-specific format flag C<%v> +to print ordinals of characters in arbitrary strings: + + printf "v%vd", $^V; # prints current version, such as "v5.5.650" + printf "%*vX", ":", $addr; # formats IPv6 address + printf "%*vb", " ", $bits; # displays bitstring + +See L for additional information. + +=head2 Weak references + +WARNING: This is an experimental feature. + +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. + +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. + +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. + +To use this feature, you need the WeakRef package from CPAN, which +contains additional documentation. + +change#3385, also need perlguts documentation +[TODO - Tuomas Lukka ] + +=head2 File globbing implemented internally + +WARNING: This is currently an experimental feature. Interfaces and +implementation are likely to change. + +Perl now uses the File::Glob implementation of the glob() operator +automatically. This avoids using an external csh process and the +problems associated with it. =head2 Binary numbers supported @@ -105,19 +578,191 @@ C: $answer = 0b101010; printf "The answer is: %b\n", oct("0b101010"); +=head2 Some arrows may be omitted in calls through references + +Perl now allows the arrow to be omitted in many constructs +involving subroutine calls through references. For example, +C<< $foo[10]->('foo') >> may now be written C<$foo[10]('foo')>. +This is rather similar to how the arrow may be omitted from +C<< $foo[10]->{'foo'} >>. Note however, that the arrow is still +required for C<< foo(10)->('bar') >>. + +=head2 exists() is supported on subroutine names + +The exists() builtin now works on subroutine names. A subroutine +is considered to exist if it has been declared (even if implicitly). +See L for examples. + +=head2 exists() and delete() are supported on array elements + +The exists() and delete() builtins now work on simple arrays as well. +The behavior is similar to that on hash elements. + +exists() 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 EXISTS() method in the corresponding tied +package will be invoked. + +delete() may be used to remove an element from the array and return +it. The array element at that position returns to its unintialized +state, so that testing for the same element with exists() 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 +exists(), or 0 if none such is found. If the array is tied, the DELETE() +method in the corresponding tied package will be invoked. + +See L and L for examples. + =head2 syswrite() ease-of-use -The length argument of C is now optional. +The length argument of C has become optional. + +=head2 File and directory handles can be autovivified + +Similar to how constructs such as C<< $x->[0] >> autovivify a reference, +handle constructors (open(), opendir(), pipe(), socketpair(), sysopen(), +socket(), and accept()) now autovivify a file or directory handle +if the handle passed to them is an uninitialized scalar variable. This +allows the constructs such as C and C +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: + + sub myopen { + open my $fh, "@_" + or die "Can't open '@_': $!"; + return $fh; + } + + { + my $f = myopen("; + # $f implicitly closed here + } + =head2 64-bit support -Better 64-bit support -- but full support still a distant goal. One -must Configure with -Duse64bits to get Configure to probe for the -extent of 64-bit support. Depending on the platform (hints file) more -or less 64-awareness becomes available. As of 5.005_54 at least -somewhat 64-bit aware platforms are HP-UX 11 or better, Solaris 2.6 or -better, IRIX 6.2 or better. Naturally 64-bit platforms like Digital -Unix and UNICOS also have 64-bit support. + NOTE: The Configure flags -Duselonglong and -Duse64bits + have been deprecated. Use -Duse64bitint instead. + +Any platform that has 64-bit integers either (a) natively as longs or +ints (b) via special compiler flags (c) using long long are able to +use "quads" (64-integers) as follows: + +=over 4 + +=item * + +constants (decimal, hexadecimal, octal, binary) in the code + +=item * + +arguments to oct() and hex() + +=item * + +arguments to print(), printf() and sprintf() (flag prefixes ll, L, q) + +=item * + +printed as such + +=item * + +pack() and unpack() "q" and "Q" formats + +=item * + +in basic arithmetics: + - * / % (NOTE: operating close to the limits +of the integer values may produce surprising results) + +=item * + +in bit arithmetics: & | ^ ~ << >> (NOTE: these used to be forced +to be 32 bits wide.) + +=item * + +vec() + +=back + +Note that unless you have the case (a) you will have to configure +and compile Perl using the -Duse64bitint Configure flag. + +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 one 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 most likely are 32-bit); the second +one goes all the way by attempting to switch also longs (and pointers) +being 64-bit. This may create an even more binary incompatible Perl +than -Duse64bitint: the resulting executable may not run at all in a +CPU-bit box, or you may have to reboot/reconfigure/rebuild your +operating system to be 64-bit aware. + +Natively 64-bit systems like Alpha and Cray need neither -Duse64bitint +nor -Duse64bitall. + +Last but not least: note that due to Perl's habit of always using +floating point numbers the quads are still not true integers. +When quads overflow their limits (0...18_446_744_073_709_551_615 unsigned, +-9_223_372_036_854_775_808...9_223_372_036_854_775_807 signed), they +are silently promoted to floating point numbers, after which they will +start losing precision (their lower digits). + +=head2 Large file support + +If you have filesystems that support "large files" (files larger than +2 gigabytes), you may now also be able to create and access them from +Perl. You have to use Configure -Duselargefiles. Turning on the +large file support turns on also the 64-bit support on many platforms. +Beware that unless your filesystem also supports "sparse files" seeking +to umpteen petabytes may be unadvisable. + +Note that in addition to requiring a proper file system to do large +files you may also need to adjust your per-process (or your +per-system, or per-process-group, or per-user-group) maximum filesize +limits before running Perl scripts that try to handle large files, +especially if you intend to write such files. + +Finally, in addition to your process/process group maximum filesize +limits, you may have quota limits on your filesystems that stop you +(your user id or your user group id) from using large files. + +Adjusting your process/user/group/file system/operating system limits +is outside the scope of Perl core language. For process limits, you +may try increasing the limits using your shell's limits/limit/ulimit +command before running Perl. The BSD::Resource extension (not +included with the standard Perl distribution) may also be of use, it +offers the getrlimit/setrlimit interface that can be used to adjust +process resource usage limits, including the maximum filesize limit. + +=head2 Long doubles + +In some systems you may be able to use long doubles to enhance the +range 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). + +=head2 "more bits" + +You can "Configure -Dusemorebits" to turn on both the 64-bit support +and the long double support. + +=head2 Enhanced support for sort() subroutines + +Perl subroutines with a prototype of C<($$)> 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 @_. See L. + +For unprototyped sort subroutines, the historical behavior of passing +the elements to be compared as the global variables $a and $b remains +unchanged. =head2 Better syntax checks on parenthesized unary operators @@ -142,6 +787,11 @@ behaviour of: remains unchanged. See L. +=head2 POSIX character class syntax [: :] supported + +For example to match alphabetic characters use /[[:alpha:]]/. +See L for details. + =head2 Improved C operator The C operator is now evaluated at compile time into a true list @@ -165,6 +815,17 @@ strings. See L. The new format type modifier '!' is useful for packing and unpacking native shorts, ints, and longs. See L. +=head2 pack() and unpack() support counted strings + +The template character '/' can be used to specify a counted string +type to be packed or unpacked. See L. + +=head2 Comments in pack() templates + +The '#' character in a template introduces a comment up to +end of the line. This facilitates documentation of pack() +templates. + =head2 $^X variables may now have names longer than one character Formerly, $^X was synonymous with ${"\cX"}, but $^XY was a syntax @@ -184,16 +845,97 @@ As before, lexical variables may not have names beginning with control characters. As before, variables whose names begin with a control character are always forced to be in package `main'. All such variables are reserved for future extensions, except those that begin with -C<^_>, which may be used by user programs and is guaranteed not to +C<^_>, which may be used by user programs and are guaranteed not to acquire special meaning in any future version of Perl. +=head2 C implicit in subroutine attributes + +Formerly, if you wanted to mark a subroutine as being a method call or +as requiring an automatic lock() when it is entered, you had to declare +that with a C pragma in the body of the subroutine. +That can now be accomplished with declaration syntax, like this: + + sub mymethod : locked method ; + ... + sub mymethod : locked method { + ... + } + + sub othermethod :locked :method ; + ... + sub othermethod :locked :method { + ... + } + + +(Note how only the first C<:> is mandatory, and whitespace surrounding +the C<:> is optional.) + +F and F have been updated to keep the attributes +with the stubs they provide. See L. + +=head2 Regular expression improvements + +change#2827,2373,2372,2365,1813,1800,4112,4158,4215,4301 +[TODO - Ilya Zakharevich ] + +=head2 Overloading improvements + +change#2150 +[TODO - Ilya Zakharevich ] + +=head2 open() with more than two arguments + +[TODO - Ilya Zakharevich ] + +=head2 Support for interpolating named characters + +change#4052 +[TODO - Ilya Zakharevich ] + +=head2 C and C may be overridden + +C and C operations may be overridden locally +by importing subroutines of the same name into the current package +(or globally by importing them into the CORE::GLOBAL:: namespace). +Overriding C will also affect C, provided the override +is visible at compile-time. +See L. + +=head2 New variable $^C reflects C<-c> switch + +C<$^C> has a boolean value that reflects whether perl is being run +in compile-only mode (i.e. via the C<-c> switch). Since +BEGIN blocks are executed under such conditions, this variable +enables perl code to determine whether actions that make sense +only during normal running are warranted. See L. + +=head2 New variable $^V contains Perl version as a string + +C<$^V> contains the Perl version number as a string composed of +characters whose ordinals match the version numbers, e.g., v5.6.0. +This may be used in string comparisons. + +See C for an +example. + +=head2 Optional Y2K warnings + +If Perl is built with the cpp macro C defined, +it emits optional warnings when concatenating the number 19 +with another number. + +This behavior must be specifically enabled when running Configure. +See F and F. + =head1 Significant bug fixes -=head2 EHANDLEE on empty files +=head2 on empty files -With C<$/> set to C, slurping an empty file returns a string of +With C<$/> set to C, "slurping" an empty file returns a string of zero length (instead of C, as it used to) the first time the -HANDLE is read. Further reads yield C. +HANDLE is read after C<$/> is set to C. Further reads yield +C. This means that the following will append "foo" to an empty file (it used to do nothing): @@ -221,6 +963,21 @@ Parsing of here documents used to be flawed when they appeared as the replacement expression in C. This has been fixed. +=head2 All compilation errors are true errors + +Some "errors" encountered at compile time were by neccessity +generated as warnings followed by eventual termination of the +program. This enabled more such errors to be reported in a +single run, rather than causing a hard stop at the first error +that was encountered. + +The mechanism for reporting such errors has been reimplemented +to queue compile-time errors and report them at the end of the +compilation as true errors rather than as warnings. This fixes +cases where error messages leaked through in the form of warnings +when code was compiled at run time using C, and +also allows such errors to be reliably trapped using __DIE__ hooks. + =head2 Automatic flushing of output buffers fork(), exec(), system(), qx//, and pipe open()s now flush buffers @@ -229,116 +986,582 @@ was attempted. This mostly eliminates confusing buffering mishaps suffered by users unaware of how Perl internally handles I/O. -=head1 Supported Platforms +=head2 Better diagnostics on meaningless filehandle operations -=over 4 +Constructs such as C<< open() >> and C<< close() >> +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). -=item * +=head2 Where possible, buffered data discarded from duped input filehandle -VM/ESA is now supported. +C<< open(NEW, "<&OLD") >> now attempts to discard any data that +was previously read and buffered in C before duping the handle. +On platforms where doing this is allowed, the next read operation +on C will return the same data as the corresponding operation +on C. Formerly, it would have returned the data from the start +of the following disk block instead. -=item * +=head2 eof() has the same old magic as <> -Siemens BS2000 is now supported under the POSIX Shell. +C would return true if no attempt to read from C<< <> >> had +yet been made. C has been changed to have a little magic of its +own, it now opens the C<< <> >> files. -=item * +=head2 system(), backticks and pipe open now reflect exec() failure -The Mach CThreads (NEXTSTEP, OPENSTEP) are now supported by the Thread -extension. +On Unix and similar platforms, system(), qx() and open(FOO, "cmd |") +etc., are implemented via fork() and exec(). When the underlying +exec() fails, earlier versions did not report the error properly, +since the exec() happened to be in a different process. -=item * +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 $!. -GNU/Hurd is now supported. +=head2 Implicitly closed filehandles are safer -=item * +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. -Rhapsody is now supported. +=head2 C<(\$)> prototype and C<$foo{a}> -=item * +An scalar reference prototype now correctly allows a hash or +array element in that slot. -EPOC is is now supported (on Psion 5). +=head2 Pseudo-hashes work better -=back +Dereferencing some types of reference values in a pseudo-hash, +such as C<< $ph->{foo}[1] >>, was accidentally disallowed. This has +been corrected. -=head1 New tests +When applied to a pseudo-hash element, exists() now reports whether +the specified value exists, not merely if the key is valid. -=over 4 +delete() 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 L. -=item op/io_const +Pseudo-hash slices with constant keys are now optimized to array lookups +at compile-time. -IO constants (SEEK_*, _IO*). +The C pragma now provides ways to create pseudo-hashes, via +fields::new() and fields::phash(). See L. -=item op/io_dir +=head2 C and AUTOLOAD -Directory-related IO methods (new, read, close, rewind, tied delete). +The C construct works correctly when C<&sub> happens +to be autoloaded. -=item op/io_multihomed +=head2 C<-bareword> allowed under C -INET sockets with multi-homed hosts. +The autoquoting of barewords preceded by C<-> did not work +in prior versions when the C pragma was enabled. +This has been fixed. -=item op/io_poll +=head2 Boolean assignment operators are legal lvalues -IO poll(). +Constructs such as C<($a ||= 2) += 1> are now allowed. -=item op/io_unix +=head2 C allowed -UNIX sockets. +sort() did not accept a subroutine reference as the comparison +function in earlier versions. This is now permitted. -=item op/filetest +=head2 Failures in DESTROY() -File test operators. +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. -=item op/lex_assign +=head2 Locale bugs fixed -Verify operations that access pad objects (lexicals and temporaries). +printf() and sprintf() previously reset the numeric locale +back to the default "C" locale. This has been fixed. -=back +Numbers formatted according to the local numeric locale +(such as using a decimal comma instead of a decimal dot) caused +"isn't numeric" warnings, even while the operations accessing +those numbers produced correct results. The warnings are gone. -=head1 Modules and Pragmata +=head2 Memory leaks -=head2 Modules +The C construct could sometimes leak +memory. This has been fixed. -=over 4 +Operations that aren't filehandle constructors used to leak memory +when used on invalid filehandles. This has been fixed. -=item Dumpvalue +Constructs that modified C<@_> could fail to deallocate values +in C<@_> and thus leak memory. This has been corrected. -Added Dumpvalue module provides screen dumps of Perl data. +=head2 Spurious subroutine stubs after failed subroutine calls -=item Benchmark +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. -You can now run tests for I seconds instead of guessing the right -number of tests to run: e.g. timethese(-5, ...) will run each -code for at least 5 CPU seconds. Zero as the "number of repetitions" -means "for at least 3 CPU seconds". The output format has also -changed. For example: +=head2 Consistent numeric conversions -use Benchmark;$x=3;timethese(-5,{a=>sub{$x*$x},b=>sub{$x**2}}) +change#3378,3318 +[TODO - Ilya Zakharevich ] -will now output something like this: +=head2 Taint failures under C<-U> -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) +When running in unsafe mode, taint violations could sometimes +cause silent failures. This has been fixed. -New features: "each for at least N CPU seconds...", "wallclock secs", -and the "@ operations/CPU second (n=operations)". +=head2 END blocks and the C<-c> switch -=item Devel::Peek +Prior versions used to run BEGIN B END blocks when Perl was +run in compile-only mode. Since this is typically not the expected +behavior, END blocks are not executed anymore when the C<-c> switch +is used. -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. +See L for how to run things when the compile phase ends. -=item Fcntl +=head2 Potential to leak DATA filehandles -More Fcntl constants added: F_SETLK64, F_SETLKW64, O_LARGEFILE for -large (more than 4G) file access (64-bit support is not yet -working, though, so no need to get overly excited), Free/Net/OpenBSD -locking behaviour flags F_FLOCK, F_POSIX, Linux F_SHLCK, and -O_ACCMODE: the mask of O_RDONLY, O_WRONLY, and O_RDWR. +Using the C<__DATA__> 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. -=item File::Spec +This caveat is now better explained in the documentation. +See L. -New methods have been added to the File::Spec module: devnull() returns +=head2 Diagnostics follow STDERR + +Diagnostic output now goes to whichever file the C handle +is pointing at, instead of always going to the underlying C runtime +library's C. + +=head2 Other fixes for better diagnostics + +Line numbers are no longer suppressed (under most likely circumstances) +during the global destruction phase. + +Diagnostics emitted from code running in threads other than the main +thread are now accompanied by the thread ID. + +Embedded null characters in diagnostics now actually show up. They +used to truncate the message in prior versions. + +$foo::a and $foo::b are now exempt from "possible typo" warnings only +if sort() is encountered in package foo. + +Unrecognized alphabetic escapes encountered when parsing quote +constructs now generate a warning, since they may take on new +semantics in later versions of Perl. + +=head1 Performance enhancements + +=head2 Simple sort() using { $a <=> $b } and the like are optimized + +Many common sort() operations using a simple inlined block are now +optimized for faster performance. + +=head2 Optimized assignments to lexical variables + +Certain operations in the RHS of assignment statements have been +optimized to directly set the lexical variable on the LHS, +eliminating redundant copying overheads. + +=head2 Faster mechanism to invoke XSUBs + +change#4044,4125 +[TODO - Ilya Zakharevich ] + +=head2 Perl_malloc() improvements + +change#4237 +[TODO - Ilya Zakharevich ] + +=head2 Faster subroutine calls + +Minor changes in how subroutine calls are handled internally +provide marginal improvements in performance. + +=head1 Platform specific changes + +=head2 Supported platforms + +=over 4 + +=item * + +VM/ESA is now supported. + +=item * + +Siemens BS2000 is now supported under the POSIX Shell. + +=item * + +The Mach CThreads (NEXTSTEP, OPENSTEP) are now supported by the Thread +extension. + +=item * + +GNU/Hurd is now supported. + +=item * + +Rhapsody/Darwin is now supported. + +=item * + +EPOC is is now supported (on Psion 5). + +=back + +=head2 DOS + +=over 4 + +=item * + +Perl now works with djgpp 2.02 (and 2.03 alpha). + +=item * + +Environment variable names are not converted to uppercase any more. + +=item * + +Wrong exit code from backticks now fixed. + +=item * + +This port is still using its own builtin globbing. + +=back + +=head2 OS/2 + +[TODO - Ilya Zakharevich ] + +=head2 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. + +It is unclear whether future versions will renew support for this +platform, but the possibility exists. + +=head2 VMS + +Numerous revisions and extensions to configuration, build, testing, and +installation process to accomodate core changes and VMS-specific options + +Expand %ENV-handling code to allow runtime mapping to logical names, +CLI symbols, and CRTL environ array + +Extension of subprocess invocation code to accept filespecs as command "verbs" + +Add to Perl command line processing the ability to use default file types and +to recognize Unix-style C<2E&1>. + +Expansion of File::Spec::VMS routines, and integration into ExtUtils::MM_VMS + +Extension of ExtUtils::MM_VMS to handle complex extensions more flexibly + +Barewords at start of Unix-syntax paths may be treated as text rather than +only as logical names + +Optional secure translation of several logical names used internally by Perl + +Miscellaneous bugfixing and porting of new core code to VMS + +Thanks are gladly extended to the many people who have contributed VMS +patches, testing, and ideas. + +=head2 Win32 + +Site library searches failed to look for ".../site/5.XXX/lib" +if ".../site/5.XXXYY/lib" wasn't found. This has been corrected. + +When given a pathname that consists only of a drivename, such +as C, opendir() and stat() now use the current working +directory for the drive rather than the drive root. + +The builtin XSUB functions in the Win32:: namespace are +documented. See L. + +$^X now contains the full path name of the running executable. + +A Win32::GetLongPathName() function is provided to complement +Win32::GetFullPathName() and Win32::GetShortPathName(). See L. + +POSIX::uname() is supported. + +system(1,...) now returns true process IDs rather than process +handles. kill() accepts any real process id, rather than strictly +return values from system(1,...). + +For better compatibility with Unix, C can now be used to +test whether a process exists. + +The C module is supported. + +Rudimentary support for building under command.com in Windows 95 +has been added. + +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. + +The glob() operator is implemented via the C extension, +which supports glob syntax of the C shell. This increases the flexibility +of the glob() 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 put +a C in your program. For details and compatibility +information, see L. + +[TODO - GSAR] + +=head1 New tests + +=over 4 + +=item lib/attrs + +Compatibility tests for C vs the older C. + +=item lib/env + +Tests for new environment scalar capability (e.g., C). + +=item lib/env-array + +Tests for new environment array capability (e.g., C). + +=item lib/io_const + +IO constants (SEEK_*, _IO*). + +=item lib/io_dir + +Directory-related IO methods (new, read, close, rewind, tied delete). + +=item lib/io_multihomed + +INET sockets with multi-homed hosts. + +=item lib/io_poll + +IO poll(). + +=item lib/io_unix + +UNIX sockets. + +=item op/attrs + +Regression tests for C and . + +=item op/filetest + +File test operators. + +=item op/lex_assign + +Verify operations that access pad objects (lexicals and temporaries). + +=item op/exists_sub + +Verify C operations. + +=back + +=head1 Modules and Pragmata + +=head2 Modules + +=over 4 + +=item attributes + +While used internally by Perl as a pragma, this module also +provides a way to fetch subroutine and variable attributes. +See L. + +=item B + +WARNING: The Compiler suite is still highly experimental. The +generated code may not be correct, even it manages to execute +without errors. + +The Perl Compiler suite has been extensively reworked for this +release. More of the standard Perl testsuite passes when run +under the Compiler, but there is still a significant way to +go to achieve production quality compiled executables. + +=item ByteLoader + +The ByteLoader is a dedicated extension to generate and run +Perl bytecode. See L. + +=item constant + +References can now be used. + +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. + +See L. + +=item charnames + +change#4052 +[TODO - Ilya Zakharevich ] + +=item Data::Dumper + +A C setting can be specified to avoid venturing +too deeply into deep data structures. See L. + +The XSUB implementation of Dump() is now automatically called if the +C setting is not in use. + +Dumping C objects works correctly. + +=item DB + +C is an experimental module that exposes a clean abstraction +to Perl's debugging API. + +=item DB_File + +DB_File can now be built with Berkeley DB versions 1, 2 or 3. +See C. + +=item Devel::DProf + +Devel::DProf, a Perl source code profiler has been added. See +L and L. + +=item Dumpvalue + +The Dumpvalue module provides screen dumps of Perl data. + +=item Benchmark + +Overall, Benchmark results exhibit lower average error and better timing +accuracy. + +You can now run tests for I seconds instead of guessing the right +number of tests to run: e.g. timethese(-5, ...) will run each +code for at least 5 CPU seconds. Zero as the "number of repetitions" +means "for at least 3 CPU seconds". The output format has also +changed. For example: + + use Benchmark;$x=3;timethese(-5,{a=>sub{$x*$x},b=>sub{$x**2}}) + +will now output something like this: + + Benchmark: running a, b, each for at least 5 CPU seconds... + a: 5 wallclock secs ( 5.77 usr + 0.00 sys = 5.77 CPU) @ 200551.91/s (n=1156516) + b: 4 wallclock secs ( 5.00 usr + 0.02 sys = 5.02 CPU) @ 159605.18/s (n=800686) + +New features: "each for at least N CPU seconds...", "wallclock secs", +and the "@ operations/CPU second (n=operations)". + +timethese() now returns a reference to a hash of Benchmark objects containing +the test results, keyed on the names of the tests. + +timethis() now returns the iterations field in the Benchmark result object +instead of 0. + +timethese(), timethis(), and the new cmpthese() (see below) can also take +a format specifier of 'none' to suppress output. + +A new function countit() is just like timeit() except that it takes a +TIME instead of a COUNT. + +A new function cmpthese() prints a chart comparing the results of each test +returned from a timethese() call. For each possible pair of tests, the +percentage speed difference (iters/sec or seconds/iter) is shown. + +For other details, see L. + +=item Devel::Peek + +The Devel::Peek module provides access to the internal representation +of Perl variables and data. It is a data debugging tool for the XS programmer. + +=item English + +$PERL_VERSION now stands for C<$^V> (a string value) rather than for C<$]> +(a numeric value). + +=item Env + +Env now supports accessing environment variables like PATH as array +variables. + +=item ExtUtils::MakeMaker + +change#4135, also needs docs in module pod +[TODO - Ilya Zakharevich ] + +=item Fcntl + +More Fcntl constants added: F_SETLK64, F_SETLKW64, O_LARGEFILE for +large file (more than 4GB) access Note that the O_LARGEFILE is +automatically/transparently added to sysopen() flags if large file +support has been configured), 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 seek()/sysseek() constants +SEEK_SET, SEEK_CUR, and SEEK_END are available via the C<:seek> tag. +The chmod()/stat() S_IF* constants and S_IS* functions are available +via the C<:mode> tag. + + +=item File::Compare + +A compare_text() function has been added, which allows custom +comparison functions. See L. + +=item File::Find + +File::Find now works correctly when the wanted() function is either +autoloaded or is a symbolic reference. + +A bug that caused File::Find to lose track of the working directory +when pruning top-level directories has been fixed. + +File::Find now also supports several other options to control its +behavior. It can follow symbolic links if the C option is +specified. Enabling the C option will make File::Find skip +changing the current directory when walking directories. The C +flag can be useful when running with taint checks enabled. + +See L. + +=item File::Glob + +This extension implements BSD-style file globbing. By default, +it will also be used for the internal implementation of the glob() +operator. See L. + +=item File::Spec + +New methods have been added to the File::Spec module: devnull() returns the name of the null device (/dev/null on Unix) and tmpdir() the name of the temp directory (normally /tmp on Unix). There are now also methods to convert between absolute and relative filenames: abs2rel() and @@ -357,9 +1580,100 @@ instead of $fullname = File::Spec->catfile($dir1, $dir2, $file); +=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. + +Getopt::Long encourages the use of Pod::Usage to produce help +messages. For example: + + use Getopt::Long; + use Pod::Usage; + my $man = 0; + my $help = 0; + GetOptions('help|?' => \$help, man => \$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 will read the given input file(s) and do someting + useful with the contents thereof. + + =cut + +See L for details. + +A bug that prevented the non-option call-back <> from being +specified as the first argument has been fixed. + +To specify the characters < and > as option starters, use ><. Note, +however, that changing option starters is strongly deprecated. + +=item IO + +write() and syswrite() will now accept a single-argument +form of the call, for consistency with Perl's syswrite(). + +You can now create a TCP-based IO::Socket::INET without forcing +a connect attempt. This allows you to configure its options +(like making it non-blocking) and then call connect() manually. + +A bug that prevented the IO::Socket::protocol() accessor +from ever returning the correct value has been corrected. + +IO::Socket::connect now uses non-blocking IO instead of alarm() +to do connect timeouts. + +IO::Socket::accept now uses select() instead of alarm() for doing +timeouts. + +IO::Socket::INET->new now sets $! correctly on failure. $@ is +still set for backwards compatability. + +=item JPL + +Java Perl Lingo is now distributed with Perl. See jpl/README +for more information. + +=item lib + +C now weeds out any trailing duplicate entries. +C removes all named entries. + =item Math::BigInt -The logical operations CE>, CE>, C<&>, C<|>, +The bitwise operations C<<< << >>>, C<<< >> >>>, C<&>, C<|>, and C<~> are now supported on bigints. =item Math::Complex @@ -367,10 +1681,102 @@ and C<~> are now supported on bigints. The accessor methods Re, Im, arg, abs, rho, and theta can now also act as mutators (accessor $z->Re(), mutator $z->Re(3)). +The class method C and the corresponding object method +C, in addition to accepting just one argument, now can +also accept a parameter hash. Recognized keys of a parameter hash are +C<"style">, which corresponds to the old one parameter case, and two +new parameters: C<"format">, which is a printf()-style format string +(defaults usually to C<"%.15g">, you can revert to the default by +setting the format string to C) used for both parts of a +complex number, and C<"polar_pretty_print"> (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. + +The potentially disruptive change is that in list context both methods +now I, instead of only the value of the +C<"style"> parameter. + =item Math::Trig -A little bit of radial trigonometry (cylindrical and spherical), -radial coordinate conversions, and the great circle distance were added. +A little bit of radial trigonometry (cylindrical and spherical), +radial coordinate conversions, and the great circle distance were added. + +=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. + +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. + +As of release 5.6 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. + +For further information, please see L and L. + +=item Pod::Checker, podchecker + +This utility checks pod files for correct syntax, according to +L. Obvious errors are flagged as such, while warnings are +printed for mistakes that can be handled gracefully. The checklist is +not complete yet. See L. + +=item Pod::ParseUtils, Pod::Find + +These modules provide a set of gizmos that are useful mainly for pod +translators. L traverses directory structures and +returns found pod files, along with their canonical names (like +C). L contains +B (useful for storing pod list information), B +(for parsing the contents of CE> sequences) and B +(for caching information about pod files, e.g. link nodes). + +=item Pod::Select, podselect + +Pod::Select is a subclass of Pod::Parser which provides a function +named "podselect()" 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 L. + +=item Pod::Usage, pod2usage + +Pod::Usage provides the function "pod2usage()" to print usage messages for +a Perl script based on its embedded pod documentation. The pod2usage() +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. + +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). + +For details and examples, please see L. + +=item Pod::Text and Pod::Man + +Pod::Text has been rewritten to use Pod::Parser. While pod2text() is +still available for backwards compatibility, the module now has a new +preferred interface. See L 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. + +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. =item SDBM_File @@ -379,10 +1785,30 @@ been added to the underlying sdbm library), so one can now call exists on an SDBM_File tied hash and get the correct result, rather than a runtime error. +A bug that may have caused data loss when more than one disk block +happens to be read from the database in a single FETCH() has been +fixed. + +=item Sys::Syslog + +Sys::Syslog now uses XSUBs to access facilities from syslog.h so it +no longer requires syslog.ph to exist. + +=item Sys::Hostname + +Sys::Hostname now uses XSUBs to call the C library's gethostname() or +uname() if they exist. + +=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. + =item Time::Local The timelocal() and timegm() functions used to silently return bogus -results when the date exceeded the machine's integer range. They +results when the date fell outside the machine's integer range. They now consistently croak() if the date falls in an unsupported range. =item Win32 @@ -405,7 +1831,7 @@ to the Win32::GetLastError() function. The new Win32::GetFullPathName(FILENAME) returns the full absolute pathname for FILENAME in scalar context. In list context it returns a two-element list containing the fully qualified directory name and -the filename. +the filename. See L. =item DBM Filters @@ -426,29 +1852,66 @@ See L for further information. =head2 Pragmata -C to enable UTF-8 and Unicode support. +C is now obsolete, and is only provided for +backward-compatibility. It's been replaced by the C +syntax. See L and L. -C allows modules to inherit pragmatic attributes -from the caller's context. C is currently the only supported -attribute. +C to enable UTF-8 and Unicode support. -Lexical warnings pragma, C, to control optional warnings. +Lexical warnings pragma, C, to control optional warnings. +See L. -C to control the behaviour of filetests (C<-r> C<-w> ...). -Currently only one subpragma implemented, "use filetest 'access';", -that enables the use of access(2) or equivalent to check -permissions instead of using stat(2) as usual. This matters -in filesystems where there are ACLs (access control lists): the -stat(2) might lie, but access(2) knows better. +C to control the behaviour of filetests (C<-r> C<-w> +...). Currently only one subpragma implemented, "use filetest +'access';", that uses access(2) or equivalent to check permissions +instead of using stat(2) as usual. This matters in filesystems +where there are ACLs (access control lists): the stat(2) might lie, +but access(2) knows better. =head1 Utility Changes -Todo. +=head2 h2ph + +[TODO - Kurt Starsinic ] + +=head2 perlcc + +C now supports the C and Bytecode backends. By default, +it generates output from the simple C backend rather than the +optimized C backend. + +Support for non-Unix platforms has been improved. + +=head2 h2xs + +change#4232 +[TODO - Ilya Zakharevich ] =head1 Documentation Changes =over 4 +=item perlapi.pod + +The official list of public Perl API functions. + +=item perlcompile.pod + +An introduction to using the Perl Compiler suite. + +=item perlfilter.pod + +An introduction to writing Perl source filters. + +=item perlhack.pod + +Some guidelines for hacking the Perl source code. + +=item perlintern.pod + +A list of internal functions in the Perl source code. +(List is currently empty.) + =item perlopentut.pod A tutorial on using open() effectively. @@ -457,29 +1920,281 @@ A tutorial on using open() effectively. A tutorial that introduces the essentials of references. +=item perlboot.pod + +A tutorial for beginners on object-oriented Perl. + =item perltootc.pod A tutorial on managing class data for object modules. +=item perlunicode.pod + +An introduction to Unicode support features in Perl. + =back -=head1 New Diagnostics +=head1 New or Changed Diagnostics + +=over 4 + +=item "%s" variable %s masks earlier declaration in same %s + +(W) 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. + +=item "my sub" not yet implemented + +(F) Lexically scoped subroutines are not yet implemented. Don't try that +yet. + +=item "our" variable %s redeclared + +(W) You seem to have already declared the same global once before in the +current lexical scope. + +=item '!' allowed only after types %s + +(F) The '!' is allowed in pack() and unpack() only after certain types. +See L. + +=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 L. + +=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 L. + +=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 L. + +=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 L. =item /%s/: Unrecognized escape \\%c passed through (W) You used a backslash-character combination which is not recognized by Perl. This combination appears in an interpolated variable or a -C<'>-delimited regular expression. +C<'>-delimited regular expression. The character was understood literally. -=item Unrecognized escape \\%c passed through +=item /%s/: Unrecognized escape \\%c in character class passed through (W) You used a backslash-character combination which is not recognized -by Perl. +by Perl inside character classes. The character was understood literally. -=item Missing command in piped open +=item /%s/ should probably be written as "%s" -(W) You used the C or C -construction, but the command was missing or blank. +(W) You have used a pattern where Perl expected to find a string, +as in the first argument to C. Perl will treat the true +or false result of matching the pattern against $_ as the string, +which is probably not what you had in mind. + +=item %s() called too early to check prototype + +(W) You've called a function that has a prototype before the parser saw a +definition or declaration for it, and Perl could not check that the call +conforms to the prototype. You need to either add an early prototype +declaration for the subroutine in question, or move the subroutine +definition ahead of the call to get proper prototype checking. Alternatively, +if you are certain that you're calling the function correctly, you may put +an ampersand before the name to avoid the warning. See L. + +=item %s argument is not a HASH or ARRAY element + +(F) The argument to exists() must be a hash or array element, such as: + + $foo{$bar} + $ref->[12]->["susie"] + +=item %s argument is not a HASH or ARRAY element or slice + +(F) The argument to delete() must be either a hash or array element, such as: + + $foo{$bar} + $ref->[12]->["susie"] + +or a hash or array slice, such as: + + @foo[$bar, $baz, $xyzzy] + @{$ref->[12]}{"susie", "queue"} + +=item %s argument is not a subroutine name + +(F) The argument to exists() for C must be a subroutine +name, and not a subroutine call. C will generate this error. + +=item %s package attribute may clash with future reserved word: %s + +(W) A lowercase attribute name was used that had a package-specific handler. +That name might have a meaning to Perl itself some day, even though it +doesn't yet. Perhaps you should use a mixed-case attribute name, instead. +See L. + +=item (in cleanup) %s + +(W) This prefix usually indicates that a DESTROY() 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. + +Failure of user callbacks dispatched using the C flag +could also result in this warning. See L. + +=item <> should be quotes + +(F) You wrote C<< require >> when you should have written +C. + +=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 join() to some other thread. + +=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 '}'. + +=item Bad realloc() ignored + +(S) An internal routine called realloc() on something that had never been +malloc()ed in the first place. Mandatory, but can be disabled by +setting environment variable C to 1. + +=item Bareword found in conditional + +(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: + + open FOO || die; + +It may also indicate a misspelled constant that has been interpreted +as a bareword: + + use constant TYPO => 1; + if (TYOP) { print "foo" } + +The C pragma is useful in avoiding such errors. + +=item Binary number > 0b11111111111111111111111111111111 non-portable + +(W) The binary number you specified is larger than 2**32-1 +(4294967295) and therefore non-portable between systems. See +L for more on portability concerns. + +=item Bit vector size > 32 non-portable + +(W) Using bit vector sizes larger than 32 is non-portable. + +=item Buffer overflow in prime_env_iter: %s + +(W) A warning peculiar to VMS. While Perl was preparing to iterate over +%ENV, it encountered a logical name or symbol definition which was too long, +so it was truncated to the string shown. + +=item Can't check filesystem of script "%s" + +(P) For some reason you can't check the filesystem of the script for nosuid. + +=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. + +=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. + +=item Can't ignore signal CHLD, forcing to default + +(W) 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. + +=item Can't modify non-lvalue subroutine call + +(F) Subroutines meant to be used in lvalue context should be declared as +such, see L. + +=item Can't read CRTL environ + +(S) A warning peculiar to VMS. Perl tried to read an element of %ENV +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 F (see L) so that environ is not searched. + +=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. + +=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. + +=item Can't weaken a nonreference + +(F) You attempted to weaken something that was not a reference. Only +references can be weakened. + +=item Character class [:%s:] unknown + +(F) The class in the character class [: :] syntax is unknown. +See L. + +=item Character class syntax [%s] belongs inside character classes + +(W) The character class constructs [: :], [= =], and [. .] go +I 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. + +=item Constant is not %s reference + +(F) A constant value (perhaps declared using the C 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 L and L. + +=item constant(%s): %%^H is not localized + +(F) When setting compile-time-lexicalized hash %^H one should set the +corresponding bit of $^H as well. + +=item constant(%s): %s + +(F) Compile-time-substitutions (such as overloaded constants and +character names) were not correctly set up. =item defined(@array) is deprecated @@ -493,27 +2208,386 @@ just use C for example. undefined I value. If you want to see if the hash is empty, just use C for example. +=item Did not produce a valid header + +See Server error. + +=item Did you mean "local" instead of "our"? + +(W) Remember that "our" does not localize the declared global variable. +You have declared it again in the same lexical scope, which seems superfluous. + +=item Document contains no data + +See Server error. + +=item entering effective %s failed + +(F) While under the C pragma, switching the real and +effective uids or gids failed. + +=item false [] range "%s" in regexp + +(W) A character class range must start and end at a literal character, not +another character class like C<\d> or C<[:alpha:]>. The "-" in your false +range is interpreted as a literal "-". Consider quoting the "-", "\-". +See L. + +=item Filehandle %s opened only for output + +(W) You tried to read from a filehandle opened only for writing. If you +intended it to be a read/write filehandle, you needed to open it with +"+<" or "+>" or "+>>" instead of with "<" or nothing. If +you intended only to read from the file, use "<". See +L. + +=item flock() on closed filehandle %s + +(W) The filehandle you're attempting to flock() got itself closed some +time before now. Check your logic flow. flock() operates on filehandles. +Are you attempting to call flock() on a dirhandle by the same name? + +=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 "::"). + +=item Hexadecimal number > 0xffffffff non-portable + +(W) The hexadecimal number you specified is larger than 2**32-1 +(4294967295) and therefore non-portable between systems. See +L for more on portability concerns. + +=item Ill-formed CRTL environ value "%s" + +(W) A warning peculiar to VMS. Perl tried to read the CRTL's internal +environ array, and encountered an element without the C<=> delimiter +used to spearate keys from values. The element is ignored. + +=item Ill-formed message in prime_env_iter: |%s| + +(W) A warning peculiar to VMS. Perl tried to read a logical name +or CLI symbol definition when preparing to iterate over %ENV, and +didn't see the expected delimiter between key and value, so the +line was ignored. + +=item Illegal binary digit %s + +(F) You used a digit other than 0 or 1 in a binary number. + +=item Illegal binary digit %s ignored + +(W) 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. + +=item Illegal number of bits in vec + +(F) The number of bits in vec() (the third argument) must be a power of +two from 1 to 32 (or 64, if your platform supports that). + +=item Integer overflow in %s number + +(W) The hexadecimal, octal or binary number you have specified either +as a literal or as an argument to hex() or oct() 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. + +=item Invalid %s attribute: %s + +The indicated attribute for a subroutine or variable was not recognized +by Perl or by a user-supplied handler. See L. + +=item Invalid %s attributes: %s + +The indicated attributes for a subroutine or variable were not recognized +by Perl or by a user-supplied handler. See L. + +=item invalid [] range "%s" in regexp + +The offending range is now explicitly displayed. + +=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 L. + +=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. + +=item leaving effective %s failed + +(F) While under the C pragma, switching the real and +effective uids or gids failed. + +=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 L. + +=item Method %s not permitted + +See Server error. + +=item Missing %sbrace%s on \N{} + +(F) Wrong syntax of character name literal C<\N{charname}> within +double-quotish context. + +=item Missing command in piped open + +(W) You used the C or C +construction, but the command was missing or blank. + +=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. + +=item No %s specified for -%c + +(F) The indicated command line switch needs a mandatory argument, but +you haven't specified one. + +=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. + +=item No space allowed after -%c + +(F) The argument to the indicated command line switch must follow immediately +after the switch, without intervening spaces. + +=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 F +to translate to the number of seconds which need to be added to UTC to +get local time. + +=item Octal number > 037777777777 non-portable + +(W) The octal number you specified is larger than 2**32-1 (4294967295) +and therefore non-portable between systems. See L for more +on portability concerns. + +See also L for writing portable code. + +=item panic: del_backref + +(P) Failed an internal consistency check while trying to reset a weak +reference. + +=item panic: kid popen errno read + +(F) forked child returned an incomprehensible message about its errno. + +=item panic: magic_killbackrefs + +(P) Failed an internal consistency check while trying to reset all weak +references to an object. + +=item Parentheses missing around "%s" list + +(W) You said something like + + my $foo, $bar = @_; + +when you meant + + my ($foo, $bar) = @_; + +Remember that "my", "our", and "local" bind tighter than comma. + +=item Possible Y2K bug: %s + +(W) You are concatenating the number 19 with another number, which +could be a potential Year 2000 problem. + +=item Premature end of script headers + +See Server error. + +=item Repeat count in pack overflows + +(F) You can't specify a repeat count so large that it overflows +your signed integers. See L. + +=item Repeat count in unpack overflows + +(F) You can't specify a repeat count so large that it overflows +your signed integers. See L. + +=item realloc() of freed memory ignored + +(S) An internal routine called realloc() on something that had already +been freed. + +=item Reference is already weak + +(W) You have attempted to weaken a reference that is already weak. +Doing so has no effect. + +=item setpgrp can't take arguments + +(F) Your system has the setpgrp() from BSD 4.2, which takes no arguments, +unlike POSIX setpgid(), which takes a process ID and process group ID. + +=item Strange *+?{} on zero-length expression + +(W) 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 C, not C. + +=item switching effective %s is not implemented + +(F) While under the C pragma, we cannot switch the +real and effective uids or gids. + +=item This Perl can't reset CRTL environ elements (%s) + +=item This Perl can't set CRTL environ elements (%s=%s) + +(W) 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 setenv() function. You'll need to +rebuild Perl with a CRTL that does, or redefine F (see +L) so that the environ array isn't the target of the change to +%ENV which produced the warning. + +=item Unknown open() mode '%s' + +(F) The second argument of 3-argument open() is not among the list +of valid modes: C<< < >>, C<< > >>, C<<< >> >>>, C<< +< >>, +C<< +> >>, C<<< +>> >>>, C<-|>, C<|->. + +=item Unknown process %x sent message to prime_env_iter: %s + +(P) An error peculiar to VMS. Perl was reading values for %ENV 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 %ENV for nefarious purposes. + +=item Unrecognized escape \\%c passed through + +(W) You used a backslash-character combination which is not recognized +by Perl. The character was understood literally. + +=item Unterminated attribute parameter in attribute list + +(F) The lexer saw an opening (left) parenthesis character while parsing an +attribute list, but the matching closing (right) parenthesis +character was not found. You may need to add (or remove) a backslash +character to get your parentheses to balance. See L. + +=item Unterminated attribute list + +(F) The lexer found something other than a simple identifier at the start +of an attribute, and it wasn't a semicolon or the start of a +block. Perhaps you terminated the parameter list of the previous attribute +too soon. See L. + +=item Unterminated attribute parameter in subroutine attribute list + +(F) The lexer saw an opening (left) parenthesis character while parsing a +subroutine attribute list, but the matching closing (right) parenthesis +character was not found. You may need to add (or remove) a backslash +character to get your parentheses to balance. + +=item Unterminated subroutine attribute list + +(F) The lexer found something other than a simple identifier at the start +of a subroutine attribute, and it wasn't a semicolon or the start of a +block. Perhaps you terminated the parameter list of the previous attribute +too soon. + +=item Value of CLI symbol "%s" too long + +(W) A warning peculiar to VMS. Perl tried to read the value of an %ENV +element from a CLI symbol table, and found a resultant string longer +than 1024 characters. The return value has been truncated to 1024 +characters. + +=item Version number must be a constant number + +(P) The attempt to translate a C statement into +its equivalent C block found an internal inconsistency with +the version number. + +=back + =head1 Obsolete Diagnostics -Todo. +=over 4 + +=item Character class syntax [: :] is reserved for future extensions -=head1 Configuration Changes +(W) Within regular expression character classes ([]) the syntax beginning +with "[:" and ending with ":]" is reserved for future extensions. +If you need to represent those character sequences inside a regular +expression character class, just quote the square brackets with the +backslash: "\[:" and ":\]". -=head2 installusrbinperl +=item Ill-formed logical name |%s| in prime_env_iter -You can use "Configure -Uinstallusrbinperl" which causes installperl -to skip installing perl also as /usr/bin/perl. This is useful if you -prefer not to modify /usr/bin for some reason or another but harmful -because many scripts assume to find Perl in /usr/bin/perl. +(W) A warning peculiar to VMS. A logical name was encountered when preparing +to iterate over %ENV which violates the syntactic rules governing logical +names. Because it cannot be translated normally, it is skipped, and will not +appear in %ENV. 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. -=head2 SOCKS support +=item Probable precedence problem on %s -You can use "Configure -Dusesocks" which causes Perl to probe -for the SOCKS proxy protocol library, http://www.socks.nec.com/ +(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: + + open FOO || die; + +=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 L. + +=item Use of "$$" to mean "${$}" 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. + +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 "$$" 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. + +=back =head1 BUGS -If you find what you think is a bug, you might check the headers of +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. @@ -536,8 +2610,8 @@ The F and F files for copyright information. =head1 HISTORY -Written by Gurusamy Sarathy >, with many contributions -from The Perl Porters. +Written by Gurusamy Sarathy >, with many +contributions from The Perl Porters. Send omissions or corrections to >.