1PERL56DELTA(1) Perl Programmers Reference Guide PERL56DELTA(1)
2
6 perl56delta - what's new for perl v5.6.0
7
9 This document describes differences between the 5.005 release and the
10 5.6.0 release.
11
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 On the Windows platform, this feature is used to emulate fork() at the
22 interpreter level. See perlfork for details about that.
23 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 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 -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 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 NOTE: This is an experimental feature. Implementation details are
52 subject to change.
53 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 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 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 NOTE: This should be considered an experimental feature. Implementation
72 details are subject to change.
73 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 "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 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 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 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 # this will parse in older versions of Perl also
106 if ($^V and $^V gt v5.6.0) {
107 # new features supported
108 }
109 "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 require 5.006; # run time check for v5.6
117 use 5.006_001; # compile time check for v5.6.1
118 Also, "sprintf" and "printf" support the Perl-specific format flag %v
120 to print ordinals of characters in arbitrary strings:
121 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 See "Scalar value constructors" in perldata for additional information.
127 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 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 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 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 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 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 sub mymethod : locked method;
163 ...
164 sub mymethod : locked method {
165 ...
166 }
167 sub othermethod :locked :method;
169 ...
170 sub othermethod :locked :method {
171 ...
172 }
173 (Note how only the first ":" is mandatory, and whitespace surrounding
175 the ":" is optional.)
176 AutoSplit.pm and SelfLoader.pm have been updated to keep the attributes
178 with the stubs they provide. See attributes.
179 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 sub myopen {
193 open my $fh, "@_"
194 or die "Can't open '@_': $!";
195 return $fh;
196 }
197 {
199 my $f = myopen("</etc/motd");
200 print <$f>;
201 # $f implicitly closed here
202 }
203 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 64-bit support
211 Any platform that has 64-bit integers either
212 (1) natively as longs or ints
214 (2) via special compiler flags
215 (3) using long long or int64_t
216 is able to use "quads" (64-bit integers) as follows:
218 • constants (decimal, hexadecimal, octal, binary) in the code
220 • arguments to oct() and hex()
222 • arguments to print(), printf() and sprintf() (flag prefixes ll, L,
224 q)
225 • printed as such
227 • pack() and unpack() "q" and "Q" formats
229 • in basic arithmetics: + - * / % (NOTE: operating close to the
231 limits of the integer values may produce surprising results)
232 • in bit arithmetics: & | ^ ~ << >> (NOTE: these used to be forced to
234 be 32 bits wide but now operate on the full native width.)
235 • vec()
237 Note that unless you have the case (a) you will have to configure and
239 compile Perl using the -Duse64bitint Configure flag.
240 NOTE: The Configure flags -Duselonglong and -Duse64bits have been
242 deprecated. Use -Duse64bitint instead.
243 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 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 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 Natively 64-bit systems like Alpha and Cray need neither -Duse64bitint
265 nor -Duse64bitall.
266 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 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 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 NOTE: The default action is to enable large file support, if
285 available on the platform.
286 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 Beware that unless your filesystem also supports "sparse files" seeking
292 to umpteen petabytes may be inadvisable.
293 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 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 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 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 "more bits"
319 You can "Configure -Dusemorebits" to turn on both the 64-bit support
320 and the long double support.
321 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 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 "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 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 NOTE: This is currently an experimental feature. Interfaces and
342 implementation are subject to change.
343 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 POSIX character class syntax [: :] supported
352 For example to match alphabetic characters use /[[:alpha:]]/. See
353 perlre for details.
354 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 These changes should result in better random numbers from rand().
361 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 Thus:
369 $foo = ($bar) = qw(a b c); print "$foo|$bar\n";
371 now correctly prints "3|a", instead of "2|a".
373 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 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 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 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 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 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 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 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 To use this feature, you need the Devel::WeakRef package from CPAN,
412 which contains additional documentation.
413 NOTE: This is an experimental feature. Details are subject to change.
415 Binary numbers supported
417 Binary numbers are now supported as literals, in s?printf formats, and
418 oct():
419 $answer = 0b101010;
421 printf "The answer is: %b\n", oct("0b101010");
422 Lvalue subroutines
424 Subroutines can now return modifiable lvalues. See "Lvalue
425 subroutines" in perlsub.
426 NOTE: This is an experimental feature. Details are subject to change.
428 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 Boolean assignment operators are legal lvalues
437 Constructs such as "($a ||= 2) += 1" are now allowed.
438 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 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 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 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 See "exists" in perlfunc and "delete" in perlfunc for examples.
462 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 When applied to a pseudo-hash element, exists() now reports whether the
468 specified value exists, not merely if the key is valid.
469 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 Pseudo-hash slices with constant keys are now optimized to array
476 lookups at compile-time.
477 List assignments to pseudo-hash slices are now supported.
479 The "fields" pragma now provides ways to create pseudo-hashes, via
481 fields::new() and fields::phash(). See fields.
482 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 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 This is not supported on some platforms like Solaris where a suitably
494 correct implementation of fflush(NULL) isn't available.
495 Better diagnostics on meaningless filehandle operations
497 Constructs such as open(<FH>) and close(<FH>) are compile time errors.
498 Attempting to read from filehandles that were opened only for writing
499 will now produce warnings (just as writing to read-only filehandles
500 does).
501 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 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 now
513 opens the "<>" files.
514 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 "-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 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 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 Improved diagnostics
536 Line numbers are no longer suppressed (under most likely circumstances)
537 during the global destruction phase.
538 Diagnostics emitted from code running in threads other than the main
540 thread are now accompanied by the thread ID.
541 Embedded null characters in diagnostics now actually show up. They
543 used to truncate the message in prior versions.
544 $foo::a and $foo::b are now exempt from "possible typo" warnings only
546 if sort() is encountered in package "foo".
547 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 Many diagnostics now report the internal operation in which the warning
553 was provoked, like so:
554 Use of uninitialized value in concatenation (.) at (eval 1) line 1.
556 Use of uninitialized value in print at (eval 1) line 1.
557 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 Not enough arguments for scalar at (eval 4)[newlib/perl5db.pl:1411] line 2, at EOF
564 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 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 syswrite() ease-of-use
580 The length argument of syswrite() has become optional.
581 Better syntax checks on parenthesized unary operators
583 Expressions such as:
584 print defined(&foo,&bar,&baz);
586 print uc("foo","bar","baz");
587 undef($foo,&bar);
588 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 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 print defined &foo, &bar, &baz;
599 print uc "foo", "bar", "baz";
600 undef $foo, &bar;
601 remains unchanged. See perlop.
603 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 Improved security features
614 More potentially unsafe operations taint their results for improved
615 security.
616 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 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 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 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 "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 $^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 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 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 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 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 See "Support for strings represented as a vector of ordinals" for an
677 example.
678 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 This behavior must be specifically enabled when running Configure. See
684 INSTALL and README.Y2K.
685 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 Literal @example now requires backslash
694 In versions 5.004_01 through 5.6.0, the error was
696 In string, @example now must be written as \@example
698 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 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 Possible unintended interpolation of @example in string
710 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 @- 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
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 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 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 Benchmark
737 Overall, Benchmark results exhibit lower average error and better
738 timing accuracy.
739 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 use Benchmark;$x=3;timethese(-5,{a=>sub{$x*$x},b=>sub{$x**2}})
747 will now output something like this:
749 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 New features: "each for at least N CPU seconds...", "wallclock
755 secs", and the "@ operations/CPU second (n=operations)".
756 timethese() now returns a reference to a hash of Benchmark objects
758 containing the test results, keyed on the names of the tests.
759 timethis() now returns the iterations field in the Benchmark result
761 object instead of 0.
762 timethese(), timethis(), and the new cmpthese() (see below) can
764 also take a format specifier of 'none' to suppress output.
765 A new function countit() is just like timeit() except that it takes
767 a TIME instead of a COUNT.
768 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 For other details, see Benchmark.
775 ByteLoader
777 The ByteLoader is a dedicated extension to generate and run Perl
778 bytecode. See ByteLoader.
779 constant
781 References can now be used.
782 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 See constant.
792 charnames
794 This pragma implements the "\N" string escape. See charnames.
795 Data::Dumper
797 A "Maxdepth" setting can be specified to avoid venturing too deeply
798 into deep data structures. See Data::Dumper.
799 The XSUB implementation of Dump() is now automatically called if
801 the "Useqq" setting is not in use.
802 Dumping "qr//" objects works correctly.
804 DB "DB" is an experimental module that exposes a clean abstraction to
806 Perl's debugging API.
807 DB_File
809 DB_File can now be built with Berkeley DB versions 1, 2 or 3. See
810 "ext/DB_File/Changes".
811 Devel::DProf
813 Devel::DProf, a Perl source code profiler has been added. See
814 Devel::DProf and dprofpp.
815 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 Dumpvalue
822 The Dumpvalue module provides screen dumps of Perl data.
823 DynaLoader
825 DynaLoader now supports a dl_unload_file() function on platforms
826 that support unloading shared objects using dlclose().
827 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 English
834 $PERL_VERSION now stands for $^V (a string value) rather than for
835 $] (a numeric value).
836 Env Env now supports accessing environment variables like PATH as array
838 variables.
839 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 File::Compare
852 A compare_text() function has been added, which allows custom
853 comparison functions. See File::Compare.
854 File::Find
856 File::Find now works correctly when the wanted() function is either
857 autoloaded or is a symbolic reference.
858 A bug that caused File::Find to lose track of the working directory
860 when pruning top-level directories has been fixed.
861 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 See File::Find.
870 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 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 File::Spec::Functions
886 The new File::Spec::Functions modules provides a function interface
887 to the File::Spec module. Allows shorthand
888 $fullname = catfile($dir1, $dir2, $file);
890 instead of
892 $fullname = File::Spec->catfile($dir1, $dir2, $file);
894 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 Getopt::Long encourages the use of Pod::Usage to produce help
901 messages. For example:
902 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 __END__
912 =head1 NAME
914 sample - Using Getopt::Long and Pod::Usage
916 =head1 SYNOPSIS
918 sample [options] [file ...]
920 Options:
922 -help brief help message
923 -man full documentation
924 =head1 OPTIONS
926 =over 8
928 =item B<-help>
930 Print a brief help message and exits.
932 =item B<-man>
934 Prints the manual page and exits.
936 =back
938 =head1 DESCRIPTION
940 B<This program> will read the given input file(s) and do something
942 useful with the contents thereof.
943 =cut
945 See Pod::Usage for details.
947 A bug that prevented the non-option call-back <> from being
949 specified as the first argument has been fixed.
950 To specify the characters < and > as option starters, use ><. Note,
952 however, that changing option starters is strongly deprecated.
953 IO write() and syswrite() will now accept a single-argument form of
955 the call, for consistency with Perl's syswrite().
956 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 A bug that prevented the IO::Socket::protocol() accessor from ever
962 returning the correct value has been corrected.
963 IO::Socket::connect now uses non-blocking IO instead of alarm() to
965 do connect timeouts.
966 IO::Socket::accept now uses select() instead of alarm() for doing
968 timeouts.
969 IO::Socket::INET->new now sets $! correctly on failure. $@ is still
971 set for backwards compatibility.
972 JPL Java Perl Lingo is now distributed with Perl. See jpl/README for
974 more information.
975 lib "use lib" now weeds out any trailing duplicate entries. "no lib"
977 removes all named entries.
978 Math::BigInt
980 The bitwise operations "<<", ">>", "&", "|", and "~" are now
981 supported on bigints.
982 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 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 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 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 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 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 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 For further information, please see Pod::Parser and
1028 Pod::InputObjects.
1029 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 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 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 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 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 For details and examples, please see Pod::Usage.
1066 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 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 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 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 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 Sys::Hostname
1097 Sys::Hostname now uses XSUBs to call the C library's gethostname()
1098 or uname() if they exist.
1099 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 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 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 Win32::FsType
1120 Win32::GetOSVersion
1121 The remaining functions are unchanged and continue to return
1123 "undef" on error even in list context.
1124 The Win32::SetLastError(ERROR) function has been added as a
1126 complement to the Win32::GetLastError() function.
1127 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 XSLoader
1134 The XSLoader extension is a simpler alternative to DynaLoader. See
1135 XSLoader.
1136 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 filter_store_key
1143 filter_store_value
1144 filter_fetch_key
1145 filter_fetch_value
1146 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 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 Lexical warnings pragma, "use warnings;", to control optional warnings.
1157 See perllexwarn.
1158 "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 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
1173 dprofpp
1174 "dprofpp" is used to display profile data generated using
1175 "Devel::DProf". See dprofpp.
1176 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 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 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 Support for non-Unix platforms has been improved.
1193 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 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
1211 Many of the platform-specific README files are now part of the perl
1212 installation. See perl for the complete list.
1213 perlapi.pod
1215 The official list of public Perl API functions.
1216 perlboot.pod
1218 A tutorial for beginners on object-oriented Perl.
1219 perlcompile.pod
1221 An introduction to using the Perl Compiler suite.
1222 perldbmfilter.pod
1224 A howto document on using the DBM filter facility.
1225 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 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 perlfork.pod
1240 Notes on the fork() emulation currently available for the Windows
1241 platform.
1242 perlfilter.pod
1244 An introduction to writing Perl source filters.
1245 perlhack.pod
1247 Some guidelines for hacking the Perl source code.
1248 perlintern.pod
1250 A list of internal functions in the Perl source code. (List is
1251 currently empty.)
1252 perllexwarn.pod
1254 Introduction and reference information about lexically scoped
1255 warning categories.
1256 perlnumber.pod
1258 Detailed information about numbers as they are represented in Perl.
1259 perlopentut.pod
1261 A tutorial on using open() effectively.
1262 perlreftut.pod
1264 A tutorial that introduces the essentials of references.
1265 perltootc.pod
1267 A tutorial on managing class data for object modules.
1268 perltodo.pod
1270 Discussion of the most often wanted features that may someday be
1271 supported in Perl.
1272 perlunicode.pod
1274 An introduction to Unicode support features in Perl.
1275
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 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 Faster subroutine calls
1287 Minor changes in how subroutine calls are handled internally provide
1288 marginal improvements in performance.
1289 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
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 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 NOTE: Support for threads continues to be an experimental feature.
1309 Interfaces and implementation are subject to sudden and drastic changes.
1310 New Configure flags
1312 The following new flags may be enabled on the Configure command line by
1313 running Configure with "-Dflag".
1314 usemultiplicity
1316 usethreads useithreads (new interpreter threads: no Perl API yet)
1317 usethreads use5005threads (threads as they were in 5.005)
1318 use64bitint (equal to now deprecated 'use64bits')
1320 use64bitall
1321 uselongdouble
1323 usemorebits
1324 uselargefiles
1325 usesocks (only SOCKS v5 supported)
1326 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 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 -Dusemorebits
1343 You can enable both -Duse64bitint and -Duselongdouble with
1344 -Dusemorebits. See also "64-bit support".
1345 -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 See "Large file support" for more information.
1352 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 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 http://www.socks.nec.com/
1365 "-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 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 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
1389 Supported platforms
1390 • The Mach CThreads (NEXTSTEP, OPENSTEP) are now supported by the
1391 Thread extension.
1392 • GNU/Hurd is now supported.
1394 • Rhapsody/Darwin is now supported.
1396 • EPOC is now supported (on Psion 5).
1398 • The cygwin port (formerly cygwin32) has been greatly improved.
1400 DOS
1402 • Perl now works with djgpp 2.02 (and 2.03 alpha).
1403 • Environment variable names are not converted to uppercase any more.
1405 • Incorrect exit codes from backticks have been fixed.
1407 • This port continues to use its own builtin globbing (not
1409 File::Glob).
1410 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 It is unclear whether future versions will renew support for this
1418 platform, but the possibility exists.
1419 VMS
1421 Numerous revisions and extensions to configuration, build, testing, and
1422 installation process to accommodate core changes and VMS-specific
1423 options.
1424 Expand %ENV-handling code to allow runtime mapping to logical names,
1426 CLI symbols, and CRTL environ array.
1427 Extension of subprocess invocation code to accept filespecs as command
1429 "verbs".
1430 Add to Perl command line processing the ability to use default file
1432 types and to recognize Unix-style "2>&1".
1433 Expansion of File::Spec::VMS routines, and integration into
1435 ExtUtils::MM_VMS.
1436 Extension of ExtUtils::MM_VMS to handle complex extensions more
1438 flexibly.
1439 Barewords at start of Unix-syntax paths may be treated as text rather
1441 than only as logical names.
1442 Optional secure translation of several logical names used internally by
1444 Perl.
1445 Miscellaneous bugfixing and porting of new core code to VMS.
1447 Thanks are gladly extended to the many people who have contributed VMS
1449 patches, testing, and ideas.
1450 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 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 The builtin XSUB functions in the Win32:: namespace are documented.
1461 See Win32.
1462 $^X now contains the full path name of the running executable.
1464 A Win32::GetLongPathName() function is provided to complement
1466 Win32::GetFullPathName() and Win32::GetShortPathName(). See Win32.
1467 POSIX::uname() is supported.
1469 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 For better compatibility with Unix, "kill(0, $pid)" can now be used to
1475 test whether a process exists.
1476 The "Shell" module is supported.
1478 Better support for building Perl under command.com in Windows 95 has
1480 been added.
1481 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 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
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 This means that the following will append "foo" to an empty file (it
1505 used to do nothing):
1506 perl -0777 -pi -e 's/^/foo/' empty_file
1508 The behaviour of:
1510 perl -pi -e 's/^/foo/' empty_file
1512 is unchanged (it continues to leave the file empty).
1514 "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 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 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 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 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 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 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 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 The new behavior is to produce an empty list if (and only if) the
1556 original list was empty. Consider the following example:
1557 @a = (1,undef,undef,2)[2,1,2];
1559 The old behavior would have resulted in @a having no elements. The new
1561 behavior ensures it has three undefined elements.
1562 Note in particular that the behavior of slices of the following cases
1564 remains unchanged:
1565 @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 See perldata.
1573 "(\$)" prototype and $foo{a}
1575 A scalar reference prototype now correctly allows a hash or array
1576 element in that slot.
1577 "goto &sub" and AUTOLOAD
1579 The "goto &sub" construct works correctly when &sub happens to be
1580 autoloaded.
1581 "-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 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 Locale bugs fixed
1593 printf() and sprintf() previously reset the numeric locale back to the
1594 default "C" locale. This has been fixed.
1595 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 Memory leaks
1602 The "eval 'return sub {...}'" construct could sometimes leak memory.
1603 This has been fixed.
1604 Operations that aren't filehandle constructors used to leak memory when
1606 used on invalid filehandles. This has been fixed.
1607 Constructs that modified @_ could fail to deallocate values in @_ and
1609 thus leak memory. This has been corrected.
1610 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 Taint failures under "-U"
1617 When running in unsafe mode, taint violations could sometimes cause
1618 silent failures. This has been fixed.
1619 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 See "Support for CHECK blocks" for how to run things when the compile
1627 phase ends.
1628 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 This caveat is now better explained in the documentation. See
1635 perldata.
1636
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 "my sub" not yet implemented
1647 (F) Lexically scoped subroutines are not yet implemented. Don't
1648 try that yet.
1649 "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 '!' allowed only after types %s
1655 (F) The '!' is allowed in pack() and unpack() only after certain
1656 types. See "pack" in perlfunc.
1657 / 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 / 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 / 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 / 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 /%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 /%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 /%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 %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 %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 $foo{$bar}
1710 $ref->{"susie"}[12]
1711 %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 $foo{$bar}
1717 $ref->{"susie"}[12]
1718 or a hash or array slice, such as:
1720 @foo[$bar, $baz, $xyzzy]
1722 @{$ref->[12]}{"susie", "queue"}
1723 %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 %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 (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 Failure of user callbacks dispatched using the "G_KEEPERR" flag
1744 could also result in this warning. See "G_KEEPERR" in perlcall.
1745 <> should be quotes
1747 (F) You wrote "require <file>" when you should have written
1748 "require 'file'".
1749 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 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 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 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 open FOO || die;
1771 It may also indicate a misspelled constant that has been
1773 interpreted as a bareword:
1774 use constant TYPO => 1;
1776 if (TYOP) { print "foo" }
1777 The "strict" pragma is useful in avoiding such errors.
1779 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 Bit vector size > 32 non-portable
1786 (W portable) Using bit vector sizes larger than 32 is non-portable.
1787 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 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 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 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 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 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 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 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 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 Can't weaken a nonreference
1837 (F) You attempted to weaken something that was not a reference.
1838 Only references can be weakened.
1839 Character class [:%s:] unknown
1841 (F) The class in the character class [: :] syntax is unknown. See
1842 perlre.
1843 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 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 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 CORE::%s is not a keyword
1867 (F) The CORE:: namespace is reserved for Perl keywords.
1868 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 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 Did not produce a valid header
1880 See Server error.
1881 (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 Document contains no data
1888 See Server error.
1889 entering effective %s failed
1891 (F) While under the "use filetest" pragma, switching the real and
1892 effective uids or gids failed.
1893 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 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 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 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 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 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 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 Illegal binary digit %s
1937 (F) You used a digit other than 0 or 1 in a binary number.
1938 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 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 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 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 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 invalid [] range "%s" in regexp
1968 The offending range is now explicitly displayed.
1969 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 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 leaving effective %s failed
1983 (F) While under the "use filetest" pragma, switching the real and
1984 effective uids or gids failed.
1985 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 Method %s not permitted
1992 See Server error.
1993 Missing %sbrace%s on \N{}
1995 (F) Wrong syntax of character name literal "\N{charname}" within
1996 double-quotish context.
1997 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 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 No %s specified for -%c
2007 (F) The indicated command line switch needs a mandatory argument,
2008 but you haven't specified one.
2009 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 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 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 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 See also perlport for writing portable code.
2032 panic: del_backref
2034 (P) Failed an internal consistency check while trying to reset a
2035 weak reference.
2036 panic: kid popen errno read
2038 (F) forked child returned an incomprehensible message about its
2039 errno.
2040 panic: magic_killbackrefs
2042 (P) Failed an internal consistency check while trying to reset all
2043 weak references to an object.
2044 Parentheses missing around "%s" list
2046 (W parenthesis) You said something like
2047 my $foo, $bar = @_;
2049 when you meant
2051 my ($foo, $bar) = @_;
2053 Remember that "my", "our", and "local" bind tighter than comma.
2055 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 print "fred@example.com";
2063 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 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 pragma "attrs" is deprecated, use "sub NAME : ATTRS" instead
2074 (W deprecated) You have written something like this:
2075 sub doit
2077 {
2078 use attrs qw(locked);
2079 }
2080 You should use the new declaration syntax instead.
2082 sub doit : locked
2084 {
2085 ...
2086 The "use attrs" pragma is now obsolete, and is only provided for
2088 backward-compatibility. See "Subroutine Attributes" in perlsub.
2089 Premature end of script headers
2091 See Server error.
2092 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 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 realloc() of freed memory ignored
2102 (S) An internal routine called realloc() on something that had
2103 already been freed.
2104 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 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 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 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 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 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 Unknown open() mode '%s'
2143 (F) The second argument of 3-argument open() is not among the list
2144 of valid modes: "<", ">", ">>", "+<", "+>", "+>>", "-|", "|-".
2145 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 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 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 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 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 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 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 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
2194 lib/attrs
2195 Compatibility tests for "sub : attrs" vs the older "use attrs".
2196 lib/env
2198 Tests for new environment scalar capability (e.g., "use Env
2199 qw($BAR);").
2200 lib/env-array
2202 Tests for new environment array capability (e.g., "use Env
2203 qw(@PATH);").
2204 lib/io_const
2206 IO constants (SEEK_*, _IO*).
2207 lib/io_dir
2209 Directory-related IO methods (new, read, close, rewind, tied
2210 delete).
2211 lib/io_multihomed
2213 INET sockets with multi-homed hosts.
2214 lib/io_poll
2216 IO poll().
2217 lib/io_unix
2219 UNIX sockets.
2220 op/attrs
2222 Regression tests for "my ($x,@y,%z) : attrs" and <sub : attrs>.
2223 op/filetest
2225 File test operators.
2226 op/lex_assign
2228 Verify operations that access pad objects (lexicals and
2229 temporaries).
2230 op/exists_sub
2232 Verify "exists &sub" operations.
2233
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 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 CHECK is a new keyword
2244 All subroutine definitions named CHECK are now special. See
2245 "/"Support for CHECK blocks"" for more information.
2246 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 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 See "Improved Perl version numbering system" for the reasons for
2259 this change.
2260 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 For example, "print 97.98.99" used to output 97.9899 in earlier
2268 versions, but now prints "abc".
2269 See "Support for strings represented as a vector of ordinals".
2271 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 See "Better pseudo-random number generator".
2279 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 See "Better worst-case behavior of hashes" for additional
2288 information.
2289 "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 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 See "More consistent close-on-exec behavior".
2300 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 In Perl 5.6.0 and later, "$$1" always means "${$1}".
2306 delete(), each(), values() and "\(%h)"
2308 operate on aliases to values, not copies
2309 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 See also "delete(), each(), values() and hash iteration are
2319 faster".
2320 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 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 "%@" 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 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 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 grep not($_), @things;
2345 On the other hand, using "not" with a literal list slice may not
2347 work. The following previously allowed construct:
2348 print not (1,2,3)[0];
2350 needs to be written with additional parentheses now:
2352 print not((1,2,3)[0]);
2354 The behavior remains unaffected when "not" is not followed by
2356 parentheses.
2357 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 See "More functional bareword prototype (*)".
2367 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 See "Bit operators support full native integer width".
2381 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 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 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 perl Makefile.PL POLLUTE=1
2400 "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 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 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 See "Background and PERL_IMPLICIT_CONTEXT" in perlguts for detailed
2421 information on the ramifications of building Perl with this option.
2422 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 "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 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 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 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 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 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 The usethreads or usemultiplicity builds are not binary compatible with
2472 the corresponding builds in 5.005.
2473 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 For the full list of public API functions, see perlapi.
2481
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 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 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 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 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 UNICOS/mk CC failures during Configure run
2514 In UNICOS/mk the following errors may appear during the Configure run:
2515 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 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 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 @x->[2]
2534 scalar(@x)->[2]
2535 These expressions will get run-time errors in some future release of
2537 Perl.
2538 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 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
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 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 In string, @%s now must be written as \@%s
2575 The description of this error used to say:
2576 (Someday it will simply assume that an unbackslashed @
2578 interpolates an array.)
2579 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 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 open FOO || die;
2590 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 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 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
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 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
2623 The Changes file for exhaustive details on what changed.
2624 The INSTALL file for how to build Perl.
2626 The README file for general stuff.
2628 The Artistic and Copying files for copyright information.
2630
2632 Written by Gurusamy Sarathy <gsar@activestate.com>, with many
2633 contributions from The Perl Porters.
2634 Send omissions or corrections to <perlbug@perl.org>.
2636perl v5.38.2 2023-11-30 PERL56DELTA(1)