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

NAME

6       perl5005delta - what's new for perl5.005
7

DESCRIPTION

9       This document describes differences between the 5.004 release and this
10       one.
11

About the new versioning system

13       Perl is now developed on two tracks: a maintenance track that makes
14       small, safe updates to released production versions with emphasis on
15       compatibility; and a development track that pursues more aggressive
16       evolution.  Maintenance releases (which should be considered production
17       quality) have subversion numbers that run from 1 to 49, and development
18       releases (which should be considered "alpha" quality) run from 50 to
19       99.
20
21       Perl 5.005 is the combined product of the new dual-track development
22       scheme.
23

Incompatible Changes

25   WARNING:  This version is not binary compatible with Perl 5.004.
26       Starting with Perl 5.004_50 there were many deep and far-reaching
27       changes to the language internals.  If you have dynamically loaded
28       extensions that you built under perl 5.003 or 5.004, you can continue
29       to use them with 5.004, but you will need to rebuild and reinstall
30       those extensions to use them 5.005.  See INSTALL for detailed
31       instructions on how to upgrade.
32
33   Default installation structure has changed
34       The new Configure defaults are designed to allow a smooth upgrade from
35       5.004 to 5.005, but you should read INSTALL for a detailed discussion
36       of the changes in order to adapt them to your system.
37
38   Perl Source Compatibility
39       When none of the experimental features are enabled, there should be
40       very few user-visible Perl source compatibility issues.
41
42       If threads are enabled, then some caveats apply. @_ and $_ become
43       lexical variables.  The effect of this should be largely transparent to
44       the user, but there are some boundary conditions under which user will
45       need to be aware of the issues.  For example, local(@_) results in a
46       "Can't localize lexical variable @_ ..." message.  This may be enabled
47       in a future version.
48
49       Some new keywords have been introduced.  These are generally expected
50       to have very little impact on compatibility.  See "New "INIT" keyword",
51       "New "lock" keyword", and "New "qr//" operator".
52
53       Certain barewords are now reserved.  Use of these will provoke a
54       warning if you have asked for them with the "-w" switch.  See ""our" is
55       now a reserved word".
56
57   C Source Compatibility
58       There have been a large number of changes in the internals to support
59       the new features in this release.
60
61       •   Core sources now require ANSI C compiler
62
63           An ANSI C compiler is now required to build perl.  See INSTALL.
64
65       •   All Perl global variables must now be referenced with an explicit
66           prefix
67
68           All Perl global variables that are visible for use by extensions
69           now have a "PL_" prefix.  New extensions should "not" refer to perl
70           globals by their unqualified names.  To preserve sanity, we provide
71           limited backward compatibility for globals that are being widely
72           used like "sv_undef" and "na" (which should now be written as
73           "PL_sv_undef", "PL_na" etc.)
74
75           If you find that your XS extension does not compile anymore because
76           a perl global is not visible, try adding a "PL_" prefix to the
77           global and rebuild.
78
79           It is strongly recommended that all functions in the Perl API that
80           don't begin with "perl" be referenced with a "Perl_" prefix.  The
81           bare function names without the "Perl_" prefix are supported with
82           macros, but this support may cease in a future release.
83
84           See perlapi.
85
86       •   Enabling threads has source compatibility issues
87
88           Perl built with threading enabled requires extensions to use the
89           new "dTHR" macro to initialize the handle to access per-thread
90           data.  If you see a compiler error that talks about the variable
91           "thr" not being declared (when building a module that has XS code),
92           you need to add "dTHR;" at the beginning of the block that elicited
93           the error.
94
95           The API function "perl_get_sv("@",GV_ADD)" should be used instead
96           of directly accessing perl globals as GvSV(errgv).  The API call is
97           backward compatible with existing perls and provides source
98           compatibility with threading is enabled.
99
100           See "C Source Compatibility" for more information.
101
102   Binary Compatibility
103       This version is NOT binary compatible with older versions.  All
104       extensions will need to be recompiled.  Further binaries built with
105       threads enabled are incompatible with binaries built without.  This
106       should largely be transparent to the user, as all binary incompatible
107       configurations have their own unique architecture name, and extension
108       binaries get installed at unique locations.  This allows coexistence of
109       several configurations in the same directory hierarchy.  See INSTALL.
110
111   Security fixes may affect compatibility
112       A few taint leaks and taint omissions have been corrected.  This may
113       lead to "failure" of scripts that used to work with older versions.
114       Compiling with -DINCOMPLETE_TAINTS provides a perl with minimal amounts
115       of changes to the tainting behavior.  But note that the resulting perl
116       will have known insecurities.
117
118       Oneliners with the "-e" switch do not create temporary files anymore.
119
120   Relaxed new mandatory warnings introduced in 5.004
121       Many new warnings that were introduced in 5.004 have been made
122       optional.  Some of these warnings are still present, but perl's new
123       features make them less often a problem.  See "New Diagnostics".
124
125   Licensing
126       Perl has a new Social Contract for contributors.  See Porting/Contract.
127
128       The license included in much of the Perl documentation has changed.
129       Most of the Perl documentation was previously under the implicit GNU
130       General Public License or the Artistic License (at the user's choice).
131       Now much of the documentation unambiguously states the terms under
132       which it may be distributed.  Those terms are in general much less
133       restrictive than the GNU GPL.  See perl and the individual perl
134       manpages listed therein.
135

Core Changes

137   Threads
138       WARNING: Threading is considered an experimental feature.  Details of
139       the implementation may change without notice.  There are known
140       limitations and some bugs.  These are expected to be fixed in future
141       versions.
142
143       See README.threads.
144
145   Compiler
146       WARNING: The Compiler and related tools are considered experimental.
147       Features may change without notice, and there are known limitations and
148       bugs.  Since the compiler is fully external to perl, the default
149       configuration will build and install it.
150
151       The Compiler produces three different types of transformations of a
152       perl program.  The C backend generates C code that captures perl's
153       state just before execution begins.  It eliminates the compile-time
154       overheads of the regular perl interpreter, but the run-time performance
155       remains comparatively the same.  The CC backend generates optimized C
156       code equivalent to the code path at run-time.  The CC backend has
157       greater potential for big optimizations, but only a few optimizations
158       are implemented currently.  The Bytecode backend generates a platform
159       independent bytecode representation of the interpreter's state just
160       before execution.  Thus, the Bytecode back end also eliminates much of
161       the compilation overhead of the interpreter.
162
163       The compiler comes with several valuable utilities.
164
165       "B::Lint" is an experimental module to detect and warn about suspicious
166       code, especially the cases that the "-w" switch does not detect.
167
168       "B::Deparse" can be used to demystify perl code, and understand how
169       perl optimizes certain constructs.
170
171       "B::Xref" generates cross reference reports of all definition and use
172       of variables, subroutines and formats in a program.
173
174       "B::Showlex" show the lexical variables used by a subroutine or file at
175       a glance.
176
177       "perlcc" is a simple frontend for compiling perl.
178
179       See "ext/B/README", B, and the respective compiler modules.
180
181   Regular Expressions
182       Perl's regular expression engine has been seriously overhauled, and
183       many new constructs are supported.  Several bugs have been fixed.
184
185       Here is an itemized summary:
186
187       Many new and improved optimizations
188           Changes in the RE engine:
189
190                   Unneeded nodes removed;
191                   Substrings merged together;
192                   New types of nodes to process (SUBEXPR)* and similar expressions
193                       quickly, used if the SUBEXPR has no side effects and matches
194                       strings of the same length;
195                   Better optimizations by lookup for constant substrings;
196                   Better search for constants substrings anchored by $ ;
197
198           Changes in Perl code using RE engine:
199
200                   More optimizations to s/longer/short/;
201                   study() was not working;
202                   /blah/ may be optimized to an analogue of index() if $& $` $' not seen;
203                   Unneeded copying of matched-against string removed;
204                   Only matched part of the string is copying if $` $' were not seen;
205
206       Many bug fixes
207           Note that only the major bug fixes are listed here.  See Changes
208           for others.
209
210                   Backtracking might not restore start of $3.
211                   No feedback if max count for * or + on "complex" subexpression
212                       was reached, similarly (but at compile time) for {3,34567}
213                   Primitive restrictions on max count introduced to decrease a
214                       possibility of a segfault;
215                   (ZERO-LENGTH)* could segfault;
216                   (ZERO-LENGTH)* was prohibited;
217                   Long REs were not allowed;
218                   /RE/g could skip matches at the same position after a
219                     zero-length match;
220
221       New regular expression constructs
222           The following new syntax elements are supported:
223
224                   (?<=RE)
225                   (?<!RE)
226                   (?{ CODE })
227                   (?i-x)
228                   (?i:RE)
229                   (?(COND)YES_RE|NO_RE)
230                   (?>RE)
231                   \z
232
233       New operator for precompiled regular expressions
234           See "New "qr//" operator".
235
236       Other improvements
237                   Better debugging output (possibly with colors),
238                       even from non-debugging Perl;
239                   RE engine code now looks like C, not like assembler;
240                   Behaviour of RE modifiable by `use re' directive;
241                   Improved documentation;
242                   Test suite significantly extended;
243                   Syntax [:^upper:] etc., reserved inside character classes;
244
245       Incompatible changes
246                   (?i) localized inside enclosing group;
247                   $( is not interpolated into RE any more;
248                   /RE/g may match at the same position (with non-zero length)
249                       after a zero-length match (bug fix).
250
251       See perlre and perlop.
252
253   Improved malloc()
254       See banner at the beginning of "malloc.c" for details.
255
256   Quicksort is internally implemented
257       Perl now contains its own highly optimized qsort() routine.  The new
258       qsort() is resistant to inconsistent comparison functions, so Perl's
259       sort() will not provoke coredumps any more when given poorly written
260       sort subroutines.  (Some C library qsort()s that were being used before
261       used to have this problem.)  In our testing, the new qsort() required
262       the minimal number of pair-wise compares on average, among all known
263       qsort() implementations.
264
265       See "perlfunc/sort".
266
267   Reliable signals
268       Perl's signal handling is susceptible to random crashes, because
269       signals arrive asynchronously, and the Perl runtime is not reentrant at
270       arbitrary times.
271
272       However, one experimental implementation of reliable signals is
273       available when threads are enabled.  See "Thread::Signal".  Also see
274       INSTALL for how to build a Perl capable of threads.
275
276   Reliable stack pointers
277       The internals now reallocate the perl stack only at predictable times.
278       In particular, magic calls never trigger reallocations of the stack,
279       because all reentrancy of the runtime is handled using a "stack of
280       stacks".  This should improve reliability of cached stack pointers in
281       the internals and in XSUBs.
282
283   More generous treatment of carriage returns
284       Perl used to complain if it encountered literal carriage returns in
285       scripts.  Now they are mostly treated like whitespace within program
286       text.  Inside string literals and here documents, literal carriage
287       returns are ignored if they occur paired with linefeeds, or get
288       interpreted as whitespace if they stand alone.  This behavior means
289       that literal carriage returns in files should be avoided.  You can get
290       the older, more compatible (but less generous) behavior by defining the
291       preprocessor symbol "PERL_STRICT_CR" when building perl.  Of course,
292       all this has nothing whatever to do with how escapes like "\r" are
293       handled within strings.
294
295       Note that this doesn't somehow magically allow you to keep all text
296       files in DOS format.  The generous treatment only applies to files that
297       perl itself parses.  If your C compiler doesn't allow carriage returns
298       in files, you may still be unable to build modules that need a C
299       compiler.
300
301   Memory leaks
302       "substr", "pos" and "vec" don't leak memory anymore when used in lvalue
303       context.  Many small leaks that impacted applications that embed
304       multiple interpreters have been fixed.
305
306   Better support for multiple interpreters
307       The build-time option "-DMULTIPLICITY" has had many of the details
308       reworked.  Some previously global variables that should have been per-
309       interpreter now are.  With care, this allows interpreters to call each
310       other.  See the "PerlInterp" extension on CPAN.
311
312   Behavior of local() on array and hash elements is now well-defined
313       See "Temporary Values via local()" in perlsub.
314
315   "%!" is transparently tied to the Errno module
316       See perlvar, and Errno.
317
318   Pseudo-hashes are supported
319       See perlref.
320
321   "EXPR foreach EXPR" is supported
322       See perlsyn.
323
324   Keywords can be globally overridden
325       See perlsub.
326
327   $^E is meaningful on Win32
328       See perlvar.
329
330   "foreach (1..1000000)" optimized
331       "foreach (1..1000000)" is now optimized into a counting loop.  It does
332       not try to allocate a 1000000-size list anymore.
333
334   "Foo::" can be used as implicitly quoted package name
335       Barewords caused unintuitive behavior when a subroutine with the same
336       name as a package happened to be defined.  Thus, "new Foo @args", use
337       the result of the call to Foo() instead of "Foo" being treated as a
338       literal.  The recommended way to write barewords in the indirect object
339       slot is "new Foo:: @args".  Note that the method new() is called with a
340       first argument of "Foo", not "Foo::" when you do that.
341
342   "exists $Foo::{Bar::}" tests existence of a package
343       It was impossible to test for the existence of a package without
344       actually creating it before.  Now "exists $Foo::{Bar::}" can be used to
345       test if the "Foo::Bar" namespace has been created.
346
347   Better locale support
348       See perllocale.
349
350   Experimental support for 64-bit platforms
351       Perl5 has always had 64-bit support on systems with 64-bit longs.
352       Starting with 5.005, the beginnings of experimental support for systems
353       with 32-bit long and 64-bit 'long long' integers has been added.  If
354       you add -DUSE_LONG_LONG to your ccflags in config.sh (or manually
355       define it in perl.h) then perl will be built with 'long long' support.
356       There will be many compiler warnings, and the resultant perl may not
357       work on all systems.  There are many other issues related to third-
358       party extensions and libraries.  This option exists to allow people to
359       work on those issues.
360
361   prototype() returns useful results on builtins
362       See "prototype" in perlfunc.
363
364   Extended support for exception handling
365       die() now accepts a reference value, and $@ gets set to that value in
366       exception traps.  This makes it possible to propagate exception
367       objects.  This is an undocumented experimental feature.
368
369   Re-blessing in DESTROY() supported for chaining DESTROY() methods
370       See "Destructors" in perlobj.
371
372   All "printf" format conversions are handled internally
373       See "printf" in perlfunc.
374
375   New "INIT" keyword
376       "INIT" subs are like "BEGIN" and "END", but they get run just before
377       the perl runtime begins execution.  e.g., the Perl Compiler makes use
378       of "INIT" blocks to initialize and resolve pointers to XSUBs.
379
380   New "lock" keyword
381       The "lock" keyword is the fundamental synchronization primitive in
382       threaded perl.  When threads are not enabled, it is currently a noop.
383
384       To minimize impact on source compatibility this keyword is "weak",
385       i.e., any user-defined subroutine of the same name overrides it, unless
386       a "use Thread" has been seen.
387
388   New "qr//" operator
389       The "qr//" operator, which is syntactically similar to the other quote-
390       like operators, is used to create precompiled regular expressions.
391       This compiled form can now be explicitly passed around in variables,
392       and interpolated in other regular expressions.  See perlop.
393
394   "our" is now a reserved word
395       Calling a subroutine with the name "our" will now provoke a warning
396       when using the "-w" switch.
397
398   Tied arrays are now fully supported
399       See Tie::Array.
400
401   Tied handles support is better
402       Several missing hooks have been added.  There is also a new base class
403       for TIEARRAY implementations.  See Tie::Array.
404
405   4th argument to substr
406       substr() can now both return and replace in one operation.  The
407       optional 4th argument is the replacement string.  See "substr" in
408       perlfunc.
409
410   Negative LENGTH argument to splice
411       splice() with a negative LENGTH argument now work similar to what the
412       LENGTH did for substr().  Previously a negative LENGTH was treated as
413       0.  See "splice" in perlfunc.
414
415   Magic lvalues are now more magical
416       When you say something like "substr($x, 5) = "hi"", the scalar returned
417       by substr() is special, in that any modifications to it affect $x.
418       (This is called a 'magic lvalue' because an 'lvalue' is something on
419       the left side of an assignment.)  Normally, this is exactly what you
420       would expect to happen, but Perl uses the same magic if you use
421       substr(), pos(), or vec() in a context where they might be modified,
422       like taking a reference with "\" or as an argument to a sub that
423       modifies @_.  In previous versions, this 'magic' only went one way, but
424       now changes to the scalar the magic refers to ($x in the above example)
425       affect the magic lvalue too. For instance, this code now acts
426       differently:
427
428           $x = "hello";
429           sub printit {
430               $x = "g'bye";
431               print $_[0], "\n";
432           }
433           printit(substr($x, 0, 5));
434
435       In previous versions, this would print "hello", but it now prints
436       "g'bye".
437
438   <> now reads in records
439       If $/ is a reference to an integer, or a scalar that holds an integer,
440       <> will read in records instead of lines. For more info, see "$/" in
441       perlvar.
442

Supported Platforms

444       Configure has many incremental improvements.  Site-wide policy for
445       building perl can now be made persistent, via Policy.sh.  Configure
446       also records the command-line arguments used in config.sh.
447
448   New Platforms
449       BeOS is now supported.  See README.beos.
450
451       DOS is now supported under the DJGPP tools.  See README.dos (installed
452       as perldos on some systems).
453
454       MiNT is now supported.  See README.mint.
455
456       MPE/iX is now supported.  See README.mpeix.
457
458       MVS (aka OS390, aka Open Edition) is now supported.  See README.os390
459       (installed as perlos390 on some systems).
460
461       Stratus VOS is now supported.  See README.vos.
462
463   Changes in existing support
464       Win32 support has been vastly enhanced.  Support for Perl Object, a C++
465       encapsulation of Perl.  GCC and EGCS are now supported on Win32.  See
466       README.win32, aka perlwin32.
467
468       VMS configuration system has been rewritten.  See README.vms (installed
469       as README_vms on some systems).
470
471       The hints files for most Unix platforms have seen incremental
472       improvements.
473

Modules and Pragmata

475   New Modules
476       B   Perl compiler and tools.  See B.
477
478       Data::Dumper
479           A module to pretty print Perl data.  See Data::Dumper.
480
481       Dumpvalue
482           A module to dump perl values to the screen. See Dumpvalue.
483
484       Errno
485           A module to look up errors more conveniently.  See Errno.
486
487       File::Spec
488           A portable API for file operations.
489
490       ExtUtils::Installed
491           Query and manage installed modules.
492
493       ExtUtils::Packlist
494           Manipulate .packlist files.
495
496       Fatal
497           Make functions/builtins succeed or die.
498
499       IPC::SysV
500           Constants and other support infrastructure for System V IPC
501           operations in perl.
502
503       Test
504           A framework for writing test suites.
505
506       Tie::Array
507           Base class for tied arrays.
508
509       Tie::Handle
510           Base class for tied handles.
511
512       Thread
513           Perl thread creation, manipulation, and support.
514
515       attrs
516           Set subroutine attributes.
517
518       fields
519           Compile-time class fields.
520
521       re  Various pragmata to control behavior of regular expressions.
522
523   Changes in existing modules
524       Benchmark
525           You can now run tests for x seconds instead of guessing the right
526           number of tests to run.
527
528           Keeps better time.
529
530       Carp
531           Carp has a new function cluck(). cluck() warns, like carp(), but
532           also adds a stack backtrace to the error message, like confess().
533
534       CGI CGI has been updated to version 2.42.
535
536       Fcntl
537           More Fcntl constants added: F_SETLK64, F_SETLKW64, O_LARGEFILE for
538           large (more than 4G) file access (the 64-bit support is not yet
539           working, though, so no need to get overly excited),
540           Free/Net/OpenBSD locking behaviour flags F_FLOCK, F_POSIX, Linux
541           F_SHLCK, and O_ACCMODE: the mask of O_RDONLY, O_WRONLY, and O_RDWR.
542
543       Math::Complex
544           The accessors methods Re, Im, arg, abs, rho, theta, methods can
545           ($z->Re()) now also act as mutators ($z->Re(3)).
546
547       Math::Trig
548           A little bit of radial trigonometry (cylindrical and spherical)
549           added, for example the great circle distance.
550
551       POSIX
552           POSIX now has its own platform-specific hints files.
553
554       DB_File
555           DB_File supports version 2.x of Berkeley DB.  See
556           "ext/DB_File/Changes".
557
558       MakeMaker
559           MakeMaker now supports writing empty makefiles, provides a way to
560           specify that site umask() policy should be honored.  There is also
561           better support for manipulation of .packlist files, and getting
562           information about installed modules.
563
564           Extensions that have both architecture-dependent and architecture-
565           independent files are now always installed completely in the
566           architecture-dependent locations.  Previously, the shareable parts
567           were shared both across architectures and across perl versions and
568           were therefore liable to be overwritten with newer versions that
569           might have subtle incompatibilities.
570
571       CPAN
572           See perlmodinstall and CPAN.
573
574       Cwd Cwd::cwd is faster on most platforms.
575

Utility Changes

577       "h2ph" and related utilities have been vastly overhauled.
578
579       "perlcc", a new experimental front end for the compiler is available.
580
581       The crude GNU "configure" emulator is now called "configure.gnu" to
582       avoid trampling on "Configure" under case-insensitive filesystems.
583
584       "perldoc" used to be rather slow.  The slower features are now
585       optional.  In particular, case-insensitive searches need the "-i"
586       switch, and recursive searches need "-r".  You can set these switches
587       in the "PERLDOC" environment variable to get the old behavior.
588

Documentation Changes

590       Config.pm now has a glossary of variables.
591
592       Porting/patching.pod has detailed instructions on how to create and
593       submit patches for perl.
594
595       perlport specifies guidelines on how to write portably.
596
597       perlmodinstall describes how to fetch and install modules from "CPAN"
598       sites.
599
600       Some more Perl traps are documented now.  See perltrap.
601
602       perlopentut gives a tutorial on using open().
603
604       perlreftut gives a tutorial on references.
605
606       perlthrtut gives a tutorial on threads.
607

New Diagnostics

609       Ambiguous call resolved as CORE::%s(), qualify as such or use &
610           (W) A subroutine you have declared has the same name as a Perl
611           keyword, and you have used the name without qualification for
612           calling one or the other.  Perl decided to call the builtin because
613           the subroutine is not imported.
614
615           To force interpretation as a subroutine call, either put an
616           ampersand before the subroutine name, or qualify the name with its
617           package.  Alternatively, you can import the subroutine (or pretend
618           that it's imported with the "use subs" pragma).
619
620           To silently interpret it as the Perl operator, use the "CORE::"
621           prefix on the operator (e.g. CORE::log($x)) or by declaring the
622           subroutine to be an object method (see "attrs").
623
624       Bad index while coercing array into hash
625           (F) The index looked up in the hash found as the 0'th element of a
626           pseudo-hash is not legal.  Index values must be at 1 or greater.
627           See perlref.
628
629       Bareword "%s" refers to nonexistent package
630           (W) You used a qualified bareword of the form "Foo::", but the
631           compiler saw no other uses of that namespace before that point.
632           Perhaps you need to predeclare a package?
633
634       Can't call method "%s" on an undefined value
635           (F) You used the syntax of a method call, but the slot filled by
636           the object reference or package name contains an undefined value.
637           Something like this will reproduce the error:
638
639               $BADREF = 42;
640               process $BADREF 1,2,3;
641               $BADREF->process(1,2,3);
642
643       Can't check filesystem of script "%s" for nosuid
644           (P) For some reason you can't check the filesystem of the script
645           for nosuid.
646
647       Can't coerce array into hash
648           (F) You used an array where a hash was expected, but the array has
649           no information on how to map from keys to array indices.  You can
650           do that only with arrays that have a hash reference at index 0.
651
652       Can't goto subroutine from an eval-string
653           (F) The "goto subroutine" call can't be used to jump out of an eval
654           "string".  (You can use it to jump out of an eval {BLOCK}, but you
655           probably don't want to.)
656
657       Can't localize pseudo-hash element
658           (F) You said something like "local $ar->{'key'}", where $ar is a
659           reference to a pseudo-hash.  That hasn't been implemented yet, but
660           you can get a similar effect by localizing the corresponding array
661           element directly: "local $ar->[$ar->[0]{'key'}]".
662
663       Can't use %%! because Errno.pm is not available
664           (F) The first time the %! hash is used, perl automatically loads
665           the Errno.pm module. The Errno module is expected to tie the %!
666           hash to provide symbolic names for $! errno values.
667
668       Cannot find an opnumber for "%s"
669           (F) A string of a form "CORE::word" was given to prototype(), but
670           there is no builtin with the name "word".
671
672       Character class syntax [. .] is reserved for future extensions
673           (W) Within regular expression character classes ([]) the syntax
674           beginning with "[." and ending with ".]" is reserved for future
675           extensions.  If you need to represent those character sequences
676           inside a regular expression character class, just quote the square
677           brackets with the backslash: "\[." and ".\]".
678
679       Character class syntax [: :] is reserved for future extensions
680           (W) Within regular expression character classes ([]) the syntax
681           beginning with "[:" and ending with ":]" is reserved for future
682           extensions.  If you need to represent those character sequences
683           inside a regular expression character class, just quote the square
684           brackets with the backslash: "\[:" and ":\]".
685
686       Character class syntax [= =] is reserved for future extensions
687           (W) Within regular expression character classes ([]) the syntax
688           beginning with "[=" and ending with "=]" is reserved for future
689           extensions.  If you need to represent those character sequences
690           inside a regular expression character class, just quote the square
691           brackets with the backslash: "\[=" and "=\]".
692
693       %s: Eval-group in insecure regular expression
694           (F) Perl detected tainted data when trying to compile a regular
695           expression that contains the "(?{ ... })" zero-width assertion,
696           which is unsafe.  See "(?{ code })" in perlre, and perlsec.
697
698       %s: Eval-group not allowed, use re 'eval'
699           (F) A regular expression contained the "(?{ ... })" zero-width
700           assertion, but that construct is only allowed when the "use re
701           'eval'" pragma is in effect.  See "(?{ code })" in perlre.
702
703       %s: Eval-group not allowed at run time
704           (F) Perl tried to compile a regular expression containing the "(?{
705           ... })" zero-width assertion at run time, as it would when the
706           pattern contains interpolated values.  Since that is a security
707           risk, it is not allowed.  If you insist, you may still do this by
708           explicitly building the pattern from an interpolated string at run
709           time and using that in an eval().  See "(?{ code })" in perlre.
710
711       Explicit blessing to '' (assuming package main)
712           (W) You are blessing a reference to a zero length string.  This has
713           the effect of blessing the reference into the package main.  This
714           is usually not what you want.  Consider providing a default target
715           package, e.g. bless($ref, $p || 'MyPackage');
716
717       Illegal hex digit ignored
718           (W) You may have tried to use a character other than 0 - 9 or A - F
719           in a hexadecimal number.  Interpretation of the hexadecimal number
720           stopped before the illegal character.
721
722       No such array field
723           (F) You tried to access an array as a hash, but the field name used
724           is not defined.  The hash at index 0 should map all valid field
725           names to array indices for that to work.
726
727       No such field "%s" in variable %s of type %s
728           (F) You tried to access a field of a typed variable where the type
729           does not know about the field name.  The field names are looked up
730           in the %FIELDS hash in the type package at compile time.  The
731           %FIELDS hash is usually set up with the 'fields' pragma.
732
733       Out of memory during ridiculously large request
734           (F) You can't allocate more than 2^31+"small amount" bytes.  This
735           error is most likely to be caused by a typo in the Perl program.
736           e.g., $arr[time] instead of $arr[$time].
737
738       Range iterator outside integer range
739           (F) One (or both) of the numeric arguments to the range operator
740           ".."  are outside the range which can be represented by integers
741           internally.  One possible workaround is to force Perl to use
742           magical string increment by prepending "0" to your numbers.
743
744       Recursive inheritance detected while looking for method '%s' %s
745           (F) More than 100 levels of inheritance were encountered while
746           invoking a method.  Probably indicates an unintended loop in your
747           inheritance hierarchy.
748
749       Reference found where even-sized list expected
750           (W) You gave a single reference where Perl was expecting a list
751           with an even number of elements (for assignment to a hash). This
752           usually means that you used the anon hash constructor when you
753           meant to use parens. In any case, a hash requires key/value pairs.
754
755               %hash = { one => 1, two => 2, };   # WRONG
756               %hash = [ qw/ an anon array / ];   # WRONG
757               %hash = ( one => 1, two => 2, );   # right
758               %hash = qw( one 1 two 2 );                 # also fine
759
760       Undefined value assigned to typeglob
761           (W) An undefined value was assigned to a typeglob, a la "*foo =
762           undef".  This does nothing.  It's possible that you really mean
763           "undef *foo".
764
765       Use of reserved word "%s" is deprecated
766           (D) The indicated bareword is a reserved word.  Future versions of
767           perl may use it as a keyword, so you're better off either
768           explicitly quoting the word in a manner appropriate for its context
769           of use, or using a different name altogether.  The warning can be
770           suppressed for subroutine names by either adding a "&" prefix, or
771           using a package qualifier, e.g. &our(), or Foo::our().
772
773       perl: warning: Setting locale failed.
774           (S) The whole warning message will look something like:
775
776                  perl: warning: Setting locale failed.
777                  perl: warning: Please check that your locale settings:
778                          LC_ALL = "En_US",
779                          LANG = (unset)
780                      are supported and installed on your system.
781                  perl: warning: Falling back to the standard locale ("C").
782
783           Exactly what were the failed locale settings varies.  In the above
784           the settings were that the LC_ALL was "En_US" and the LANG had no
785           value.  This error means that Perl detected that you and/or your
786           system administrator have set up the so-called variable system but
787           Perl could not use those settings.  This was not dead serious,
788           fortunately: there is a "default locale" called "C" that Perl can
789           and will use, the script will be run.  Before you really fix the
790           problem, however, you will get the same error message each time you
791           run Perl.  How to really fix the problem can be found in "LOCALE
792           PROBLEMS" in perllocale.
793

Obsolete Diagnostics

795       Can't mktemp()
796           (F) The mktemp() routine failed for some reason while trying to
797           process a -e switch.  Maybe your /tmp partition is full, or
798           clobbered.
799
800           Removed because -e doesn't use temporary files any more.
801
802       Can't write to temp file for -e: %s
803           (F) The write routine failed for some reason while trying to
804           process a -e switch.  Maybe your /tmp partition is full, or
805           clobbered.
806
807           Removed because -e doesn't use temporary files any more.
808
809       Cannot open temporary file
810           (F) The create routine failed for some reason while trying to
811           process a -e switch.  Maybe your /tmp partition is full, or
812           clobbered.
813
814           Removed because -e doesn't use temporary files any more.
815
816       regexp too big
817           (F) The current implementation of regular expressions uses shorts
818           as address offsets within a string.  Unfortunately this means that
819           if the regular expression compiles to longer than 32767, it'll blow
820           up.  Usually when you want a regular expression this big, there is
821           a better way to do it with multiple statements.  See perlre.
822

Configuration Changes

824       You can use "Configure -Uinstallusrbinperl" which causes installperl to
825       skip installing perl also as /usr/bin/perl.  This is useful if you
826       prefer not to modify /usr/bin for some reason or another but harmful
827       because many scripts assume to find Perl in /usr/bin/perl.
828

BUGS

830       If you find what you think is a bug, you might check the headers of
831       recently posted articles in the comp.lang.perl.misc newsgroup.  There
832       may also be information at http://www.perl.com/perl/ , the Perl Home
833       Page.
834
835       If you believe you have an unreported bug, please run the perlbug
836       program included with your release.  Make sure you trim your bug down
837       to a tiny but sufficient test case.  Your bug report, along with the
838       output of "perl -V", will be sent off to <perlbug@perl.com> to be
839       analysed by the Perl porting team.
840

SEE ALSO

842       The Changes file for exhaustive details on what changed.
843
844       The INSTALL file for how to build Perl.
845
846       The README file for general stuff.
847
848       The Artistic and Copying files for copyright information.
849

HISTORY

851       Written by Gurusamy Sarathy <gsar@activestate.com>, with many
852       contributions from The Perl Porters.
853
854       Send omissions or corrections to <perlbug@perl.com>.
855
856
857
858perl v5.38.2                      2023-11-30                  PERL5005DELTA(1)
Impressum