1PERL56DELTA(1)         Perl Programmers Reference Guide         PERL56DELTA(1)
2
3
4

NAME

6       perl56delta - what's new for perl v5.6.0
7

DESCRIPTION

9       This document describes differences between the 5.005 release and the
10       5.6.0 release.
11

Core Enhancements

13   Interpreter cloning, threads, and concurrency
14       Perl 5.6.0 introduces the beginnings of support for running multiple
15       interpreters concurrently in different threads.  In conjunction with
16       the perl_clone() API call, which can be used to selectively duplicate
17       the state of any given interpreter, it is possible to compile a piece
18       of code once in an interpreter, clone that interpreter one or more
19       times, and run all the resulting interpreters in distinct threads.
20
21       On the Windows platform, this feature is used to emulate fork() at the
22       interpreter level.  See perlfork for details about that.
23
24       This feature is still in evolution.  It is eventually meant to be used
25       to selectively clone a subroutine and data reachable from that
26       subroutine in a separate interpreter and run the cloned subroutine in a
27       separate thread.  Since there is no shared data between the
28       interpreters, little or no locking will be needed (unless parts of the
29       symbol table are explicitly shared).  This is obviously intended to be
30       an easy-to-use replacement for the existing threads support.
31
32       Support for cloning interpreters and interpreter concurrency can be
33       enabled using the -Dusethreads Configure option (see win32/Makefile for
34       how to enable it on Windows.)  The resulting perl executable will be
35       functionally identical to one that was built with -Dmultiplicity, but
36       the perl_clone() API call will only be available in the former.
37
38       -Dusethreads enables the cpp macro USE_ITHREADS by default, which in
39       turn enables Perl source code changes that provide a clear separation
40       between the op tree and the data it operates with.  The former is
41       immutable, and can therefore be shared between an interpreter and all
42       of its clones, while the latter is considered local to each
43       interpreter, and is therefore copied for each clone.
44
45       Note that building Perl with the -Dusemultiplicity Configure option is
46       adequate if you wish to run multiple independent interpreters
47       concurrently in different threads.  -Dusethreads only provides the
48       additional functionality of the perl_clone() API call and other support
49       for running cloned interpreters concurrently.
50
51           NOTE: This is an experimental feature.  Implementation details are
52           subject to change.
53
54   Lexically scoped warning categories
55       You can now control the granularity of warnings emitted by perl at a
56       finer level using the "use warnings" pragma.  warnings and perllexwarn
57       have copious documentation on this feature.
58
59   Unicode and UTF-8 support
60       Perl now uses UTF-8 as its internal representation for character
61       strings.  The "utf8" and "bytes" pragmas are used to control this
62       support in the current lexical scope.  See perlunicode, utf8 and bytes
63       for more information.
64
65       This feature is expected to evolve quickly to support some form of I/O
66       disciplines that can be used to specify the kind of input and output
67       data (bytes or characters).  Until that happens, additional modules
68       from CPAN will be needed to complete the toolkit for dealing with
69       Unicode.
70
71           NOTE: This should be considered an experimental feature.  Implementation
72           details are subject to change.
73
74   Support for interpolating named characters
75       The new "\N" escape interpolates named characters within strings.  For
76       example, "Hi! \N{WHITE SMILING FACE}" evaluates to a string with a
77       unicode smiley face at the end.
78
79   "our" declarations
80       An "our" declaration introduces a value that can be best understood as
81       a lexically scoped symbolic alias to a global variable in the package
82       that was current where the variable was declared.  This is mostly
83       useful as an alternative to the "vars" pragma, but also provides the
84       opportunity to introduce typing and other attributes for such
85       variables.  See "our" in perlfunc.
86
87   Support for strings represented as a vector of ordinals
88       Literals of the form "v1.2.3.4" are now parsed as a string composed of
89       characters with the specified ordinals.  This is an alternative, more
90       readable way to construct (possibly unicode) strings instead of
91       interpolating characters, as in "\x{1}\x{2}\x{3}\x{4}".  The leading
92       "v" may be omitted if there are more than two ordinals, so 1.2.3 is
93       parsed the same as "v1.2.3".
94
95       Strings written in this form are also useful to represent version
96       "numbers".  It is easy to compare such version "numbers" (which are
97       really just plain strings) using any of the usual string comparison
98       operators "eq", "ne", "lt", "gt", etc., or perform bitwise string
99       operations on them using "|", "&", etc.
100
101       In conjunction with the new $^V magic variable (which contains the perl
102       version as a string), such literals can be used as a readable way to
103       check if you're running a particular version of Perl:
104
105           # this will parse in older versions of Perl also
106           if ($^V and $^V gt v5.6.0) {
107               # new features supported
108           }
109
110       "require" and "use" also have some special magic to support such
111       literals, but this particular usage should be avoided because it leads
112       to misleading error messages under versions of Perl which don't support
113       vector strings.  Using a true version number will ensure correct
114       behavior in all versions of Perl:
115
116           require 5.006;    # run time check for v5.6
117           use 5.006_001;    # compile time check for v5.6.1
118
119       Also, "sprintf" and "printf" support the Perl-specific format flag %v
120       to print ordinals of characters in arbitrary strings:
121
122           printf "v%vd", $^V;         # prints current version, such as "v5.5.650"
123           printf "%*vX", ":", $addr;  # formats IPv6 address
124           printf "%*vb", " ", $bits;  # displays bitstring
125
126       See "Scalar value constructors" in perldata for additional information.
127
128   Improved Perl version numbering system
129       Beginning with Perl version 5.6.0, the version number convention has
130       been changed to a "dotted integer" scheme that is more commonly found
131       in open source projects.
132
133       Maintenance versions of v5.6.0 will be released as v5.6.1, v5.6.2 etc.
134       The next development series following v5.6.0 will be numbered v5.7.x,
135       beginning with v5.7.0, and the next major production release following
136       v5.6.0 will be v5.8.0.
137
138       The English module now sets $PERL_VERSION to $^V (a string value)
139       rather than $] (a numeric value).  (This is a potential
140       incompatibility.  Send us a report via perlbug if you are affected by
141       this.)
142
143       The v1.2.3 syntax is also now legal in Perl.  See "Support for strings
144       represented as a vector of ordinals" for more on that.
145
146       To cope with the new versioning system's use of at least three
147       significant digits for each version component, the method used for
148       incrementing the subversion number has also changed slightly.  We
149       assume that versions older than v5.6.0 have been incrementing the
150       subversion component in multiples of 10.  Versions after v5.6.0 will
151       increment them by 1.  Thus, using the new notation, 5.005_03 is the
152       "same" as v5.5.30, and the first maintenance version following v5.6.0
153       will be v5.6.1 (which should be read as being equivalent to a floating
154       point value of 5.006_001 in the older format, stored in $]).
155
156   New syntax for declaring subroutine attributes
157       Formerly, if you wanted to mark a subroutine as being a method call or
158       as requiring an automatic lock() when it is entered, you had to declare
159       that with a "use attrs" pragma in the body of the subroutine.  That can
160       now be accomplished with declaration syntax, like this:
161
162           sub mymethod : locked method;
163           ...
164           sub mymethod : locked method {
165               ...
166           }
167
168           sub othermethod :locked :method;
169           ...
170           sub othermethod :locked :method {
171               ...
172           }
173
174       (Note how only the first ":" is mandatory, and whitespace surrounding
175       the ":" is optional.)
176
177       AutoSplit.pm and SelfLoader.pm have been updated to keep the attributes
178       with the stubs they provide.  See attributes.
179
180   File and directory handles can be autovivified
181       Similar to how constructs such as "$x->[0]" autovivify a reference,
182       handle constructors (open(), opendir(), pipe(), socketpair(),
183       sysopen(), socket(), and accept()) now autovivify a file or directory
184       handle if the handle passed to them is an uninitialized scalar
185       variable.  This allows the constructs such as "open(my $fh, ...)" and
186       "open(local $fh,...)"  to be used to create filehandles that will
187       conveniently be closed automatically when the scope ends, provided
188       there are no other references to them.  This largely eliminates the
189       need for typeglobs when opening filehandles that must be passed around,
190       as in the following example:
191
192           sub myopen {
193               open my $fh, "@_"
194                    or die "Can't open '@_': $!";
195               return $fh;
196           }
197
198           {
199               my $f = myopen("</etc/motd");
200               print <$f>;
201               # $f implicitly closed here
202           }
203
204   open() with more than two arguments
205       If open() is passed three arguments instead of two, the second argument
206       is used as the mode and the third argument is taken to be the file
207       name.  This is primarily useful for protecting against unintended magic
208       behavior of the traditional two-argument form.  See "open" in perlfunc.
209
210   64-bit support
211       Any platform that has 64-bit integers either
212
213               (1) natively as longs or ints
214               (2) via special compiler flags
215               (3) using long long or int64_t
216
217       is able to use "quads" (64-bit integers) as follows:
218
219       •   constants (decimal, hexadecimal, octal, binary) in the code
220
221       •   arguments to oct() and hex()
222
223       •   arguments to print(), printf() and sprintf() (flag prefixes ll, L,
224           q)
225
226       •   printed as such
227
228pack() and unpack() "q" and "Q" formats
229
230       •   in basic arithmetics: + - * / % (NOTE: operating close to the
231           limits of the integer values may produce surprising results)
232
233       •   in bit arithmetics: & | ^ ~ << >> (NOTE: these used to be forced to
234           be 32 bits wide but now operate on the full native width.)
235
236vec()
237
238       Note that unless you have the case (a) you will have to configure and
239       compile Perl using the -Duse64bitint Configure flag.
240
241           NOTE: The Configure flags -Duselonglong and -Duse64bits have been
242           deprecated.  Use -Duse64bitint instead.
243
244       There are actually two modes of 64-bitness: the first one is achieved
245       using Configure -Duse64bitint and the second one using Configure
246       -Duse64bitall.  The difference is that the first one is minimal and the
247       second one maximal.  The first works in more places than the second.
248
249       The "use64bitint" does only as much as is required to get 64-bit
250       integers into Perl (this may mean, for example, using "long longs")
251       while your memory may still be limited to 2 gigabytes (because your
252       pointers could still be 32-bit).  Note that the name "64bitint" does
253       not imply that your C compiler will be using 64-bit "int"s (it might,
254       but it doesn't have to): the "use64bitint" means that you will be able
255       to have 64 bits wide scalar values.
256
257       The "use64bitall" goes all the way by attempting to switch also
258       integers (if it can), longs (and pointers) to being 64-bit.  This may
259       create an even more binary incompatible Perl than -Duse64bitint: the
260       resulting executable may not run at all in a 32-bit box, or you may
261       have to reboot/reconfigure/rebuild your operating system to be 64-bit
262       aware.
263
264       Natively 64-bit systems like Alpha and Cray need neither -Duse64bitint
265       nor -Duse64bitall.
266
267       Last but not least: note that due to Perl's habit of always using
268       floating point numbers, the quads are still not true integers.  When
269       quads overflow their limits (0...18_446_744_073_709_551_615 unsigned,
270       -9_223_372_036_854_775_808...9_223_372_036_854_775_807 signed), they
271       are silently promoted to floating point numbers, after which they will
272       start losing precision (in their lower digits).
273
274           NOTE: 64-bit support is still experimental on most platforms.
275           Existing support only covers the LP64 data model.  In particular, the
276           LLP64 data model is not yet supported.  64-bit libraries and system
277           APIs on many platforms have not stabilized--your mileage may vary.
278
279   Large file support
280       If you have filesystems that support "large files" (files larger than 2
281       gigabytes), you may now also be able to create and access them from
282       Perl.
283
284           NOTE: The default action is to enable large file support, if
285           available on the platform.
286
287       If the large file support is on, and you have a Fcntl constant
288       O_LARGEFILE, the O_LARGEFILE is automatically added to the flags of
289       sysopen().
290
291       Beware that unless your filesystem also supports "sparse files" seeking
292       to umpteen petabytes may be inadvisable.
293
294       Note that in addition to requiring a proper file system to do large
295       files you may also need to adjust your per-process (or your per-system,
296       or per-process-group, or per-user-group) maximum filesize limits before
297       running Perl scripts that try to handle large files, especially if you
298       intend to write such files.
299
300       Finally, in addition to your process/process group maximum filesize
301       limits, you may have quota limits on your filesystems that stop you
302       (your user id or your user group id) from using large files.
303
304       Adjusting your process/user/group/file system/operating system limits
305       is outside the scope of Perl core language.  For process limits, you
306       may try increasing the limits using your shell's limits/limit/ulimit
307       command before running Perl.  The BSD::Resource extension (not included
308       with the standard Perl distribution) may also be of use, it offers the
309       getrlimit/setrlimit interface that can be used to adjust process
310       resource usage limits, including the maximum filesize limit.
311
312   Long doubles
313       In some systems you may be able to use long doubles to enhance the
314       range and precision of your double precision floating point numbers
315       (that is, Perl's numbers).  Use Configure -Duselongdouble to enable
316       this support (if it is available).
317
318   "more bits"
319       You can "Configure -Dusemorebits" to turn on both the 64-bit support
320       and the long double support.
321
322   Enhanced support for sort() subroutines
323       Perl subroutines with a prototype of "($$)", and XSUBs in general, can
324       now be used as sort subroutines.  In either case, the two elements to
325       be compared are passed as normal parameters in @_.  See "sort" in
326       perlfunc.
327
328       For unprototyped sort subroutines, the historical behavior of passing
329       the elements to be compared as the global variables $a and $b remains
330       unchanged.
331
332   "sort $coderef @foo" allowed
333       sort() did not accept a subroutine reference as the comparison function
334       in earlier versions.  This is now permitted.
335
336   File globbing implemented internally
337       Perl now uses the File::Glob implementation of the glob() operator
338       automatically.  This avoids using an external csh process and the
339       problems associated with it.
340
341           NOTE: This is currently an experimental feature.  Interfaces and
342           implementation are subject to change.
343
344   Support for CHECK blocks
345       In addition to "BEGIN", "INIT", "END", "DESTROY" and "AUTOLOAD",
346       subroutines named "CHECK" are now special.  These are queued up during
347       compilation and behave similar to END blocks, except they are called at
348       the end of compilation rather than at the end of execution.  They
349       cannot be called directly.
350
351   POSIX character class syntax [: :] supported
352       For example to match alphabetic characters use /[[:alpha:]]/.  See
353       perlre for details.
354
355   Better pseudo-random number generator
356       In 5.005_0x and earlier, perl's rand() function used the C library
357       rand(3) function.  As of 5.005_52, Configure tests for drand48(),
358       random(), and rand() (in that order) and picks the first one it finds.
359
360       These changes should result in better random numbers from rand().
361
362   Improved "qw//" operator
363       The "qw//" operator is now evaluated at compile time into a true list
364       instead of being replaced with a run time call to "split()".  This
365       removes the confusing misbehaviour of "qw//" in scalar context, which
366       had inherited that behaviour from split().
367
368       Thus:
369
370           $foo = ($bar) = qw(a b c); print "$foo|$bar\n";
371
372       now correctly prints "3|a", instead of "2|a".
373
374   Better worst-case behavior of hashes
375       Small changes in the hashing algorithm have been implemented in order
376       to improve the distribution of lower order bits in the hashed value.
377       This is expected to yield better performance on keys that are repeated
378       sequences.
379
380   pack() format 'Z' supported
381       The new format type 'Z' is useful for packing and unpacking null-
382       terminated strings.  See "pack" in perlfunc.
383
384   pack() format modifier '!' supported
385       The new format type modifier '!' is useful for packing and unpacking
386       native shorts, ints, and longs.  See "pack" in perlfunc.
387
388   pack() and unpack() support counted strings
389       The template character '/' can be used to specify a counted string type
390       to be packed or unpacked.  See "pack" in perlfunc.
391
392   Comments in pack() templates
393       The '#' character in a template introduces a comment up to end of the
394       line.  This facilitates documentation of pack() templates.
395
396   Weak references
397       In previous versions of Perl, you couldn't cache objects so as to allow
398       them to be deleted if the last reference from outside the cache is
399       deleted.  The reference in the cache would hold a reference count on
400       the object and the objects would never be destroyed.
401
402       Another familiar problem is with circular references.  When an object
403       references itself, its reference count would never go down to zero, and
404       it would not get destroyed until the program is about to exit.
405
406       Weak references solve this by allowing you to "weaken" any reference,
407       that is, make it not count towards the reference count.  When the last
408       non-weak reference to an object is deleted, the object is destroyed and
409       all the weak references to the object are automatically undef-ed.
410
411       To use this feature, you need the Devel::WeakRef package from CPAN,
412       which contains additional documentation.
413
414           NOTE: This is an experimental feature.  Details are subject to change.
415
416   Binary numbers supported
417       Binary numbers are now supported as literals, in s?printf formats, and
418       "oct()":
419
420           $answer = 0b101010;
421           printf "The answer is: %b\n", oct("0b101010");
422
423   Lvalue subroutines
424       Subroutines can now return modifiable lvalues.  See "Lvalue
425       subroutines" in perlsub.
426
427           NOTE: This is an experimental feature.  Details are subject to change.
428
429   Some arrows may be omitted in calls through references
430       Perl now allows the arrow to be omitted in many constructs involving
431       subroutine calls through references.  For example, "$foo[10]->('foo')"
432       may now be written "$foo[10]('foo')".  This is rather similar to how
433       the arrow may be omitted from "$foo[10]->{'foo'}".  Note however, that
434       the arrow is still required for "foo(10)->('bar')".
435
436   Boolean assignment operators are legal lvalues
437       Constructs such as "($a ||= 2) += 1" are now allowed.
438
439   exists() is supported on subroutine names
440       The exists() builtin now works on subroutine names.  A subroutine is
441       considered to exist if it has been declared (even if implicitly).  See
442       "exists" in perlfunc for examples.
443
444   exists() and delete() are supported on array elements
445       The exists() and delete() builtins now work on simple arrays as well.
446       The behavior is similar to that on hash elements.
447
448       exists() can be used to check whether an array element has been
449       initialized.  This avoids autovivifying array elements that don't
450       exist.  If the array is tied, the EXISTS() method in the corresponding
451       tied package will be invoked.
452
453       delete() may be used to remove an element from the array and return it.
454       The array element at that position returns to its uninitialized state,
455       so that testing for the same element with exists() will return false.
456       If the element happens to be the one at the end, the size of the array
457       also shrinks up to the highest element that tests true for exists(), or
458       0 if none such is found.  If the array is tied, the DELETE() method in
459       the corresponding tied package will be invoked.
460
461       See "exists" in perlfunc and "delete" in perlfunc for examples.
462
463   Pseudo-hashes work better
464       Dereferencing some types of reference values in a pseudo-hash, such as
465       "$ph->{foo}[1]", was accidentally disallowed.  This has been corrected.
466
467       When applied to a pseudo-hash element, exists() now reports whether the
468       specified value exists, not merely if the key is valid.
469
470       delete() now works on pseudo-hashes.  When given a pseudo-hash element
471       or slice it deletes the values corresponding to the keys (but not the
472       keys themselves).  See "Pseudo-hashes: Using an array as a hash" in
473       perlref.
474
475       Pseudo-hash slices with constant keys are now optimized to array
476       lookups at compile-time.
477
478       List assignments to pseudo-hash slices are now supported.
479
480       The "fields" pragma now provides ways to create pseudo-hashes, via
481       fields::new() and fields::phash().  See fields.
482
483           NOTE: The pseudo-hash data type continues to be experimental.
484           Limiting oneself to the interface elements provided by the
485           fields pragma will provide protection from any future changes.
486
487   Automatic flushing of output buffers
488       fork(), exec(), system(), qx//, and pipe open()s now flush buffers of
489       all files opened for output when the operation was attempted.  This
490       mostly eliminates confusing buffering mishaps suffered by users unaware
491       of how Perl internally handles I/O.
492
493       This is not supported on some platforms like Solaris where a suitably
494       correct implementation of fflush(NULL) isn't available.
495
496   Better diagnostics on meaningless filehandle operations
497       Constructs such as "open(<FH>)" and "close(<FH>)" are compile time
498       errors.  Attempting to read from filehandles that were opened only for
499       writing will now produce warnings (just as writing to read-only
500       filehandles does).
501
502   Where possible, buffered data discarded from duped input filehandle
503       "open(NEW, "<&OLD")" now attempts to discard any data that was
504       previously read and buffered in "OLD" before duping the handle.  On
505       platforms where doing this is allowed, the next read operation on "NEW"
506       will return the same data as the corresponding operation on "OLD".
507       Formerly, it would have returned the data from the start of the
508       following disk block instead.
509
510   eof() has the same old magic as <>
511       "eof()" would return true if no attempt to read from "<>" had yet been
512       made.  "eof()" has been changed to have a little magic of its own, it
513       now opens the "<>" files.
514
515   binmode() can be used to set :crlf and :raw modes
516       binmode() now accepts a second argument that specifies a discipline for
517       the handle in question.  The two pseudo-disciplines ":raw" and ":crlf"
518       are currently supported on DOS-derivative platforms.  See "binmode" in
519       perlfunc and open.
520
521   "-T" filetest recognizes UTF-8 encoded files as "text"
522       The algorithm used for the "-T" filetest has been enhanced to correctly
523       identify UTF-8 content as "text".
524
525   system(), backticks and pipe open now reflect exec() failure
526       On Unix and similar platforms, system(), qx() and open(FOO, "cmd |")
527       etc., are implemented via fork() and exec().  When the underlying
528       exec() fails, earlier versions did not report the error properly, since
529       the exec() happened to be in a different process.
530
531       The child process now communicates with the parent about the error in
532       launching the external command, which allows these constructs to return
533       with their usual error value and set $!.
534
535   Improved diagnostics
536       Line numbers are no longer suppressed (under most likely circumstances)
537       during the global destruction phase.
538
539       Diagnostics emitted from code running in threads other than the main
540       thread are now accompanied by the thread ID.
541
542       Embedded null characters in diagnostics now actually show up.  They
543       used to truncate the message in prior versions.
544
545       $foo::a and $foo::b are now exempt from "possible typo" warnings only
546       if sort() is encountered in package "foo".
547
548       Unrecognized alphabetic escapes encountered when parsing quote
549       constructs now generate a warning, since they may take on new semantics
550       in later versions of Perl.
551
552       Many diagnostics now report the internal operation in which the warning
553       was provoked, like so:
554
555           Use of uninitialized value in concatenation (.) at (eval 1) line 1.
556           Use of uninitialized value in print at (eval 1) line 1.
557
558       Diagnostics  that occur within eval may also report the file and line
559       number where the eval is located, in addition to the eval sequence
560       number and the line number within the evaluated text itself.  For
561       example:
562
563           Not enough arguments for scalar at (eval 4)[newlib/perl5db.pl:1411] line 2, at EOF
564
565   Diagnostics follow STDERR
566       Diagnostic output now goes to whichever file the "STDERR" handle is
567       pointing at, instead of always going to the underlying C runtime
568       library's "stderr".
569
570   More consistent close-on-exec behavior
571       On systems that support a close-on-exec flag on filehandles, the flag
572       is now set for any handles created by pipe(), socketpair(), socket(),
573       and accept(), if that is warranted by the value of $^F that may be in
574       effect.  Earlier versions neglected to set the flag for handles created
575       with these operators.  See "pipe" in perlfunc, "socketpair" in
576       perlfunc, "socket" in perlfunc, "accept" in perlfunc, and "$^F" in
577       perlvar.
578
579   syswrite() ease-of-use
580       The length argument of "syswrite()" has become optional.
581
582   Better syntax checks on parenthesized unary operators
583       Expressions such as:
584
585           print defined(&foo,&bar,&baz);
586           print uc("foo","bar","baz");
587           undef($foo,&bar);
588
589       used to be accidentally allowed in earlier versions, and produced
590       unpredictable behaviour.  Some produced ancillary warnings when used in
591       this way; others silently did the wrong thing.
592
593       The parenthesized forms of most unary operators that expect a single
594       argument now ensure that they are not called with more than one
595       argument, making the cases shown above syntax errors.  The usual
596       behaviour of:
597
598           print defined &foo, &bar, &baz;
599           print uc "foo", "bar", "baz";
600           undef $foo, &bar;
601
602       remains unchanged.  See perlop.
603
604   Bit operators support full native integer width
605       The bit operators (& | ^ ~ << >>) now operate on the full native
606       integral width (the exact size of which is available in
607       $Config{ivsize}).  For example, if your platform is either natively
608       64-bit or if Perl has been configured to use 64-bit integers, these
609       operations apply to 8 bytes (as opposed to 4 bytes on 32-bit
610       platforms).  For portability, be sure to mask off the excess bits in
611       the result of unary "~", e.g., "~$x & 0xffffffff".
612
613   Improved security features
614       More potentially unsafe operations taint their results for improved
615       security.
616
617       The "passwd" and "shell" fields returned by the getpwent(), getpwnam(),
618       and getpwuid() are now tainted, because the user can affect their own
619       encrypted password and login shell.
620
621       The variable modified by shmread(), and messages returned by msgrcv()
622       (and its object-oriented interface IPC::SysV::Msg::rcv) are also
623       tainted, because other untrusted processes can modify messages and
624       shared memory segments for their own nefarious purposes.
625
626   More functional bareword prototype (*)
627       Bareword prototypes have been rationalized to enable them to be used to
628       override builtins that accept barewords and interpret them in a special
629       way, such as "require" or "do".
630
631       Arguments prototyped as "*" will now be visible within the subroutine
632       as either a simple scalar or as a reference to a typeglob.  See
633       "Prototypes" in perlsub.
634
635   "require" and "do" may be overridden
636       "require" and "do 'file'" operations may be overridden locally by
637       importing subroutines of the same name into the current package (or
638       globally by importing them into the CORE::GLOBAL:: namespace).
639       Overriding "require" will also affect "use", provided the override is
640       visible at compile-time.  See "Overriding Built-in Functions" in
641       perlsub.
642
643   $^X variables may now have names longer than one character
644       Formerly, $^X was synonymous with ${"\cX"}, but $^XY was a syntax
645       error.  Now variable names that begin with a control character may be
646       arbitrarily long.  However, for compatibility reasons, these variables
647       must be written with explicit braces, as "${^XY}" for example.
648       "${^XYZ}" is synonymous with ${"\cXYZ"}.  Variable names with more than
649       one control character, such as "${^XY^Z}", are illegal.
650
651       The old syntax has not changed.  As before, `^X' may be either a
652       literal control-X character or the two-character sequence `caret' plus
653       `X'.  When braces are omitted, the variable name stops after the
654       control character.  Thus "$^XYZ" continues to be synonymous with "$^X .
655       "YZ"" as before.
656
657       As before, lexical variables may not have names beginning with control
658       characters.  As before, variables whose names begin with a control
659       character are always forced to be in package `main'.  All such
660       variables are reserved for future extensions, except those that begin
661       with "^_", which may be used by user programs and are guaranteed not to
662       acquire special meaning in any future version of Perl.
663
664   New variable $^C reflects "-c" switch
665       $^C has a boolean value that reflects whether perl is being run in
666       compile-only mode (i.e. via the "-c" switch).  Since BEGIN blocks are
667       executed under such conditions, this variable enables perl code to
668       determine whether actions that make sense only during normal running
669       are warranted.  See perlvar.
670
671   New variable $^V contains Perl version as a string
672       $^V contains the Perl version number as a string composed of characters
673       whose ordinals match the version numbers, i.e. v5.6.0.  This may be
674       used in string comparisons.
675
676       See "Support for strings represented as a vector of ordinals" for an
677       example.
678
679   Optional Y2K warnings
680       If Perl is built with the cpp macro "PERL_Y2KWARN" defined, it emits
681       optional warnings when concatenating the number 19 with another number.
682
683       This behavior must be specifically enabled when running Configure.  See
684       INSTALL and README.Y2K.
685
686   Arrays now always interpolate into double-quoted strings
687       In double-quoted strings, arrays now interpolate, no matter what.  The
688       behavior in earlier versions of perl 5 was that arrays would
689       interpolate into strings if the array had been mentioned before the
690       string was compiled, and otherwise Perl would raise a fatal compile-
691       time error.  In versions 5.000 through 5.003, the error was
692
693               Literal @example now requires backslash
694
695       In versions 5.004_01 through 5.6.0, the error was
696
697               In string, @example now must be written as \@example
698
699       The idea here was to get people into the habit of writing
700       "fred\@example.com" when they wanted a literal "@" sign, just as they
701       have always written "Give me back my \$5" when they wanted a literal
702       "$" sign.
703
704       Starting with 5.6.1, when Perl now sees an "@" sign in a double-quoted
705       string, it always attempts to interpolate an array, regardless of
706       whether or not the array has been used or declared already.  The fatal
707       error has been downgraded to an optional warning:
708
709               Possible unintended interpolation of @example in string
710
711       This warns you that "fred@example.com" is going to turn into "fred.com"
712       if you don't backslash the "@".  See
713       http://perl.plover.com/at-error.html for more details about the history
714       here.
715
716   @- and @+ provide starting/ending offsets of regex matches
717       The new magic variables @- and @+ provide the starting and ending
718       offsets, respectively, of $&, $1, $2, etc.  See perlvar for details.
719

Modules and Pragmata

721   Modules
722       attributes
723           While used internally by Perl as a pragma, this module also
724           provides a way to fetch subroutine and variable attributes.  See
725           attributes.
726
727       B   The Perl Compiler suite has been extensively reworked for this
728           release.  More of the standard Perl test suite passes when run
729           under the Compiler, but there is still a significant way to go to
730           achieve production quality compiled executables.
731
732               NOTE: The Compiler suite remains highly experimental.  The
733               generated code may not be correct, even when it manages to execute
734               without errors.
735
736       Benchmark
737           Overall, Benchmark results exhibit lower average error and better
738           timing accuracy.
739
740           You can now run tests for n seconds instead of guessing the right
741           number of tests to run: e.g., timethese(-5, ...) will run each code
742           for at least 5 CPU seconds.  Zero as the "number of repetitions"
743           means "for at least 3 CPU seconds".  The output format has also
744           changed.  For example:
745
746              use Benchmark;$x=3;timethese(-5,{a=>sub{$x*$x},b=>sub{$x**2}})
747
748           will now output something like this:
749
750              Benchmark: running a, b, each for at least 5 CPU seconds...
751                       a:  5 wallclock secs ( 5.77 usr +  0.00 sys =  5.77 CPU) @ 200551.91/s (n=1156516)
752                       b:  4 wallclock secs ( 5.00 usr +  0.02 sys =  5.02 CPU) @ 159605.18/s (n=800686)
753
754           New features: "each for at least N CPU seconds...", "wallclock
755           secs", and the "@ operations/CPU second (n=operations)".
756
757           timethese() now returns a reference to a hash of Benchmark objects
758           containing the test results, keyed on the names of the tests.
759
760           timethis() now returns the iterations field in the Benchmark result
761           object instead of 0.
762
763           timethese(), timethis(), and the new cmpthese() (see below) can
764           also take a format specifier of 'none' to suppress output.
765
766           A new function countit() is just like timeit() except that it takes
767           a TIME instead of a COUNT.
768
769           A new function cmpthese() prints a chart comparing the results of
770           each test returned from a timethese() call.  For each possible pair
771           of tests, the percentage speed difference (iters/sec or
772           seconds/iter) is shown.
773
774           For other details, see Benchmark.
775
776       ByteLoader
777           The ByteLoader is a dedicated extension to generate and run Perl
778           bytecode.  See ByteLoader.
779
780       constant
781           References can now be used.
782
783           The new version also allows a leading underscore in constant names,
784           but disallows a double leading underscore (as in "__LINE__").  Some
785           other names are disallowed or warned against, including BEGIN, END,
786           etc.  Some names which were forced into main:: used to fail
787           silently in some cases; now they're fatal (outside of main::) and
788           an optional warning (inside of main::).  The ability to detect
789           whether a constant had been set with a given name has been added.
790
791           See constant.
792
793       charnames
794           This pragma implements the "\N" string escape.  See charnames.
795
796       Data::Dumper
797           A "Maxdepth" setting can be specified to avoid venturing too deeply
798           into deep data structures.  See Data::Dumper.
799
800           The XSUB implementation of Dump() is now automatically called if
801           the "Useqq" setting is not in use.
802
803           Dumping "qr//" objects works correctly.
804
805       DB  "DB" is an experimental module that exposes a clean abstraction to
806           Perl's debugging API.
807
808       DB_File
809           DB_File can now be built with Berkeley DB versions 1, 2 or 3.  See
810           "ext/DB_File/Changes".
811
812       Devel::DProf
813           Devel::DProf, a Perl source code profiler has been added.  See
814           Devel::DProf and dprofpp.
815
816       Devel::Peek
817           The Devel::Peek module provides access to the internal
818           representation of Perl variables and data.  It is a data debugging
819           tool for the XS programmer.
820
821       Dumpvalue
822           The Dumpvalue module provides screen dumps of Perl data.
823
824       DynaLoader
825           DynaLoader now supports a dl_unload_file() function on platforms
826           that support unloading shared objects using dlclose().
827
828           Perl can also optionally arrange to unload all extension shared
829           objects loaded by Perl.  To enable this, build Perl with the
830           Configure option "-Accflags=-DDL_UNLOAD_ALL_AT_EXIT".  (This maybe
831           useful if you are using Apache with mod_perl.)
832
833       English
834           $PERL_VERSION now stands for $^V (a string value) rather than for
835           $] (a numeric value).
836
837       Env Env now supports accessing environment variables like PATH as array
838           variables.
839
840       Fcntl
841           More Fcntl constants added: F_SETLK64, F_SETLKW64, O_LARGEFILE for
842           large file (more than 4GB) access (NOTE: the O_LARGEFILE is
843           automatically added to sysopen() flags if large file support has
844           been configured, as is the default), Free/Net/OpenBSD locking
845           behaviour flags F_FLOCK, F_POSIX, Linux F_SHLCK, and O_ACCMODE: the
846           combined mask of O_RDONLY, O_WRONLY, and O_RDWR.  The
847           seek()/sysseek() constants SEEK_SET, SEEK_CUR, and SEEK_END are
848           available via the ":seek" tag.  The chmod()/stat() S_IF* constants
849           and S_IS* functions are available via the ":mode" tag.
850
851       File::Compare
852           A compare_text() function has been added, which allows custom
853           comparison functions.  See File::Compare.
854
855       File::Find
856           File::Find now works correctly when the wanted() function is either
857           autoloaded or is a symbolic reference.
858
859           A bug that caused File::Find to lose track of the working directory
860           when pruning top-level directories has been fixed.
861
862           File::Find now also supports several other options to control its
863           behavior.  It can follow symbolic links if the "follow" option is
864           specified.  Enabling the "no_chdir" option will make File::Find
865           skip changing the current directory when walking directories.  The
866           "untaint" flag can be useful when running with taint checks
867           enabled.
868
869           See File::Find.
870
871       File::Glob
872           This extension implements BSD-style file globbing.  By default, it
873           will also be used for the internal implementation of the glob()
874           operator.  See File::Glob.
875
876       File::Spec
877           New methods have been added to the File::Spec module: devnull()
878           returns the name of the null device (/dev/null on Unix) and
879           tmpdir() the name of the temp directory (normally /tmp on Unix).
880           There are now also methods to convert between absolute and relative
881           filenames: abs2rel() and rel2abs().  For compatibility with
882           operating systems that specify volume names in file paths, the
883           splitpath(), splitdir(), and catdir() methods have been added.
884
885       File::Spec::Functions
886           The new File::Spec::Functions modules provides a function interface
887           to the File::Spec module.  Allows shorthand
888
889               $fullname = catfile($dir1, $dir2, $file);
890
891           instead of
892
893               $fullname = File::Spec->catfile($dir1, $dir2, $file);
894
895       Getopt::Long
896           Getopt::Long licensing has changed to allow the Perl Artistic
897           License as well as the GPL. It used to be GPL only, which got in
898           the way of non-GPL applications that wanted to use Getopt::Long.
899
900           Getopt::Long encourages the use of Pod::Usage to produce help
901           messages. For example:
902
903               use Getopt::Long;
904               use Pod::Usage;
905               my $man = 0;
906               my $help = 0;
907               GetOptions('help|?' => \$help, man => \$man) or pod2usage(2);
908               pod2usage(1) if $help;
909               pod2usage(-exitstatus => 0, -verbose => 2) if $man;
910
911               __END__
912
913               =head1 NAME
914
915               sample - Using Getopt::Long and Pod::Usage
916
917               =head1 SYNOPSIS
918
919               sample [options] [file ...]
920
921                Options:
922                  -help            brief help message
923                  -man             full documentation
924
925               =head1 OPTIONS
926
927               =over 8
928
929               =item B<-help>
930
931               Print a brief help message and exits.
932
933               =item B<-man>
934
935               Prints the manual page and exits.
936
937               =back
938
939               =head1 DESCRIPTION
940
941               B<This program> will read the given input file(s) and do something
942               useful with the contents thereof.
943
944               =cut
945
946           See Pod::Usage for details.
947
948           A bug that prevented the non-option call-back <> from being
949           specified as the first argument has been fixed.
950
951           To specify the characters < and > as option starters, use ><. Note,
952           however, that changing option starters is strongly deprecated.
953
954       IO  write() and syswrite() will now accept a single-argument form of
955           the call, for consistency with Perl's syswrite().
956
957           You can now create a TCP-based IO::Socket::INET without forcing a
958           connect attempt.  This allows you to configure its options (like
959           making it non-blocking) and then call connect() manually.
960
961           A bug that prevented the IO::Socket::protocol() accessor from ever
962           returning the correct value has been corrected.
963
964           IO::Socket::connect now uses non-blocking IO instead of alarm() to
965           do connect timeouts.
966
967           IO::Socket::accept now uses select() instead of alarm() for doing
968           timeouts.
969
970           IO::Socket::INET->new now sets $! correctly on failure. $@ is still
971           set for backwards compatibility.
972
973       JPL Java Perl Lingo is now distributed with Perl.  See jpl/README for
974           more information.
975
976       lib "use lib" now weeds out any trailing duplicate entries.  "no lib"
977           removes all named entries.
978
979       Math::BigInt
980           The bitwise operations "<<", ">>", "&", "|", and "~" are now
981           supported on bigints.
982
983       Math::Complex
984           The accessor methods Re, Im, arg, abs, rho, and theta can now also
985           act as mutators (accessor $z->Re(), mutator $z->Re(3)).
986
987           The class method "display_format" and the corresponding object
988           method "display_format", in addition to accepting just one
989           argument, now can also accept a parameter hash.  Recognized keys of
990           a parameter hash are "style", which corresponds to the old one
991           parameter case, and two new parameters: "format", which is a
992           printf()-style format string (defaults usually to "%.15g", you can
993           revert to the default by setting the format string to "undef") used
994           for both parts of a complex number, and "polar_pretty_print"
995           (defaults to true), which controls whether an attempt is made to
996           try to recognize small multiples and rationals of pi (2pi, pi/2) at
997           the argument (angle) of a polar complex number.
998
999           The potentially disruptive change is that in list context both
1000           methods now return the parameter hash, instead of only the value of
1001           the "style" parameter.
1002
1003       Math::Trig
1004           A little bit of radial trigonometry (cylindrical and spherical),
1005           radial coordinate conversions, and the great circle distance were
1006           added.
1007
1008       Pod::Parser, Pod::InputObjects
1009           Pod::Parser is a base class for parsing and selecting sections of
1010           pod documentation from an input stream.  This module takes care of
1011           identifying pod paragraphs and commands in the input and hands off
1012           the parsed paragraphs and commands to user-defined methods which
1013           are free to interpret or translate them as they see fit.
1014
1015           Pod::InputObjects defines some input objects needed by Pod::Parser,
1016           and for advanced users of Pod::Parser that need more about a
1017           command besides its name and text.
1018
1019           As of release 5.6.0 of Perl, Pod::Parser is now the officially
1020           sanctioned "base parser code" recommended for use by all pod2xxx
1021           translators.  Pod::Text (pod2text) and Pod::Man (pod2man) have
1022           already been converted to use Pod::Parser and efforts to convert
1023           Pod::HTML (pod2html) are already underway.  For any questions or
1024           comments about pod parsing and translating issues and utilities,
1025           please use the pod-people@perl.org mailing list.
1026
1027           For further information, please see Pod::Parser and
1028           Pod::InputObjects.
1029
1030       Pod::Checker, podchecker
1031           This utility checks pod files for correct syntax, according to
1032           perlpod.  Obvious errors are flagged as such, while warnings are
1033           printed for mistakes that can be handled gracefully.  The checklist
1034           is not complete yet.  See Pod::Checker.
1035
1036       Pod::ParseUtils, Pod::Find
1037           These modules provide a set of gizmos that are useful mainly for
1038           pod translators.  Pod::Find traverses directory structures and
1039           returns found pod files, along with their canonical names (like
1040           "File::Spec::Unix").  Pod::ParseUtils contains Pod::List (useful
1041           for storing pod list information), Pod::Hyperlink (for parsing the
1042           contents of "L<>" sequences) and Pod::Cache (for caching
1043           information about pod files, e.g., link nodes).
1044
1045       Pod::Select, podselect
1046           Pod::Select is a subclass of Pod::Parser which provides a function
1047           named "podselect()" to filter out user-specified sections of raw
1048           pod documentation from an input stream. podselect is a script that
1049           provides access to Pod::Select from other scripts to be used as a
1050           filter.  See Pod::Select.
1051
1052       Pod::Usage, pod2usage
1053           Pod::Usage provides the function "pod2usage()" to print usage
1054           messages for a Perl script based on its embedded pod documentation.
1055           The pod2usage() function is generally useful to all script authors
1056           since it lets them write and maintain a single source (the pods)
1057           for documentation, thus removing the need to create and maintain
1058           redundant usage message text consisting of information already in
1059           the pods.
1060
1061           There is also a pod2usage script which can be used from other kinds
1062           of scripts to print usage messages from pods (even for non-Perl
1063           scripts with pods embedded in comments).
1064
1065           For details and examples, please see Pod::Usage.
1066
1067       Pod::Text and Pod::Man
1068           Pod::Text has been rewritten to use Pod::Parser.  While pod2text()
1069           is still available for backwards compatibility, the module now has
1070           a new preferred interface.  See Pod::Text for the details.  The new
1071           Pod::Text module is easily subclassed for tweaks to the output, and
1072           two such subclasses (Pod::Text::Termcap for man-page-style bold and
1073           underlining using termcap information, and Pod::Text::Color for
1074           markup with ANSI color sequences) are now standard.
1075
1076           pod2man has been turned into a module, Pod::Man, which also uses
1077           Pod::Parser.  In the process, several outstanding bugs related to
1078           quotes in section headers, quoting of code escapes, and nested
1079           lists have been fixed.  pod2man is now a wrapper script around this
1080           module.
1081
1082       SDBM_File
1083           An EXISTS method has been added to this module (and sdbm_exists()
1084           has been added to the underlying sdbm library), so one can now call
1085           exists on an SDBM_File tied hash and get the correct result, rather
1086           than a runtime error.
1087
1088           A bug that may have caused data loss when more than one disk block
1089           happens to be read from the database in a single FETCH() has been
1090           fixed.
1091
1092       Sys::Syslog
1093           Sys::Syslog now uses XSUBs to access facilities from syslog.h so it
1094           no longer requires syslog.ph to exist.
1095
1096       Sys::Hostname
1097           Sys::Hostname now uses XSUBs to call the C library's gethostname()
1098           or uname() if they exist.
1099
1100       Term::ANSIColor
1101           Term::ANSIColor is a very simple module to provide easy and
1102           readable access to the ANSI color and highlighting escape
1103           sequences, supported by most ANSI terminal emulators.  It is now
1104           included standard.
1105
1106       Time::Local
1107           The timelocal() and timegm() functions used to silently return
1108           bogus results when the date fell outside the machine's integer
1109           range.  They now consistently croak() if the date falls in an
1110           unsupported range.
1111
1112       Win32
1113           The error return value in list context has been changed for all
1114           functions that return a list of values.  Previously these functions
1115           returned a list with a single element "undef" if an error occurred.
1116           Now these functions return the empty list in these situations.
1117           This applies to the following functions:
1118
1119               Win32::FsType
1120               Win32::GetOSVersion
1121
1122           The remaining functions are unchanged and continue to return
1123           "undef" on error even in list context.
1124
1125           The Win32::SetLastError(ERROR) function has been added as a
1126           complement to the Win32::GetLastError() function.
1127
1128           The new Win32::GetFullPathName(FILENAME) returns the full absolute
1129           pathname for FILENAME in scalar context.  In list context it
1130           returns a two-element list containing the fully qualified directory
1131           name and the filename.  See Win32.
1132
1133       XSLoader
1134           The XSLoader extension is a simpler alternative to DynaLoader.  See
1135           XSLoader.
1136
1137       DBM Filters
1138           A new feature called "DBM Filters" has been added to all the DBM
1139           modules--DB_File, GDBM_File, NDBM_File, ODBM_File, and SDBM_File.
1140           DBM Filters add four new methods to each DBM module:
1141
1142               filter_store_key
1143               filter_store_value
1144               filter_fetch_key
1145               filter_fetch_value
1146
1147           These can be used to filter key-value pairs before the pairs are
1148           written to the database or just after they are read from the
1149           database.  See perldbmfilter for further information.
1150
1151   Pragmata
1152       "use attrs" is now obsolete, and is only provided for backward-
1153       compatibility.  It's been replaced by the "sub : attributes" syntax.
1154       See "Subroutine Attributes" in perlsub and attributes.
1155
1156       Lexical warnings pragma, "use warnings;", to control optional warnings.
1157       See perllexwarn.
1158
1159       "use filetest" to control the behaviour of filetests ("-r" "-w" ...).
1160       Currently only one subpragma implemented, "use filetest 'access';",
1161       that uses access(2) or equivalent to check permissions instead of using
1162       stat(2) as usual.  This matters in filesystems where there are ACLs
1163       (access control lists): the stat(2) might lie, but access(2) knows
1164       better.
1165
1166       The "open" pragma can be used to specify default disciplines for handle
1167       constructors (e.g. open()) and for qx//.  The two pseudo-disciplines
1168       ":raw" and ":crlf" are currently supported on DOS-derivative platforms
1169       (i.e. where binmode is not a no-op).  See also "binmode() can be used
1170       to set :crlf and :raw modes".
1171

Utility Changes

1173   dprofpp
1174       "dprofpp" is used to display profile data generated using
1175       "Devel::DProf".  See dprofpp.
1176
1177   find2perl
1178       The "find2perl" utility now uses the enhanced features of the
1179       File::Find module.  The -depth and -follow options are supported.  Pod
1180       documentation is also included in the script.
1181
1182   h2xs
1183       The "h2xs" tool can now work in conjunction with "C::Scan" (available
1184       from CPAN) to automatically parse real-life header files.  The "-M",
1185       "-a", "-k", and "-o" options are new.
1186
1187   perlcc
1188       "perlcc" now supports the C and Bytecode backends.  By default, it
1189       generates output from the simple C backend rather than the optimized C
1190       backend.
1191
1192       Support for non-Unix platforms has been improved.
1193
1194   perldoc
1195       "perldoc" has been reworked to avoid possible security holes.  It will
1196       not by default let itself be run as the superuser, but you may still
1197       use the -U switch to try to make it drop privileges first.
1198
1199   The Perl Debugger
1200       Many bug fixes and enhancements were added to perl5db.pl, the Perl
1201       debugger.  The help documentation was rearranged.  New commands include
1202       "< ?", "> ?", and "{ ?" to list out current actions, "man docpage" to
1203       run your doc viewer on some perl docset, and support for quoted
1204       options.  The help information was rearranged, and should be viewable
1205       once again if you're using less as your pager.  A serious security hole
1206       was plugged--you should immediately remove all older versions of the
1207       Perl debugger as installed in previous releases, all the way back to
1208       perl3, from your system to avoid being bitten by this.
1209

Improved Documentation

1211       Many of the platform-specific README files are now part of the perl
1212       installation.  See perl for the complete list.
1213
1214       perlapi.pod
1215           The official list of public Perl API functions.
1216
1217       perlboot.pod
1218           A tutorial for beginners on object-oriented Perl.
1219
1220       perlcompile.pod
1221           An introduction to using the Perl Compiler suite.
1222
1223       perldbmfilter.pod
1224           A howto document on using the DBM filter facility.
1225
1226       perldebug.pod
1227           All material unrelated to running the Perl debugger, plus all low-
1228           level guts-like details that risked crushing the casual user of the
1229           debugger, have been relocated from the old manpage to the next
1230           entry below.
1231
1232       perldebguts.pod
1233           This new manpage contains excessively low-level material not
1234           related to the Perl debugger, but slightly related to debugging
1235           Perl itself.  It also contains some arcane internal details of how
1236           the debugging process works that may only be of interest to
1237           developers of Perl debuggers.
1238
1239       perlfork.pod
1240           Notes on the fork() emulation currently available for the Windows
1241           platform.
1242
1243       perlfilter.pod
1244           An introduction to writing Perl source filters.
1245
1246       perlhack.pod
1247           Some guidelines for hacking the Perl source code.
1248
1249       perlintern.pod
1250           A list of internal functions in the Perl source code.  (List is
1251           currently empty.)
1252
1253       perllexwarn.pod
1254           Introduction and reference information about lexically scoped
1255           warning categories.
1256
1257       perlnumber.pod
1258           Detailed information about numbers as they are represented in Perl.
1259
1260       perlopentut.pod
1261           A tutorial on using open() effectively.
1262
1263       perlreftut.pod
1264           A tutorial that introduces the essentials of references.
1265
1266       perltootc.pod
1267           A tutorial on managing class data for object modules.
1268
1269       perltodo.pod
1270           Discussion of the most often wanted features that may someday be
1271           supported in Perl.
1272
1273       perlunicode.pod
1274           An introduction to Unicode support features in Perl.
1275

Performance enhancements

1277   Simple sort() using { $a <=> $b } and the like are optimized
1278       Many common sort() operations using a simple inlined block are now
1279       optimized for faster performance.
1280
1281   Optimized assignments to lexical variables
1282       Certain operations in the RHS of assignment statements have been
1283       optimized to directly set the lexical variable on the LHS, eliminating
1284       redundant copying overheads.
1285
1286   Faster subroutine calls
1287       Minor changes in how subroutine calls are handled internally provide
1288       marginal improvements in performance.
1289
1290   delete(), each(), values() and hash iteration are faster
1291       The hash values returned by delete(), each(), values() and hashes in a
1292       list context are the actual values in the hash, instead of copies.
1293       This results in significantly better performance, because it eliminates
1294       needless copying in most situations.
1295

Installation and Configuration Improvements

1297   -Dusethreads means something different
1298       The -Dusethreads flag now enables the experimental interpreter-based
1299       thread support by default.  To get the flavor of experimental threads
1300       that was in 5.005 instead, you need to run Configure with "-Dusethreads
1301       -Duse5005threads".
1302
1303       As of v5.6.0, interpreter-threads support is still lacking a way to
1304       create new threads from Perl (i.e., "use Thread;" will not work with
1305       interpreter threads).  "use Thread;" continues to be available when you
1306       specify the -Duse5005threads option to Configure, bugs and all.
1307
1308           NOTE: Support for threads continues to be an experimental feature.
1309           Interfaces and implementation are subject to sudden and drastic changes.
1310
1311   New Configure flags
1312       The following new flags may be enabled on the Configure command line by
1313       running Configure with "-Dflag".
1314
1315           usemultiplicity
1316           usethreads useithreads      (new interpreter threads: no Perl API yet)
1317           usethreads use5005threads   (threads as they were in 5.005)
1318
1319           use64bitint                 (equal to now deprecated 'use64bits')
1320           use64bitall
1321
1322           uselongdouble
1323           usemorebits
1324           uselargefiles
1325           usesocks                    (only SOCKS v5 supported)
1326
1327   Threadedness and 64-bitness now more daring
1328       The Configure options enabling the use of threads and the use of
1329       64-bitness are now more daring in the sense that they no more have an
1330       explicit list of operating systems of known threads/64-bit
1331       capabilities.  In other words: if your operating system has the
1332       necessary APIs and datatypes, you should be able just to go ahead and
1333       use them, for threads by Configure -Dusethreads, and for 64 bits either
1334       explicitly by Configure -Duse64bitint or implicitly if your system has
1335       64-bit wide datatypes.  See also "64-bit support".
1336
1337   Long Doubles
1338       Some platforms have "long doubles", floating point numbers of even
1339       larger range than ordinary "doubles".  To enable using long doubles for
1340       Perl's scalars, use -Duselongdouble.
1341
1342   -Dusemorebits
1343       You can enable both -Duse64bitint and -Duselongdouble with
1344       -Dusemorebits.  See also "64-bit support".
1345
1346   -Duselargefiles
1347       Some platforms support system APIs that are capable of handling large
1348       files (typically, files larger than two gigabytes).  Perl will try to
1349       use these APIs if you ask for -Duselargefiles.
1350
1351       See "Large file support" for more information.
1352
1353   installusrbinperl
1354       You can use "Configure -Uinstallusrbinperl" which causes installperl to
1355       skip installing perl also as /usr/bin/perl.  This is useful if you
1356       prefer not to modify /usr/bin for some reason or another but harmful
1357       because many scripts assume to find Perl in /usr/bin/perl.
1358
1359   SOCKS support
1360       You can use "Configure -Dusesocks" which causes Perl to probe for the
1361       SOCKS proxy protocol library (v5, not v4).  For more information on
1362       SOCKS, see:
1363
1364           http://www.socks.nec.com/
1365
1366   "-A" flag
1367       You can "post-edit" the Configure variables using the Configure "-A"
1368       switch.  The editing happens immediately after the platform specific
1369       hints files have been processed but before the actual configuration
1370       process starts.  Run "Configure -h" to find out the full "-A" syntax.
1371
1372   Enhanced Installation Directories
1373       The installation structure has been enriched to improve the support for
1374       maintaining multiple versions of perl, to provide locations for vendor-
1375       supplied modules, scripts, and manpages, and to ease maintenance of
1376       locally-added modules, scripts, and manpages.  See the section on
1377       Installation Directories in the INSTALL file for complete details.  For
1378       most users building and installing from source, the defaults should be
1379       fine.
1380
1381       If you previously used "Configure -Dsitelib" or "-Dsitearch" to set
1382       special values for library directories, you might wish to consider
1383       using the new "-Dsiteprefix" setting instead.  Also, if you wish to re-
1384       use a config.sh file from an earlier version of perl, you should be
1385       sure to check that Configure makes sensible choices for the new
1386       directories.  See INSTALL for complete details.
1387

Platform specific changes

1389   Supported platforms
1390       •   The Mach CThreads (NEXTSTEP, OPENSTEP) are now supported by the
1391           Thread extension.
1392
1393       •   GNU/Hurd is now supported.
1394
1395       •   Rhapsody/Darwin is now supported.
1396
1397       •   EPOC is now supported (on Psion 5).
1398
1399       •   The cygwin port (formerly cygwin32) has been greatly improved.
1400
1401   DOS
1402       •   Perl now works with djgpp 2.02 (and 2.03 alpha).
1403
1404       •   Environment variable names are not converted to uppercase any more.
1405
1406       •   Incorrect exit codes from backticks have been fixed.
1407
1408       •   This port continues to use its own builtin globbing (not
1409           File::Glob).
1410
1411   OS390 (OpenEdition MVS)
1412       Support for this EBCDIC platform has not been renewed in this release.
1413       There are difficulties in reconciling Perl's standardization on UTF-8
1414       as its internal representation for characters with the EBCDIC character
1415       set, because the two are incompatible.
1416
1417       It is unclear whether future versions will renew support for this
1418       platform, but the possibility exists.
1419
1420   VMS
1421       Numerous revisions and extensions to configuration, build, testing, and
1422       installation process to accommodate core changes and VMS-specific
1423       options.
1424
1425       Expand %ENV-handling code to allow runtime mapping to logical names,
1426       CLI symbols, and CRTL environ array.
1427
1428       Extension of subprocess invocation code to accept filespecs as command
1429       "verbs".
1430
1431       Add to Perl command line processing the ability to use default file
1432       types and to recognize Unix-style "2>&1".
1433
1434       Expansion of File::Spec::VMS routines, and integration into
1435       ExtUtils::MM_VMS.
1436
1437       Extension of ExtUtils::MM_VMS to handle complex extensions more
1438       flexibly.
1439
1440       Barewords at start of Unix-syntax paths may be treated as text rather
1441       than only as logical names.
1442
1443       Optional secure translation of several logical names used internally by
1444       Perl.
1445
1446       Miscellaneous bugfixing and porting of new core code to VMS.
1447
1448       Thanks are gladly extended to the many people who have contributed VMS
1449       patches, testing, and ideas.
1450
1451   Win32
1452       Perl can now emulate fork() internally, using multiple interpreters
1453       running in different concurrent threads.  This support must be enabled
1454       at build time.  See perlfork for detailed information.
1455
1456       When given a pathname that consists only of a drivename, such as "A:",
1457       opendir() and stat() now use the current working directory for the
1458       drive rather than the drive root.
1459
1460       The builtin XSUB functions in the Win32:: namespace are documented.
1461       See Win32.
1462
1463       $^X now contains the full path name of the running executable.
1464
1465       A Win32::GetLongPathName() function is provided to complement
1466       Win32::GetFullPathName() and Win32::GetShortPathName().  See Win32.
1467
1468       POSIX::uname() is supported.
1469
1470       system(1,...) now returns true process IDs rather than process handles.
1471       kill() accepts any real process id, rather than strictly return values
1472       from system(1,...).
1473
1474       For better compatibility with Unix, "kill(0, $pid)" can now be used to
1475       test whether a process exists.
1476
1477       The "Shell" module is supported.
1478
1479       Better support for building Perl under command.com in Windows 95 has
1480       been added.
1481
1482       Scripts are read in binary mode by default to allow ByteLoader (and the
1483       filter mechanism in general) to work properly.  For compatibility, the
1484       DATA filehandle will be set to text mode if a carriage return is
1485       detected at the end of the line containing the __END__ or __DATA__
1486       token; if not, the DATA filehandle will be left open in binary mode.
1487       Earlier versions always opened the DATA filehandle in text mode.
1488
1489       The glob() operator is implemented via the "File::Glob" extension,
1490       which supports glob syntax of the C shell.  This increases the
1491       flexibility of the glob() operator, but there may be compatibility
1492       issues for programs that relied on the older globbing syntax.  If you
1493       want to preserve compatibility with the older syntax, you might want to
1494       run perl with "-MFile::DosGlob".  For details and compatibility
1495       information, see File::Glob.
1496

Significant bug fixes

1498   <HANDLE> on empty files
1499       With $/ set to "undef", "slurping" an empty file returns a string of
1500       zero length (instead of "undef", as it used to) the first time the
1501       HANDLE is read after $/ is set to "undef".  Further reads yield
1502       "undef".
1503
1504       This means that the following will append "foo" to an empty file (it
1505       used to do nothing):
1506
1507           perl -0777 -pi -e 's/^/foo/' empty_file
1508
1509       The behaviour of:
1510
1511           perl -pi -e 's/^/foo/' empty_file
1512
1513       is unchanged (it continues to leave the file empty).
1514
1515   "eval '...'" improvements
1516       Line numbers (as reflected by caller() and most diagnostics) within
1517       "eval '...'" were often incorrect where here documents were involved.
1518       This has been corrected.
1519
1520       Lexical lookups for variables appearing in "eval '...'" within
1521       functions that were themselves called within an "eval '...'" were
1522       searching the wrong place for lexicals.  The lexical search now
1523       correctly ends at the subroutine's block boundary.
1524
1525       The use of "return" within "eval {...}" caused $@ not to be reset
1526       correctly when no exception occurred within the eval.  This has been
1527       fixed.
1528
1529       Parsing of here documents used to be flawed when they appeared as the
1530       replacement expression in "eval 's/.../.../e'".  This has been fixed.
1531
1532   All compilation errors are true errors
1533       Some "errors" encountered at compile time were by necessity generated
1534       as warnings followed by eventual termination of the program.  This
1535       enabled more such errors to be reported in a single run, rather than
1536       causing a hard stop at the first error that was encountered.
1537
1538       The mechanism for reporting such errors has been reimplemented to queue
1539       compile-time errors and report them at the end of the compilation as
1540       true errors rather than as warnings.  This fixes cases where error
1541       messages leaked through in the form of warnings when code was compiled
1542       at run time using "eval STRING", and also allows such errors to be
1543       reliably trapped using "eval "..."".
1544
1545   Implicitly closed filehandles are safer
1546       Sometimes implicitly closed filehandles (as when they are localized,
1547       and Perl automatically closes them on exiting the scope) could
1548       inadvertently set $? or $!.  This has been corrected.
1549
1550   Behavior of list slices is more consistent
1551       When taking a slice of a literal list (as opposed to a slice of an
1552       array or hash), Perl used to return an empty list if the result
1553       happened to be composed of all undef values.
1554
1555       The new behavior is to produce an empty list if (and only if) the
1556       original list was empty.  Consider the following example:
1557
1558           @a = (1,undef,undef,2)[2,1,2];
1559
1560       The old behavior would have resulted in @a having no elements.  The new
1561       behavior ensures it has three undefined elements.
1562
1563       Note in particular that the behavior of slices of the following cases
1564       remains unchanged:
1565
1566           @a = ()[1,2];
1567           @a = (getpwent)[7,0];
1568           @a = (anything_returning_empty_list())[2,1,2];
1569           @a = @b[2,1,2];
1570           @a = @c{'a','b','c'};
1571
1572       See perldata.
1573
1574   "(\$)" prototype and $foo{a}
1575       A scalar reference prototype now correctly allows a hash or array
1576       element in that slot.
1577
1578   "goto &sub" and AUTOLOAD
1579       The "goto &sub" construct works correctly when &sub happens to be
1580       autoloaded.
1581
1582   "-bareword" allowed under "use integer"
1583       The autoquoting of barewords preceded by "-" did not work in prior
1584       versions when the "integer" pragma was enabled.  This has been fixed.
1585
1586   Failures in DESTROY()
1587       When code in a destructor threw an exception, it went unnoticed in
1588       earlier versions of Perl, unless someone happened to be looking in $@
1589       just after the point the destructor happened to run.  Such failures are
1590       now visible as warnings when warnings are enabled.
1591
1592   Locale bugs fixed
1593       printf() and sprintf() previously reset the numeric locale back to the
1594       default "C" locale.  This has been fixed.
1595
1596       Numbers formatted according to the local numeric locale (such as using
1597       a decimal comma instead of a decimal dot) caused "isn't numeric"
1598       warnings, even while the operations accessing those numbers produced
1599       correct results.  These warnings have been discontinued.
1600
1601   Memory leaks
1602       The "eval 'return sub {...}'" construct could sometimes leak memory.
1603       This has been fixed.
1604
1605       Operations that aren't filehandle constructors used to leak memory when
1606       used on invalid filehandles.  This has been fixed.
1607
1608       Constructs that modified @_ could fail to deallocate values in @_ and
1609       thus leak memory.  This has been corrected.
1610
1611   Spurious subroutine stubs after failed subroutine calls
1612       Perl could sometimes create empty subroutine stubs when a subroutine
1613       was not found in the package.  Such cases stopped later method lookups
1614       from progressing into base packages.  This has been corrected.
1615
1616   Taint failures under "-U"
1617       When running in unsafe mode, taint violations could sometimes cause
1618       silent failures.  This has been fixed.
1619
1620   END blocks and the "-c" switch
1621       Prior versions used to run BEGIN and END blocks when Perl was run in
1622       compile-only mode.  Since this is typically not the expected behavior,
1623       END blocks are not executed anymore when the "-c" switch is used, or if
1624       compilation fails.
1625
1626       See "Support for CHECK blocks" for how to run things when the compile
1627       phase ends.
1628
1629   Potential to leak DATA filehandles
1630       Using the "__DATA__" token creates an implicit filehandle to the file
1631       that contains the token.  It is the program's responsibility to close
1632       it when it is done reading from it.
1633
1634       This caveat is now better explained in the documentation.  See
1635       perldata.
1636

New or Changed Diagnostics

1638       "%s" variable %s masks earlier declaration in same %s
1639           (W misc) A "my" or "our" variable has been redeclared in the
1640           current scope or statement, effectively eliminating all access to
1641           the previous instance.  This is almost always a typographical
1642           error.  Note that the earlier variable will still exist until the
1643           end of the scope or until all closure referents to it are
1644           destroyed.
1645
1646       "my sub" not yet implemented
1647           (F) Lexically scoped subroutines are not yet implemented.  Don't
1648           try that yet.
1649
1650       "our" variable %s redeclared
1651           (W misc) You seem to have already declared the same global once
1652           before in the current lexical scope.
1653
1654       '!' allowed only after types %s
1655           (F) The '!' is allowed in pack() and unpack() only after certain
1656           types.  See "pack" in perlfunc.
1657
1658       / cannot take a count
1659           (F) You had an unpack template indicating a counted-length string,
1660           but you have also specified an explicit size for the string.  See
1661           "pack" in perlfunc.
1662
1663       / must be followed by a, A or Z
1664           (F) You had an unpack template indicating a counted-length string,
1665           which must be followed by one of the letters a, A or Z to indicate
1666           what sort of string is to be unpacked.  See "pack" in perlfunc.
1667
1668       / must be followed by a*, A* or Z*
1669           (F) You had a pack template indicating a counted-length string,
1670           Currently the only things that can have their length counted are
1671           a*, A* or Z*.  See "pack" in perlfunc.
1672
1673       / must follow a numeric type
1674           (F) You had an unpack template that contained a '#', but this did
1675           not follow some numeric unpack specification.  See "pack" in
1676           perlfunc.
1677
1678       /%s/: Unrecognized escape \\%c passed through
1679           (W regexp) You used a backslash-character combination which is not
1680           recognized by Perl.  This combination appears in an interpolated
1681           variable or a "'"-delimited regular expression.  The character was
1682           understood literally.
1683
1684       /%s/: Unrecognized escape \\%c in character class passed through
1685           (W regexp) You used a backslash-character combination which is not
1686           recognized by Perl inside character classes.  The character was
1687           understood literally.
1688
1689       /%s/ should probably be written as "%s"
1690           (W syntax) You have used a pattern where Perl expected to find a
1691           string, as in the first argument to "join".  Perl will treat the
1692           true or false result of matching the pattern against $_ as the
1693           string, which is probably not what you had in mind.
1694
1695       %s() called too early to check prototype
1696           (W prototype) You've called a function that has a prototype before
1697           the parser saw a definition or declaration for it, and Perl could
1698           not check that the call conforms to the prototype.  You need to
1699           either add an early prototype declaration for the subroutine in
1700           question, or move the subroutine definition ahead of the call to
1701           get proper prototype checking.  Alternatively, if you are certain
1702           that you're calling the function correctly, you may put an
1703           ampersand before the name to avoid the warning.  See perlsub.
1704
1705       %s argument is not a HASH or ARRAY element
1706           (F) The argument to exists() must be a hash or array element, such
1707           as:
1708
1709               $foo{$bar}
1710               $ref->{"susie"}[12]
1711
1712       %s argument is not a HASH or ARRAY element or slice
1713           (F) The argument to delete() must be either a hash or array
1714           element, such as:
1715
1716               $foo{$bar}
1717               $ref->{"susie"}[12]
1718
1719           or a hash or array slice, such as:
1720
1721               @foo[$bar, $baz, $xyzzy]
1722               @{$ref->[12]}{"susie", "queue"}
1723
1724       %s argument is not a subroutine name
1725           (F) The argument to exists() for "exists &sub" must be a subroutine
1726           name, and not a subroutine call.  "exists &sub()" will generate
1727           this error.
1728
1729       %s package attribute may clash with future reserved word: %s
1730           (W reserved) A lowercase attribute name was used that had a
1731           package-specific handler.  That name might have a meaning to Perl
1732           itself some day, even though it doesn't yet.  Perhaps you should
1733           use a mixed-case attribute name, instead.  See attributes.
1734
1735       (in cleanup) %s
1736           (W misc) This prefix usually indicates that a DESTROY() method
1737           raised the indicated exception.  Since destructors are usually
1738           called by the system at arbitrary points during execution, and
1739           often a vast number of times, the warning is issued only once for
1740           any number of failures that would otherwise result in the same
1741           message being repeated.
1742
1743           Failure of user callbacks dispatched using the "G_KEEPERR" flag
1744           could also result in this warning.  See "G_KEEPERR" in perlcall.
1745
1746       <> should be quotes
1747           (F) You wrote "require <file>" when you should have written
1748           "require 'file'".
1749
1750       Attempt to join self
1751           (F) You tried to join a thread from within itself, which is an
1752           impossible task.  You may be joining the wrong thread, or you may
1753           need to move the join() to some other thread.
1754
1755       Bad evalled substitution pattern
1756           (F) You've used the /e switch to evaluate the replacement for a
1757           substitution, but perl found a syntax error in the code to
1758           evaluate, most likely an unexpected right brace '}'.
1759
1760       Bad realloc() ignored
1761           (S) An internal routine called realloc() on something that had
1762           never been malloc()ed in the first place. Mandatory, but can be
1763           disabled by setting environment variable "PERL_BADFREE" to 1.
1764
1765       Bareword found in conditional
1766           (W bareword) The compiler found a bareword where it expected a
1767           conditional, which often indicates that an || or && was parsed as
1768           part of the last argument of the previous construct, for example:
1769
1770               open FOO || die;
1771
1772           It may also indicate a misspelled constant that has been
1773           interpreted as a bareword:
1774
1775               use constant TYPO => 1;
1776               if (TYOP) { print "foo" }
1777
1778           The "strict" pragma is useful in avoiding such errors.
1779
1780       Binary number > 0b11111111111111111111111111111111 non-portable
1781           (W portable) The binary number you specified is larger than 2**32-1
1782           (4294967295) and therefore non-portable between systems.  See
1783           perlport for more on portability concerns.
1784
1785       Bit vector size > 32 non-portable
1786           (W portable) Using bit vector sizes larger than 32 is non-portable.
1787
1788       Buffer overflow in prime_env_iter: %s
1789           (W internal) A warning peculiar to VMS.  While Perl was preparing
1790           to iterate over %ENV, it encountered a logical name or symbol
1791           definition which was too long, so it was truncated to the string
1792           shown.
1793
1794       Can't check filesystem of script "%s"
1795           (P) For some reason you can't check the filesystem of the script
1796           for nosuid.
1797
1798       Can't declare class for non-scalar %s in "%s"
1799           (S) Currently, only scalar variables can declared with a specific
1800           class qualifier in a "my" or "our" declaration.  The semantics may
1801           be extended for other types of variables in future.
1802
1803       Can't declare %s in "%s"
1804           (F) Only scalar, array, and hash variables may be declared as "my"
1805           or "our" variables.  They must have ordinary identifiers as names.
1806
1807       Can't ignore signal CHLD, forcing to default
1808           (W signal) Perl has detected that it is being run with the SIGCHLD
1809           signal (sometimes known as SIGCLD) disabled.  Since disabling this
1810           signal will interfere with proper determination of exit status of
1811           child processes, Perl has reset the signal to its default value.
1812           This situation typically indicates that the parent program under
1813           which Perl may be running (e.g., cron) is being very careless.
1814
1815       Can't modify non-lvalue subroutine call
1816           (F) Subroutines meant to be used in lvalue context should be
1817           declared as such, see "Lvalue subroutines" in perlsub.
1818
1819       Can't read CRTL environ
1820           (S) A warning peculiar to VMS.  Perl tried to read an element of
1821           %ENV from the CRTL's internal environment array and discovered the
1822           array was missing.  You need to figure out where your CRTL
1823           misplaced its environ or define PERL_ENV_TABLES (see perlvms) so
1824           that environ is not searched.
1825
1826       Can't remove %s: %s, skipping file
1827           (S) You requested an inplace edit without creating a backup file.
1828           Perl was unable to remove the original file to replace it with the
1829           modified file.  The file was left unmodified.
1830
1831       Can't return %s from lvalue subroutine
1832           (F) Perl detected an attempt to return illegal lvalues (such as
1833           temporary or readonly values) from a subroutine used as an lvalue.
1834           This is not allowed.
1835
1836       Can't weaken a nonreference
1837           (F) You attempted to weaken something that was not a reference.
1838           Only references can be weakened.
1839
1840       Character class [:%s:] unknown
1841           (F) The class in the character class [: :] syntax is unknown.  See
1842           perlre.
1843
1844       Character class syntax [%s] belongs inside character classes
1845           (W unsafe) The character class constructs [: :], [= =], and [. .]
1846           go inside character classes, the [] are part of the construct, for
1847           example: /[012[:alpha:]345]/.  Note that [= =] and [. .]  are not
1848           currently implemented; they are simply placeholders for future
1849           extensions.
1850
1851       Constant is not %s reference
1852           (F) A constant value (perhaps declared using the "use constant"
1853           pragma) is being dereferenced, but it amounts to the wrong type of
1854           reference.  The message indicates the type of reference that was
1855           expected. This usually indicates a syntax error in dereferencing
1856           the constant value.  See "Constant Functions" in perlsub and
1857           constant.
1858
1859       constant(%s): %s
1860           (F) The parser found inconsistencies either while attempting to
1861           define an overloaded constant, or when trying to find the character
1862           name specified in the "\N{...}" escape.  Perhaps you forgot to load
1863           the corresponding "overload" or "charnames" pragma?  See charnames
1864           and overload.
1865
1866       CORE::%s is not a keyword
1867           (F) The CORE:: namespace is reserved for Perl keywords.
1868
1869       defined(@array) is deprecated
1870           (D) defined() is not usually useful on arrays because it checks for
1871           an undefined scalar value.  If you want to see if the array is
1872           empty, just use "if (@array) { # not empty }" for example.
1873
1874       defined(%hash) is deprecated
1875           (D) defined() is not usually useful on hashes because it checks for
1876           an undefined scalar value.  If you want to see if the hash is
1877           empty, just use "if (%hash) { # not empty }" for example.
1878
1879       Did not produce a valid header
1880           See Server error.
1881
1882       (Did you mean "local" instead of "our"?)
1883           (W misc) Remember that "our" does not localize the declared global
1884           variable.  You have declared it again in the same lexical scope,
1885           which seems superfluous.
1886
1887       Document contains no data
1888           See Server error.
1889
1890       entering effective %s failed
1891           (F) While under the "use filetest" pragma, switching the real and
1892           effective uids or gids failed.
1893
1894       false [] range "%s" in regexp
1895           (W regexp) A character class range must start and end at a literal
1896           character, not another character class like "\d" or "[:alpha:]".
1897           The "-" in your false range is interpreted as a literal "-".
1898           Consider quoting the "-",  "\-".  See perlre.
1899
1900       Filehandle %s opened only for output
1901           (W io) You tried to read from a filehandle opened only for writing.
1902           If you intended it to be a read/write filehandle, you needed to
1903           open it with "+<" or "+>" or "+>>" instead of with "<" or nothing.
1904           If you intended only to read from the file, use "<".  See "open" in
1905           perlfunc.
1906
1907       flock() on closed filehandle %s
1908           (W closed) The filehandle you're attempting to flock() got itself
1909           closed some time before now.  Check your logic flow.  flock()
1910           operates on filehandles.  Are you attempting to call flock() on a
1911           dirhandle by the same name?
1912
1913       Global symbol "%s" requires explicit package name
1914           (F) You've said "use strict vars", which indicates that all
1915           variables must either be lexically scoped (using "my"), declared
1916           beforehand using "our", or explicitly qualified to say which
1917           package the global variable is in (using "::").
1918
1919       Hexadecimal number > 0xffffffff non-portable
1920           (W portable) The hexadecimal number you specified is larger than
1921           2**32-1 (4294967295) and therefore non-portable between systems.
1922           See perlport for more on portability concerns.
1923
1924       Ill-formed CRTL environ value "%s"
1925           (W internal) A warning peculiar to VMS.  Perl tried to read the
1926           CRTL's internal environ array, and encountered an element without
1927           the "=" delimiter used to separate keys from values.  The element
1928           is ignored.
1929
1930       Ill-formed message in prime_env_iter: |%s|
1931           (W internal) A warning peculiar to VMS.  Perl tried to read a
1932           logical name or CLI symbol definition when preparing to iterate
1933           over %ENV, and didn't see the expected delimiter between key and
1934           value, so the line was ignored.
1935
1936       Illegal binary digit %s
1937           (F) You used a digit other than 0 or 1 in a binary number.
1938
1939       Illegal binary digit %s ignored
1940           (W digit) You may have tried to use a digit other than 0 or 1 in a
1941           binary number.  Interpretation of the binary number stopped before
1942           the offending digit.
1943
1944       Illegal number of bits in vec
1945           (F) The number of bits in vec() (the third argument) must be a
1946           power of two from 1 to 32 (or 64, if your platform supports that).
1947
1948       Integer overflow in %s number
1949           (W overflow) The hexadecimal, octal or binary number you have
1950           specified either as a literal or as an argument to hex() or oct()
1951           is too big for your architecture, and has been converted to a
1952           floating point number.  On a 32-bit architecture the largest
1953           hexadecimal, octal or binary number representable without overflow
1954           is 0xFFFFFFFF, 037777777777, or 0b11111111111111111111111111111111
1955           respectively.  Note that Perl transparently promotes all numbers to
1956           a floating point representation internally--subject to loss of
1957           precision errors in subsequent operations.
1958
1959       Invalid %s attribute: %s
1960           The indicated attribute for a subroutine or variable was not
1961           recognized by Perl or by a user-supplied handler.  See attributes.
1962
1963       Invalid %s attributes: %s
1964           The indicated attributes for a subroutine or variable were not
1965           recognized by Perl or by a user-supplied handler.  See attributes.
1966
1967       invalid [] range "%s" in regexp
1968           The offending range is now explicitly displayed.
1969
1970       Invalid separator character %s in attribute list
1971           (F) Something other than a colon or whitespace was seen between the
1972           elements of an attribute list.  If the previous attribute had a
1973           parenthesised parameter list, perhaps that list was terminated too
1974           soon.  See attributes.
1975
1976       Invalid separator character %s in subroutine attribute list
1977           (F) Something other than a colon or whitespace was seen between the
1978           elements of a subroutine attribute list.  If the previous attribute
1979           had a parenthesised parameter list, perhaps that list was
1980           terminated too soon.
1981
1982       leaving effective %s failed
1983           (F) While under the "use filetest" pragma, switching the real and
1984           effective uids or gids failed.
1985
1986       Lvalue subs returning %s not implemented yet
1987           (F) Due to limitations in the current implementation, array and
1988           hash values cannot be returned in subroutines used in lvalue
1989           context.  See "Lvalue subroutines" in perlsub.
1990
1991       Method %s not permitted
1992           See Server error.
1993
1994       Missing %sbrace%s on \N{}
1995           (F) Wrong syntax of character name literal "\N{charname}" within
1996           double-quotish context.
1997
1998       Missing command in piped open
1999           (W pipe) You used the "open(FH, "| command")" or "open(FH, "command
2000           |")" construction, but the command was missing or blank.
2001
2002       Missing name in "my sub"
2003           (F) The reserved syntax for lexically scoped subroutines requires
2004           that they have a name with which they can be found.
2005
2006       No %s specified for -%c
2007           (F) The indicated command line switch needs a mandatory argument,
2008           but you haven't specified one.
2009
2010       No package name allowed for variable %s in "our"
2011           (F) Fully qualified variable names are not allowed in "our"
2012           declarations, because that doesn't make much sense under existing
2013           semantics.  Such syntax is reserved for future extensions.
2014
2015       No space allowed after -%c
2016           (F) The argument to the indicated command line switch must follow
2017           immediately after the switch, without intervening spaces.
2018
2019       no UTC offset information; assuming local time is UTC
2020           (S) A warning peculiar to VMS.  Perl was unable to find the local
2021           timezone offset, so it's assuming that local system time is
2022           equivalent to UTC.  If it's not, define the logical name
2023           SYS$TIMEZONE_DIFFERENTIAL to translate to the number of seconds
2024           which need to be added to UTC to get local time.
2025
2026       Octal number > 037777777777 non-portable
2027           (W portable) The octal number you specified is larger than 2**32-1
2028           (4294967295) and therefore non-portable between systems.  See
2029           perlport for more on portability concerns.
2030
2031           See also perlport for writing portable code.
2032
2033       panic: del_backref
2034           (P) Failed an internal consistency check while trying to reset a
2035           weak reference.
2036
2037       panic: kid popen errno read
2038           (F) forked child returned an incomprehensible message about its
2039           errno.
2040
2041       panic: magic_killbackrefs
2042           (P) Failed an internal consistency check while trying to reset all
2043           weak references to an object.
2044
2045       Parentheses missing around "%s" list
2046           (W parenthesis) You said something like
2047
2048               my $foo, $bar = @_;
2049
2050           when you meant
2051
2052               my ($foo, $bar) = @_;
2053
2054           Remember that "my", "our", and "local" bind tighter than comma.
2055
2056       Possible unintended interpolation of %s in string
2057           (W ambiguous) It used to be that Perl would try to guess whether
2058           you wanted an array interpolated or a literal @.  It no longer does
2059           this; arrays are now always interpolated into strings.  This means
2060           that if you try something like:
2061
2062                   print "fred@example.com";
2063
2064           and the array @example doesn't exist, Perl is going to print
2065           "fred.com", which is probably not what you wanted.  To get a
2066           literal "@" sign in a string, put a backslash before it, just as
2067           you would to get a literal "$" sign.
2068
2069       Possible Y2K bug: %s
2070           (W y2k) You are concatenating the number 19 with another number,
2071           which could be a potential Year 2000 problem.
2072
2073       pragma "attrs" is deprecated, use "sub NAME : ATTRS" instead
2074           (W deprecated) You have written something like this:
2075
2076               sub doit
2077               {
2078                   use attrs qw(locked);
2079               }
2080
2081           You should use the new declaration syntax instead.
2082
2083               sub doit : locked
2084               {
2085                   ...
2086
2087           The "use attrs" pragma is now obsolete, and is only provided for
2088           backward-compatibility. See "Subroutine Attributes" in perlsub.
2089
2090       Premature end of script headers
2091           See Server error.
2092
2093       Repeat count in pack overflows
2094           (F) You can't specify a repeat count so large that it overflows
2095           your signed integers.  See "pack" in perlfunc.
2096
2097       Repeat count in unpack overflows
2098           (F) You can't specify a repeat count so large that it overflows
2099           your signed integers.  See "unpack" in perlfunc.
2100
2101       realloc() of freed memory ignored
2102           (S) An internal routine called realloc() on something that had
2103           already been freed.
2104
2105       Reference is already weak
2106           (W misc) You have attempted to weaken a reference that is already
2107           weak.  Doing so has no effect.
2108
2109       setpgrp can't take arguments
2110           (F) Your system has the setpgrp() from BSD 4.2, which takes no
2111           arguments, unlike POSIX setpgid(), which takes a process ID and
2112           process group ID.
2113
2114       Strange *+?{} on zero-length expression
2115           (W regexp) You applied a regular expression quantifier in a place
2116           where it makes no sense, such as on a zero-width assertion.  Try
2117           putting the quantifier inside the assertion instead.  For example,
2118           the way to match "abc" provided that it is followed by three
2119           repetitions of "xyz" is "/abc(?=(?:xyz){3})/", not
2120           "/abc(?=xyz){3}/".
2121
2122       switching effective %s is not implemented
2123           (F) While under the "use filetest" pragma, we cannot switch the
2124           real and effective uids or gids.
2125
2126       This Perl can't reset CRTL environ elements (%s)
2127       This Perl can't set CRTL environ elements (%s=%s)
2128           (W internal) Warnings peculiar to VMS.  You tried to change or
2129           delete an element of the CRTL's internal environ array, but your
2130           copy of Perl wasn't built with a CRTL that contained the setenv()
2131           function.  You'll need to rebuild Perl with a CRTL that does, or
2132           redefine PERL_ENV_TABLES (see perlvms) so that the environ array
2133           isn't the target of the change to %ENV which produced the warning.
2134
2135       Too late to run %s block
2136           (W void) A CHECK or INIT block is being defined during run time
2137           proper, when the opportunity to run them has already passed.
2138           Perhaps you are loading a file with "require" or "do" when you
2139           should be using "use" instead.  Or perhaps you should put the
2140           "require" or "do" inside a BEGIN block.
2141
2142       Unknown open() mode '%s'
2143           (F) The second argument of 3-argument open() is not among the list
2144           of valid modes: "<", ">", ">>", "+<", "+>", "+>>", "-|", "|-".
2145
2146       Unknown process %x sent message to prime_env_iter: %s
2147           (P) An error peculiar to VMS.  Perl was reading values for %ENV
2148           before iterating over it, and someone else stuck a message in the
2149           stream of data Perl expected.  Someone's very confused, or perhaps
2150           trying to subvert Perl's population of %ENV for nefarious purposes.
2151
2152       Unrecognized escape \\%c passed through
2153           (W misc) You used a backslash-character combination which is not
2154           recognized by Perl.  The character was understood literally.
2155
2156       Unterminated attribute parameter in attribute list
2157           (F) The lexer saw an opening (left) parenthesis character while
2158           parsing an attribute list, but the matching closing (right)
2159           parenthesis character was not found.  You may need to add (or
2160           remove) a backslash character to get your parentheses to balance.
2161           See attributes.
2162
2163       Unterminated attribute list
2164           (F) The lexer found something other than a simple identifier at the
2165           start of an attribute, and it wasn't a semicolon or the start of a
2166           block.  Perhaps you terminated the parameter list of the previous
2167           attribute too soon.  See attributes.
2168
2169       Unterminated attribute parameter in subroutine attribute list
2170           (F) The lexer saw an opening (left) parenthesis character while
2171           parsing a subroutine attribute list, but the matching closing
2172           (right) parenthesis character was not found.  You may need to add
2173           (or remove) a backslash character to get your parentheses to
2174           balance.
2175
2176       Unterminated subroutine attribute list
2177           (F) The lexer found something other than a simple identifier at the
2178           start of a subroutine attribute, and it wasn't a semicolon or the
2179           start of a block.  Perhaps you terminated the parameter list of the
2180           previous attribute too soon.
2181
2182       Value of CLI symbol "%s" too long
2183           (W misc) A warning peculiar to VMS.  Perl tried to read the value
2184           of an %ENV element from a CLI symbol table, and found a resultant
2185           string longer than 1024 characters.  The return value has been
2186           truncated to 1024 characters.
2187
2188       Version number must be a constant number
2189           (P) The attempt to translate a "use Module n.n LIST" statement into
2190           its equivalent "BEGIN" block found an internal inconsistency with
2191           the version number.
2192

New tests

2194       lib/attrs
2195           Compatibility tests for "sub : attrs" vs the older "use attrs".
2196
2197       lib/env
2198           Tests for new environment scalar capability (e.g., "use Env
2199           qw($BAR);").
2200
2201       lib/env-array
2202           Tests for new environment array capability (e.g., "use Env
2203           qw(@PATH);").
2204
2205       lib/io_const
2206           IO constants (SEEK_*, _IO*).
2207
2208       lib/io_dir
2209           Directory-related IO methods (new, read, close, rewind, tied
2210           delete).
2211
2212       lib/io_multihomed
2213           INET sockets with multi-homed hosts.
2214
2215       lib/io_poll
2216           IO poll().
2217
2218       lib/io_unix
2219           UNIX sockets.
2220
2221       op/attrs
2222           Regression tests for "my ($x,@y,%z) : attrs" and <sub : attrs>.
2223
2224       op/filetest
2225           File test operators.
2226
2227       op/lex_assign
2228           Verify operations that access pad objects (lexicals and
2229           temporaries).
2230
2231       op/exists_sub
2232           Verify "exists &sub" operations.
2233

Incompatible Changes

2235   Perl Source Incompatibilities
2236       Beware that any new warnings that have been added or old ones that have
2237       been enhanced are not considered incompatible changes.
2238
2239       Since all new warnings must be explicitly requested via the "-w" switch
2240       or the "warnings" pragma, it is ultimately the programmer's
2241       responsibility to ensure that warnings are enabled judiciously.
2242
2243       CHECK is a new keyword
2244           All subroutine definitions named CHECK are now special.  See
2245           "/"Support for CHECK blocks"" for more information.
2246
2247       Treatment of list slices of undef has changed
2248           There is a potential incompatibility in the behavior of list slices
2249           that are comprised entirely of undefined values.  See "Behavior of
2250           list slices is more consistent".
2251
2252       Format of $English::PERL_VERSION is different
2253           The English module now sets $PERL_VERSION to $^V (a string value)
2254           rather than $] (a numeric value).  This is a potential
2255           incompatibility.  Send us a report via perlbug if you are affected
2256           by this.
2257
2258           See "Improved Perl version numbering system" for the reasons for
2259           this change.
2260
2261       Literals of the form 1.2.3 parse differently
2262           Previously, numeric literals with more than one dot in them were
2263           interpreted as a floating point number concatenated with one or
2264           more numbers.  Such "numbers" are now parsed as strings composed of
2265           the specified ordinals.
2266
2267           For example, "print 97.98.99" used to output 97.9899 in earlier
2268           versions, but now prints "abc".
2269
2270           See "Support for strings represented as a vector of ordinals".
2271
2272       Possibly changed pseudo-random number generator
2273           Perl programs that depend on reproducing a specific set of pseudo-
2274           random numbers may now produce different output due to improvements
2275           made to the rand() builtin.  You can use "sh Configure
2276           -Drandfunc=rand" to obtain the old behavior.
2277
2278           See "Better pseudo-random number generator".
2279
2280       Hashing function for hash keys has changed
2281           Even though Perl hashes are not order preserving, the apparently
2282           random order encountered when iterating on the contents of a hash
2283           is actually determined by the hashing algorithm used.  Improvements
2284           in the algorithm may yield a random order that is different from
2285           that of previous versions, especially when iterating on hashes.
2286
2287           See "Better worst-case behavior of hashes" for additional
2288           information.
2289
2290       "undef" fails on read only values
2291           Using the "undef" operator on a readonly value (such as $1) has the
2292           same effect as assigning "undef" to the readonly value--it throws
2293           an exception.
2294
2295       Close-on-exec bit may be set on pipe and socket handles
2296           Pipe and socket handles are also now subject to the close-on-exec
2297           behavior determined by the special variable $^F.
2298
2299           See "More consistent close-on-exec behavior".
2300
2301       Writing "$$1" to mean "${$}1" is unsupported
2302           Perl 5.004 deprecated the interpretation of $$1 and similar within
2303           interpolated strings to mean "$$ . "1"", but still allowed it.
2304
2305           In Perl 5.6.0 and later, "$$1" always means "${$1}".
2306
2307       delete(), each(), values() and "\(%h)"
2308           operate on aliases to values, not copies
2309
2310           delete(), each(), values() and hashes (e.g. "\(%h)") in a list
2311           context return the actual values in the hash, instead of copies (as
2312           they used to in earlier versions).  Typical idioms for using these
2313           constructs copy the returned values, but this can make a
2314           significant difference when creating references to the returned
2315           values.  Keys in the hash are still returned as copies when
2316           iterating on a hash.
2317
2318           See also "delete(), each(), values() and hash iteration are
2319           faster".
2320
2321       vec(EXPR,OFFSET,BITS) enforces powers-of-two BITS
2322           vec() generates a run-time error if the BITS argument is not a
2323           valid power-of-two integer.
2324
2325       Text of some diagnostic output has changed
2326           Most references to internal Perl operations in diagnostics have
2327           been changed to be more descriptive.  This may be an issue for
2328           programs that may incorrectly rely on the exact text of diagnostics
2329           for proper functioning.
2330
2331       "%@" has been removed
2332           The undocumented special variable "%@" that used to accumulate
2333           "background" errors (such as those that happen in DESTROY()) has
2334           been removed, because it could potentially result in memory leaks.
2335
2336       Parenthesized not() behaves like a list operator
2337           The "not" operator now falls under the "if it looks like a
2338           function, it behaves like a function" rule.
2339
2340           As a result, the parenthesized form can be used with "grep" and
2341           "map".  The following construct used to be a syntax error before,
2342           but it works as expected now:
2343
2344               grep not($_), @things;
2345
2346           On the other hand, using "not" with a literal list slice may not
2347           work.  The following previously allowed construct:
2348
2349               print not (1,2,3)[0];
2350
2351           needs to be written with additional parentheses now:
2352
2353               print not((1,2,3)[0]);
2354
2355           The behavior remains unaffected when "not" is not followed by
2356           parentheses.
2357
2358       Semantics of bareword prototype "(*)" have changed
2359           The semantics of the bareword prototype "*" have changed.  Perl
2360           5.005 always coerced simple scalar arguments to a typeglob, which
2361           wasn't useful in situations where the subroutine must distinguish
2362           between a simple scalar and a typeglob.  The new behavior is to not
2363           coerce bareword arguments to a typeglob.  The value will always be
2364           visible as either a simple scalar or as a reference to a typeglob.
2365
2366           See "More functional bareword prototype (*)".
2367
2368       Semantics of bit operators may have changed on 64-bit platforms
2369           If your platform is either natively 64-bit or if Perl has been
2370           configured to used 64-bit integers, i.e., $Config{ivsize} is 8,
2371           there may be a potential incompatibility in the behavior of bitwise
2372           numeric operators (& | ^ ~ << >>).  These operators used to
2373           strictly operate on the lower 32 bits of integers in previous
2374           versions, but now operate over the entire native integral width.
2375           In particular, note that unary "~" will produce different results
2376           on platforms that have different $Config{ivsize}.  For portability,
2377           be sure to mask off the excess bits in the result of unary "~",
2378           e.g., "~$x & 0xffffffff".
2379
2380           See "Bit operators support full native integer width".
2381
2382       More builtins taint their results
2383           As described in "Improved security features", there may be more
2384           sources of taint in a Perl program.
2385
2386           To avoid these new tainting behaviors, you can build Perl with the
2387           Configure option "-Accflags=-DINCOMPLETE_TAINTS".  Beware that the
2388           ensuing perl binary may be insecure.
2389
2390   C Source Incompatibilities
2391       "PERL_POLLUTE"
2392           Release 5.005 grandfathered old global symbol names by providing
2393           preprocessor macros for extension source compatibility.  As of
2394           release 5.6.0, these preprocessor definitions are not available by
2395           default.  You need to explicitly compile perl with "-DPERL_POLLUTE"
2396           to get these definitions.  For extensions still using the old
2397           symbols, this option can be specified via MakeMaker:
2398
2399               perl Makefile.PL POLLUTE=1
2400
2401       "PERL_IMPLICIT_CONTEXT"
2402           This new build option provides a set of macros for all API
2403           functions such that an implicit interpreter/thread context argument
2404           is passed to every API function.  As a result of this, something
2405           like "sv_setsv(foo,bar)" amounts to a macro invocation that
2406           actually translates to something like
2407           "Perl_sv_setsv(my_perl,foo,bar)".  While this is generally expected
2408           to not have any significant source compatibility issues, the
2409           difference between a macro and a real function call will need to be
2410           considered.
2411
2412           This means that there is a source compatibility issue as a result
2413           of this if your extensions attempt to use pointers to any of the
2414           Perl API functions.
2415
2416           Note that the above issue is not relevant to the default build of
2417           Perl, whose interfaces continue to match those of prior versions
2418           (but subject to the other options described here).
2419
2420           See "Background and PERL_IMPLICIT_CONTEXT" in perlguts for detailed
2421           information on the ramifications of building Perl with this option.
2422
2423               NOTE: PERL_IMPLICIT_CONTEXT is automatically enabled whenever Perl is built
2424               with one of -Dusethreads, -Dusemultiplicity, or both.  It is not
2425               intended to be enabled by users at this time.
2426
2427       "PERL_POLLUTE_MALLOC"
2428           Enabling Perl's malloc in release 5.005 and earlier caused the
2429           namespace of the system's malloc family of functions to be usurped
2430           by the Perl versions, since by default they used the same names.
2431           Besides causing problems on platforms that do not allow these
2432           functions to be cleanly replaced, this also meant that the system
2433           versions could not be called in programs that used Perl's malloc.
2434           Previous versions of Perl have allowed this behaviour to be
2435           suppressed with the HIDEMYMALLOC and EMBEDMYMALLOC preprocessor
2436           definitions.
2437
2438           As of release 5.6.0, Perl's malloc family of functions have default
2439           names distinct from the system versions.  You need to explicitly
2440           compile perl with "-DPERL_POLLUTE_MALLOC" to get the older
2441           behaviour.  HIDEMYMALLOC and EMBEDMYMALLOC have no effect, since
2442           the behaviour they enabled is now the default.
2443
2444           Note that these functions do not constitute Perl's memory
2445           allocation API.  See "Memory Allocation" in perlguts for further
2446           information about that.
2447
2448   Compatible C Source API Changes
2449       "PATCHLEVEL" is now "PERL_VERSION"
2450           The cpp macros "PERL_REVISION", "PERL_VERSION", and
2451           "PERL_SUBVERSION" are now available by default from perl.h, and
2452           reflect the base revision, patchlevel, and subversion respectively.
2453           "PERL_REVISION" had no prior equivalent, while "PERL_VERSION" and
2454           "PERL_SUBVERSION" were previously available as "PATCHLEVEL" and
2455           "SUBVERSION".
2456
2457           The new names cause less pollution of the cpp namespace and reflect
2458           what the numbers have come to stand for in common practice.  For
2459           compatibility, the old names are still supported when patchlevel.h
2460           is explicitly included (as required before), so there is no source
2461           incompatibility from the change.
2462
2463   Binary Incompatibilities
2464       In general, the default build of this release is expected to be binary
2465       compatible for extensions built with the 5.005 release or its
2466       maintenance versions.  However, specific platforms may have broken
2467       binary compatibility due to changes in the defaults used in hints
2468       files.  Therefore, please be sure to always check the platform-specific
2469       README files for any notes to the contrary.
2470
2471       The usethreads or usemultiplicity builds are not binary compatible with
2472       the corresponding builds in 5.005.
2473
2474       On platforms that require an explicit list of exports (AIX, OS/2 and
2475       Windows, among others), purely internal symbols such as parser
2476       functions and the run time opcodes are not exported by default.  Perl
2477       5.005 used to export all functions irrespective of whether they were
2478       considered part of the public API or not.
2479
2480       For the full list of public API functions, see perlapi.
2481

Known Problems

2483   Thread test failures
2484       The subtests 19 and 20 of lib/thr5005.t test are known to fail due to
2485       fundamental problems in the 5.005 threading implementation.  These are
2486       not new failures--Perl 5.005_0x has the same bugs, but didn't have
2487       these tests.
2488
2489   EBCDIC platforms not supported
2490       In earlier releases of Perl, EBCDIC environments like OS390 (also known
2491       as Open Edition MVS) and VM-ESA were supported.  Due to changes
2492       required by the UTF-8 (Unicode) support, the EBCDIC platforms are not
2493       supported in Perl 5.6.0.
2494
2495   In 64-bit HP-UX the lib/io_multihomed test may hang
2496       The lib/io_multihomed test may hang in HP-UX if Perl has been
2497       configured to be 64-bit.  Because other 64-bit platforms do not hang in
2498       this test, HP-UX is suspect.  All other tests pass in 64-bit HP-UX.
2499       The test attempts to create and connect to "multihomed" sockets
2500       (sockets which have multiple IP addresses).
2501
2502   NEXTSTEP 3.3 POSIX test failure
2503       In NEXTSTEP 3.3p2 the implementation of the strftime(3) in the
2504       operating system libraries is buggy: the %j format numbers the days of
2505       a month starting from zero, which, while being logical to programmers,
2506       will cause the subtests 19 to 27 of the lib/posix test may fail.
2507
2508   Tru64 (aka Digital UNIX, aka DEC OSF/1) lib/sdbm test failure with gcc
2509       If compiled with gcc 2.95 the lib/sdbm test will fail (dump core).  The
2510       cure is to use the vendor cc, it comes with the operating system and
2511       produces good code.
2512
2513   UNICOS/mk CC failures during Configure run
2514       In UNICOS/mk the following errors may appear during the Configure run:
2515
2516               Guessing which symbols your C compiler and preprocessor define...
2517               CC-20 cc: ERROR File = try.c, Line = 3
2518               ...
2519                 bad switch yylook 79bad switch yylook 79bad switch yylook 79bad switch yylook 79#ifdef A29K
2520               ...
2521               4 errors detected in the compilation of "try.c".
2522
2523       The culprit is the broken awk of UNICOS/mk.  The effect is fortunately
2524       rather mild: Perl itself is not adversely affected by the error, only
2525       the h2ph utility coming with Perl, and that is rather rarely needed
2526       these days.
2527
2528   Arrow operator and arrays
2529       When the left argument to the arrow operator "->" is an array, or the
2530       "scalar" operator operating on an array, the result of the operation
2531       must be considered erroneous. For example:
2532
2533           @x->[2]
2534           scalar(@x)->[2]
2535
2536       These expressions will get run-time errors in some future release of
2537       Perl.
2538
2539   Experimental features
2540       As discussed above, many features are still experimental.  Interfaces
2541       and implementation of these features are subject to change, and in
2542       extreme cases, even subject to removal in some future release of Perl.
2543       These features include the following:
2544
2545       Threads
2546       Unicode
2547       64-bit support
2548       Lvalue subroutines
2549       Weak references
2550       The pseudo-hash data type
2551       The Compiler suite
2552       Internal implementation of file globbing
2553       The DB module
2554       The regular expression code constructs:
2555           "(?{ code })" and "(??{ code })"
2556

Obsolete Diagnostics

2558       Character class syntax [: :] is reserved for future extensions
2559           (W) Within regular expression character classes ([]) the syntax
2560           beginning with "[:" and ending with ":]" is reserved for future
2561           extensions.  If you need to represent those character sequences
2562           inside a regular expression character class, just quote the square
2563           brackets with the backslash: "\[:" and ":\]".
2564
2565       Ill-formed logical name |%s| in prime_env_iter
2566           (W) A warning peculiar to VMS.  A logical name was encountered when
2567           preparing to iterate over %ENV which violates the syntactic rules
2568           governing logical names.  Because it cannot be translated normally,
2569           it is skipped, and will not appear in %ENV.  This may be a benign
2570           occurrence, as some software packages might directly modify logical
2571           name tables and introduce nonstandard names, or it may indicate
2572           that a logical name table has been corrupted.
2573
2574       In string, @%s now must be written as \@%s
2575           The description of this error used to say:
2576
2577                   (Someday it will simply assume that an unbackslashed @
2578                    interpolates an array.)
2579
2580           That day has come, and this fatal error has been removed.  It has
2581           been replaced by a non-fatal warning instead.  See "Arrays now
2582           always interpolate into double-quoted strings" for details.
2583
2584       Probable precedence problem on %s
2585           (W) The compiler found a bareword where it expected a conditional,
2586           which often indicates that an || or && was parsed as part of the
2587           last argument of the previous construct, for example:
2588
2589               open FOO || die;
2590
2591       regexp too big
2592           (F) The current implementation of regular expressions uses shorts
2593           as address offsets within a string.  Unfortunately this means that
2594           if the regular expression compiles to longer than 32767, it'll blow
2595           up.  Usually when you want a regular expression this big, there is
2596           a better way to do it with multiple statements.  See perlre.
2597
2598       Use of "$$<digit>" to mean "${$}<digit>" is deprecated
2599           (D) Perl versions before 5.004 misinterpreted any type marker
2600           followed by "$" and a digit.  For example, "$$0" was incorrectly
2601           taken to mean "${$}0" instead of "${$0}".  This bug is (mostly)
2602           fixed in Perl 5.004.
2603
2604           However, the developers of Perl 5.004 could not fix this bug
2605           completely, because at least two widely-used modules depend on the
2606           old meaning of "$$0" in a string.  So Perl 5.004 still interprets
2607           "$$<digit>" in the old (broken) way inside strings; but it
2608           generates this message as a warning.  And in Perl 5.005, this
2609           special treatment will cease.
2610

Reporting Bugs

2612       If you find what you think is a bug, you might check the articles
2613       recently posted to the comp.lang.perl.misc newsgroup.  There may also
2614       be information at http://www.perl.com/perl/ , the Perl Home Page.
2615
2616       If you believe you have an unreported bug, please run the perlbug
2617       program included with your release.  Be sure to trim your bug down to a
2618       tiny but sufficient test case.  Your bug report, along with the output
2619       of "perl -V", will be sent off to perlbug@perl.org to be analysed by
2620       the Perl porting team.
2621

SEE ALSO

2623       The Changes file for exhaustive details on what changed.
2624
2625       The INSTALL file for how to build Perl.
2626
2627       The README file for general stuff.
2628
2629       The Artistic and Copying files for copyright information.
2630

HISTORY

2632       Written by Gurusamy Sarathy <gsar@activestate.com>, with many
2633       contributions from The Perl Porters.
2634
2635       Send omissions or corrections to <perlbug@perl.org>.
2636
2637
2638
2639perl v5.34.0                      2021-10-18                    PERL56DELTA(1)
Impressum